Debian Codegraph @

ipl/packs/idol/itags.iol

raw
1 # itags - an Icon/Idol tag generator by Nick Kline
2 # hacks (such as this header comment) by Clint Jeffery
3 # last edit: 12/13/89
4 #
5 # the output is a sorted list of lines of the form
6 # identifier owning_scope category_type filename lineno(:length)
7 #
8 # owning scope is the name of the class or procedure or record in which
9 # the tag is defined.
10 # category type is the kind of tag; one of:
11 # (global,procedure,record,class,method,param,obj_field,rec_field)
12 #
13 global ibrowseflag
14
15 procedure main(args)
16 local line, lineno, fout, i, fin, notvar, objects, actual_file, outlines
17
18 initial {
19 fout := open("ITAGS", "w") | stop("can't open ITAGS for writing");
20 outlines := [[0,0,0,0,0,0]]
21 i := 1
22 notid := &cset -- &ucase -- &digits -- &lcase -- '_'
23 }
24
25 if(*args=0) then
26 stop("usage: itags file1 [file2 ...]")
27
28 while i <= *args do {
29 if args[i] == "-i" then {
30 ibrowseflag := 1
31 i +:= 1
32 continue
33 }
34 fin := open(args[i],"r") |
35 stop("could not open file ",args[i]," exiting")
36 lineno := 1
37 objects := program( args[i] )
38
39 while line := read(fin) do {
40 line[upto('#',line):0] := ""
41 line ? {
42 tab(many(' '))
43
44 if =("global") then {
45 if(any(notid)) then
46 every objects$addvar( getword(), lineno )
47 }
48
49 if =("procedure") then
50 if(any(notid)) then {
51 objects$addproc( getword(), lineno )
52 objects$myline(tab(0),lineno)
53 }
54
55
56 if =("class") then
57 if any(notid) then {
58 objects$addclass( getword(), lineno )
59 objects$myline(tab(0),lineno)
60 }
61
62
63 if =("method") then {
64 if any(notid) then {
65 objects$addmethod( getword(), lineno )
66 objects$myline(tab(0),lineno)
67 }
68 }
69
70 if =("local") then {
71 if any(notid) then
72 every objects$addvar( getword(), lineno )
73 }
74
75 if =("static") then {
76 if any(notid) then
77 every objects$addstat( getword(), lineno )
78 }
79
80 if =("record") then {
81 if any(notid) then {
82 objects$addrec( getword(), lineno )
83 objects$myline(tab(0),lineno)
84 objects$endline( lineno)
85 }
86 }
87 if =("end") then
88 objects$endline(lineno)
89 }
90 lineno +:= 1
91 }
92 objects$drawthyself(outlines)
93 i +:= 1
94 }
95 # now process all the resulting lines
96 every i := 2 to *outlines do {
97 outlines[i] := (
98 left(outlines[i][1],outlines[1][1]+1) ||
99 left(outlines[i][2],outlines[1][2]+1) ||
100 left(outlines[i][3],outlines[1][3]+1) ||
101 left(outlines[i][4],outlines[1][4]+1) ||
102 left(outlines[i][5],outlines[1][5]) ||
103 (if \outlines[i][6] then ":"||outlines[i][6] else ""))
104 }
105 outlines := outlines[2:0]
106 outlines := sort(outlines)
107 every write(fout,!outlines)
108 end
109
110 class functions(name, lineno,vars,lastline, parent, params,stat,paramtype)
111
112 method drawthyself(outfile)
113 local k
114 every k := !self.vars do
115 emit(outfile, k[1], self.name, "local", self.parent$myfile(),k[2])
116 every k := !self.params do
117 emit(outfile, k[1], self.name, self.paramtype, self.parent$myfile(),k[2])
118 every k := !self.stat do
119 emit(outfile, k[1], self.name, "static", self.parent$myfile(),k[2])
120 end
121
122 method myline(line,lineno)
123 local word
124 static ids, letters
125 initial {
126 ids := &lcase ++ &ucase ++ &digits ++ '_'
127 letters := &ucase ++ &lcase
128 }
129
130 line ? while tab(upto(letters)) do {
131 word := tab(many(ids))
132 self.params|||:= [[word,lineno]]
133 }
134
135 end
136
137 method addstat(varname, lineno)
138 self.stat|||:=[[varname, lineno]]
139 return
140 end
141
142 method addvar(varname, lineno)
143 self.vars|||:=[[varname, lineno]]
144 return
145 end
146
147 method endline( lineno )
148 self.lastline := lineno
149 end
150
151 method resetcontext()
152 self.parent$resetcontext()
153 end
154
155 initially
156 self.vars := []
157 self.params := []
158 self.stat := []
159 self.paramtype := "param"
160 end # end of class functions
161
162
163 class proc : functions(name,lineno, parent,paramtype)
164
165 method drawthyself(outfile)
166 emit(outfile,self.name, "*" , "procedure", self.parent$myfile(),self.lineno, self.lastline-self.lineno+1)
167 self$functions.drawthyself(outfile)
168 end
169 initially
170 self.paramtype := "param"
171 end # of class proc
172
173 class rec : functions(name, lineno, parent, line, paramtype)
174
175 method drawthyself(outfile)
176 emit(outfile,self.name, "*", "record", self.parent$myfile(),
177 self.lineno)
178 self$functions.drawthyself(outfile)
179 end
180 initially
181 self.paramtype := "rec_field"
182 end # class record
183
184
185
186 class program(public myfile, vars, proc, records, classes, curcontext, contextsave,globals)
187
188 method endline( lineno )
189 self.curcontext$endline( lineno )
190 self.curcontext := pop(self.contextsave)
191 end
192
193 method myline( line,lineno)
194 self.curcontext$myline( line,lineno)
195 end
196
197 method drawthyself(outfile)
198 every k := !self.globals do
199 emit(outfile,k[1], "*", "global", self.myfile,k[2])
200 every (!self.proc)$drawthyself(outfile)
201 every (!self.records)$drawthyself(outfile)
202 every (!self.classes)$drawthyself(outfile)
203 end
204
205 method addmethod(name, lineno)
206 push(self.contextsave,self.curcontext)
207 self.curcontext := self.curcontext$addmethod(name,lineno)
208 return
209 end
210
211 method addstat(varname, lineno)
212 self.curcontext$addstat(varname, lineno)
213 end
214
215 method addvar(varname, lineno)
216 if self.curcontext === self
217 then self.globals|||:= [[varname,lineno]]
218 else self.curcontext$addvar(varname,lineno)
219 return
220 end
221
222 method addproc(procname, lineno)
223 push(self.contextsave, self.curcontext)
224 self.curcontext := proc(procname, lineno, self)
225 self.proc|||:= [self.curcontext]
226 return
227 end
228
229 method addrec(recname, lineno)
230 push(self.contextsave, self.curcontext)
231 self.curcontext := rec(recname, lineno,self)
232 self.records|||:=[self.curcontext]
233 return
234 end
235
236 method addclass(classname, lineno)
237 push(self.contextsave, self.curcontext)
238 self.curcontext := class_(classname, lineno, self)
239 self.classes|||:=[self.curcontext]
240 return
241 end
242
243 method resetcontext()
244 self.curcontext := pop(self.contextsave)
245 end
246
247 initially
248 self.globals := []
249 self.proc := []
250 self.records := []
251 self.classes := []
252 self.curcontext := self
253 self.contextsave := []
254 end # end of class program
255
256
257
258 class class_ : functions (public name, lineno, parent, meth,paramtype)
259
260 method myfile()
261 return self.parent$myfile()
262 end
263
264 method addmethod(methname, lineno)
265 self.meth|||:= [methods(methname, lineno, self)]
266 return (self.meth[-1])
267 end
268
269 method drawthyself(outfile)
270 emit(outfile,self.name, "*" , "class", self.parent$myfile(),self.lineno, self.lastline-self.lineno+1)
271 every (!self.meth)$drawthyself(outfile)
272 self$functions.drawthyself(outfile)
273 end
274
275 initially
276 self.meth := []
277 self.paramtype := "obj_field"
278 end #end of class_
279
280 class methods: functions(name, lineno, parent,paramtype)
281 method drawthyself(outfile)
282 emit(outfile,self.name, self.parent$name() , "method", self.parent$myfile(),self.lineno, self.lastline-self.lineno+1)
283 self$functions.drawthyself(outfile)
284 end
285 initially
286 self.paramtype := "param"
287 end #end of members class
288
289 procedure emit(outlist,ident, scope, type, filename, line, length)
290 outlist[1][1] := outlist[1][1] < *ident
291 outlist[1][2] := outlist[1][2] < *scope
292 outlist[1][3] := outlist[1][3] < *type
293 outlist[1][4] := outlist[1][4] < *filename
294 outlist[1][5] := outlist[1][5] < *line
295 outlist[1][6] := outlist[1][6] < *\length
296 if /ibrowseflag then
297 put( outlist, [ident,scope,type,filename,line,length] )
298 else
299 put( outlist, [ident,scope,type,filename,line,length] )
300 end
301
302
303 procedure getword()
304 local word
305 static ids,letts
306 initial {
307 ids := &ucase ++ &lcase ++ &digits ++ '_'
308 letts := &ucase ++ &lcase
309 }
310
311 while tab(upto(letts)) do {
312 word := tab(many(ids))
313 suspend word
314 }
315
316 end