| 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 |