| 1 |
# |
| 2 |
# global variables |
| 3 |
# |
| 4 |
global fin,fout,fName,fLine,alpha,alphadot,white,nonwhite,nonalpha |
| 5 |
global classes,comp,exec,strict,links,imports,loud,compiles,compatible,ct |
| 6 |
# |
| 7 |
# gencode first generates specifications for all defined classes |
| 8 |
# It then imports those classes' specifications which it needs to |
| 9 |
# compute inheritance. Finally, it writes out all classes' .icn files. |
| 10 |
# |
| 11 |
procedure gencode() |
| 12 |
if \loud then write("Class import/export:") |
| 13 |
# |
| 14 |
# export specifications for each class |
| 15 |
# |
| 16 |
every cl := classes$foreach_t() do cl$writespec() |
| 17 |
# |
| 18 |
# import class specifications, transitively |
| 19 |
# |
| 20 |
repeat { |
| 21 |
added := 0 |
| 22 |
every super:= ((classes$foreach_t())$foreachsuper() | !imports) do{ |
| 23 |
if /classes$lookup(super) then { |
| 24 |
added := 1 |
| 25 |
fname := filename(super) |
| 26 |
readinput(envpath(fname),2) |
| 27 |
if /classes$lookup(super) then halt("can't import class '",super,"'") |
| 28 |
writesublink(fname) |
| 29 |
} |
| 30 |
} |
| 31 |
if added = 0 then break |
| 32 |
} |
| 33 |
# |
| 34 |
# compute the transitive closure of the superclass graph |
| 35 |
# |
| 36 |
every (classes$foreach_t())$transitive_closure() |
| 37 |
# |
| 38 |
# generate output |
| 39 |
# |
| 40 |
if \loud then write("Generating code:") |
| 41 |
writesublink("i_object") |
| 42 |
every s := !links do writelink(s) |
| 43 |
write(fout) |
| 44 |
every out := $!classes do { |
| 45 |
name := filename(out$name()) |
| 46 |
out$write() |
| 47 |
put(compiles,name) |
| 48 |
writesublink(name) |
| 49 |
} |
| 50 |
if *compiles>0 then return cdicont(compiles) |
| 51 |
else return |
| 52 |
end |
| 53 |
|
| 54 |
# |
| 55 |
# a class defining objects resulting from parsing lines of the form |
| 56 |
# tag name ( field1 , field2, ... ) |
| 57 |
# If the constructor is given an argument, it is passed to self$read |
| 58 |
# |
| 59 |
class declaration(public name,fields,tag) |
| 60 |
# |
| 61 |
# parse a declaration string into its components |
| 62 |
# |
| 63 |
method read(decl) |
| 64 |
decl ? ( |
| 65 |
(tab(many(white)) | "") , |
| 66 |
# get my tag |
| 67 |
(self.tag := =("procedure"|"class"|"method"|"record")) , |
| 68 |
(tab(many(white)) | "") , |
| 69 |
# get my name |
| 70 |
(self.name := tab(many(alpha))) , |
| 71 |
# get my fields |
| 72 |
(tab(find("(")+1)), |
| 73 |
(tab(many(white)) | "") , |
| 74 |
((self.fields := classFields())$parse(tab(find(")")))) |
| 75 |
) | halt("declaration/read can't parse decl ",decl) |
| 76 |
end |
| 77 |
|
| 78 |
# |
| 79 |
# write a declaration; at the moment, only used by records |
| 80 |
# |
| 81 |
method write(f) |
| 82 |
write(f,self$String()) |
| 83 |
end |
| 84 |
# |
| 85 |
# convert self to a string |
| 86 |
# |
| 87 |
method String() |
| 88 |
return self.tag || " " || self.name || "(" || self.fields$String() || ")" |
| 89 |
end |
| 90 |
initially |
| 91 |
if \self.name then self$read(self.name) |
| 92 |
end |
| 93 |
|
| 94 |
# |
| 95 |
# A class for ordinary Icon global declarations |
| 96 |
# |
| 97 |
class vardecl(s) |
| 98 |
method write(f) |
| 99 |
write(f,self.s) |
| 100 |
end |
| 101 |
end |
| 102 |
|
| 103 |
# |
| 104 |
# A class defining the constants for a given scope |
| 105 |
# |
| 106 |
class constant(t) |
| 107 |
method expand(s) |
| 108 |
i := 1 |
| 109 |
# |
| 110 |
# conditions for expanding a constant: |
| 111 |
# must not be within a larger identifier nor within a quote |
| 112 |
# |
| 113 |
while ((i <- find(k <- $!self,s,i)) & ((i=1) | any(nonalpha,s[i-1])) & |
| 114 |
((*s = i+*k-1) | any(nonalpha,s[i+*k])) & |
| 115 |
notquote(s[1:i])) do { |
| 116 |
val := \ (self.t[k]) | stop("internal error in expand") |
| 117 |
s[i +: *k] := val |
| 118 |
# i +:= *val |
| 119 |
} |
| 120 |
return s |
| 121 |
end |
| 122 |
method foreach() # in this case, we mean the keys, not the values |
| 123 |
suspend key(self.t) |
| 124 |
end |
| 125 |
method eval(s) |
| 126 |
if s2 := \ self.t[s] then return s2 |
| 127 |
end |
| 128 |
method parse(s) |
| 129 |
s ? { |
| 130 |
k := trim(tab(find(":="))) | fail |
| 131 |
move(2) |
| 132 |
tab(many(white)) |
| 133 |
val := tab(0) | fail |
| 134 |
(*val > 0) | fail |
| 135 |
self.t [ k ] := val |
| 136 |
} |
| 137 |
return |
| 138 |
end |
| 139 |
method append(cd) |
| 140 |
every s := cd$parse do self$parse(s) |
| 141 |
end |
| 142 |
initially |
| 143 |
self.t := table() |
| 144 |
end |
| 145 |
|
| 146 |
# |
| 147 |
# A class defining a single constant declaration |
| 148 |
# |
| 149 |
class constdcl : vardecl() |
| 150 |
# suspend the individual constant := value strings |
| 151 |
method parse() |
| 152 |
self.s ? { |
| 153 |
tab(find("const")+6) |
| 154 |
tab(many(white)) |
| 155 |
while s2 := trim(tab(find(","))) do { |
| 156 |
suspend s2 |
| 157 |
move(1) |
| 158 |
tab(many(white)) |
| 159 |
} |
| 160 |
suspend trim(tab(0)) |
| 161 |
} |
| 162 |
end |
| 163 |
end |
| 164 |
|
| 165 |
# |
| 166 |
# class body manages a list of strings holding the code for |
| 167 |
# procedures/methods/classes |
| 168 |
# |
| 169 |
class body(fn,ln,vars,text) |
| 170 |
method read() |
| 171 |
self.fn := fName |
| 172 |
self.ln := fLine |
| 173 |
self.text := [] |
| 174 |
while line := readln() do { |
| 175 |
put(self.text, line) |
| 176 |
line ? { |
| 177 |
tab(many(white)) |
| 178 |
if ="end" & &pos > *line then return |
| 179 |
else if =("local"|"static"|"initial") & any(nonalpha) then { |
| 180 |
self.ln +:= 1 |
| 181 |
pull(self.text) |
| 182 |
/ (self.vars) := [] |
| 183 |
put(self.vars, line) |
| 184 |
} |
| 185 |
} |
| 186 |
} |
| 187 |
halt("body/read: eof inside a procedure/method definition") |
| 188 |
end |
| 189 |
method write(f) |
| 190 |
if \self.vars then every write(f,!self.vars) |
| 191 |
if \compatible then write(f," \\self := self.__state") |
| 192 |
if \self.ln then |
| 193 |
write(f,"#line ",self.ln + ((*\self.vars)|0)," \"",self.fn,"\"") |
| 194 |
every write(f,$!self) |
| 195 |
end |
| 196 |
method delete() |
| 197 |
return pull(self.text) |
| 198 |
end |
| 199 |
method size() |
| 200 |
return (*\ (self.text)) | 0 |
| 201 |
end |
| 202 |
method foreach() |
| 203 |
if t := \self.text then suspend !self.text |
| 204 |
end |
| 205 |
end |
| 206 |
|
| 207 |
# |
| 208 |
# a class defining operations on classes |
| 209 |
# |
| 210 |
class class : declaration (supers,methods,text,imethods,ifields,glob) |
| 211 |
# imethods and ifields are all lists of these: |
| 212 |
record classident(class,ident) |
| 213 |
|
| 214 |
method read(line,phase) |
| 215 |
self$declaration.read(line) |
| 216 |
self.supers := idTaque(":") |
| 217 |
self.supers$parse(line[find(":",line)+1:find("(",line)] | "") |
| 218 |
self.methods:= taque() |
| 219 |
self.text := body() |
| 220 |
while line := readln("wrap") do { |
| 221 |
line ? { |
| 222 |
tab(many(white)) |
| 223 |
if ="initially" then { |
| 224 |
self.text$read() |
| 225 |
if phase=2 then return |
| 226 |
self.text$delete() # "end" appended manually during writing after |
| 227 |
# generation of the appropriate return value |
| 228 |
return |
| 229 |
} else if ="method" then { |
| 230 |
decl := method(self.name) |
| 231 |
decl$read(line,phase) |
| 232 |
self.methods$insert(decl,decl$name()) |
| 233 |
} else if ="end" then { |
| 234 |
# "end" is tossed here. see "initially" above |
| 235 |
return |
| 236 |
} else if ="procedure" then { |
| 237 |
decl := method("") |
| 238 |
decl$read(line,phase) |
| 239 |
/self.glob := [] |
| 240 |
put(self.glob,decl) |
| 241 |
} else if ="global" then { |
| 242 |
/self.glob := [] |
| 243 |
put(self.glob,vardecl(line)) |
| 244 |
} else if ="record" then { |
| 245 |
/self.glob := [] |
| 246 |
put(self.glob,declaration(line)) |
| 247 |
} else if upto(nonwhite) then { |
| 248 |
halt("class/read expected declaration on: ",line) |
| 249 |
} |
| 250 |
} |
| 251 |
} |
| 252 |
halt("class/read syntax error: eof inside a class definition") |
| 253 |
end |
| 254 |
|
| 255 |
# |
| 256 |
# Miscellaneous methods on classes |
| 257 |
# |
| 258 |
method has_initially() |
| 259 |
return $*self.text > 0 |
| 260 |
end |
| 261 |
method ispublic(fieldname) |
| 262 |
if self.fields$ispublic(fieldname) then return fieldname |
| 263 |
end |
| 264 |
method foreachmethod() |
| 265 |
suspend $!self.methods |
| 266 |
end |
| 267 |
method foreachsuper() |
| 268 |
suspend $!self.supers |
| 269 |
end |
| 270 |
method foreachfield() |
| 271 |
suspend $!self.fields |
| 272 |
end |
| 273 |
method isvarg(s) |
| 274 |
if self.fields$isvarg(s) then return s |
| 275 |
end |
| 276 |
method transitive_closure() |
| 277 |
count := $*self.supers |
| 278 |
while count > 0 do { |
| 279 |
added := taque() |
| 280 |
every sc := $!self.supers do { |
| 281 |
if /(super := classes$lookup(sc)) then |
| 282 |
halt("class/transitive_closure: couldn't find superclass ",sc) |
| 283 |
every supersuper := super$foreachsuper() do { |
| 284 |
if / self.supers$lookup(supersuper) & |
| 285 |
/added$lookup(supersuper) then { |
| 286 |
added$insert(supersuper) |
| 287 |
} |
| 288 |
} |
| 289 |
} |
| 290 |
count := $*added |
| 291 |
every self.supers$insert($!added) |
| 292 |
} |
| 293 |
end |
| 294 |
# |
| 295 |
# write the class declaration: if s is "class" write as a spec |
| 296 |
# otherwise, write as a constructor |
| 297 |
# |
| 298 |
method writedecl(f,s) |
| 299 |
writes(f, s," ",self.name) |
| 300 |
if s=="class" & ( *(supers := self.supers$String()) > 0 ) then |
| 301 |
writes(f," : ",supers) |
| 302 |
writes(f,"(") |
| 303 |
rv := self.fields$String(s) |
| 304 |
if *rv > 0 then rv ||:= "," |
| 305 |
if s~=="class" & *(\self.ifields)>0 then { # inherited fields |
| 306 |
every l := !self.ifields do rv ||:= l.ident || "," |
| 307 |
if /(superclass := classes$lookup(l.class)) then |
| 308 |
halt("class/resolve: couldn't find superclass ",sc) |
| 309 |
if superclass$isvarg(l.ident) then rv := rv[1:-1]||"[]," |
| 310 |
} |
| 311 |
writes(f,rv[1:-1]) |
| 312 |
write(f,,")") |
| 313 |
end |
| 314 |
method writespec(f) # write the specification of a class |
| 315 |
f := envopen(filename(self.name),"w") |
| 316 |
self$writedecl(f,"class") |
| 317 |
every ($!self.methods)$writedecl(f,"method") |
| 318 |
if self$has_initially() then write(f,"initially") |
| 319 |
write(f,"end") |
| 320 |
close(f) |
| 321 |
end |
| 322 |
|
| 323 |
# |
| 324 |
# write out the Icon code for this class' explicit methods |
| 325 |
# and its "nested global" declarations (procedures, records, etc.) |
| 326 |
# |
| 327 |
method writemethods() |
| 328 |
f:= envopen(filename(self.name,".icn"),"w") |
| 329 |
every ($!self.methods)$write(f,self.name) |
| 330 |
|
| 331 |
if \self.glob & *self.glob>0 then { |
| 332 |
write(f,"#\n# globals declared within the class\n#") |
| 333 |
every i := 1 to *self.glob do (self.glob[i])$write(f,"") |
| 334 |
} |
| 335 |
close(f) |
| 336 |
end |
| 337 |
|
| 338 |
# |
| 339 |
# write - write an Icon implementation of a class to file f |
| 340 |
# |
| 341 |
method write() |
| 342 |
f:= envopen(filename(self.name,".icn"),"a") |
| 343 |
# |
| 344 |
# must have done inheritance computation to write things out |
| 345 |
# |
| 346 |
if /self.ifields then self$resolve() |
| 347 |
|
| 348 |
# |
| 349 |
# write a record containing the state variables |
| 350 |
# |
| 351 |
writes(f,"record ",self.name,"__state(__state,__methods") # reserved fields |
| 352 |
rv := "," |
| 353 |
rv ||:= self.fields$idTaque.String() # my fields |
| 354 |
if rv[-1] ~== "," then rv ||:= "," |
| 355 |
every s := (!self.ifields).ident do rv ||:= s || "," # inherited fields |
| 356 |
write(f,rv[1:-1],")") |
| 357 |
|
| 358 |
# |
| 359 |
# write a record containing the methods |
| 360 |
# |
| 361 |
writes(f,"record ",self.name,"__methods(") |
| 362 |
rv := "" |
| 363 |
|
| 364 |
every s := ((($!self.methods)$name()) | # my explicit methods |
| 365 |
self.fields$foreachpublic() | # my implicit methods |
| 366 |
(!self.imethods).ident | # my inherited methods |
| 367 |
$!self.supers) # super.method fields |
| 368 |
do rv ||:= s || "," |
| 369 |
|
| 370 |
if *rv>0 then rv[-1] := "" # trim trailling , |
| 371 |
write(f,rv,")") |
| 372 |
|
| 373 |
# |
| 374 |
# write a global containing this classes' operation record |
| 375 |
# along with declarations for all superclasses op records |
| 376 |
# |
| 377 |
writes(f,"global ",self.name,"__oprec") |
| 378 |
every writes(f,", ", $!self.supers,"__oprec") |
| 379 |
write(f) |
| 380 |
|
| 381 |
# |
| 382 |
# write the constructor procedure. |
| 383 |
# This is a long involved process starting with writing the declaration. |
| 384 |
# |
| 385 |
self$writedecl(f,"procedure") |
| 386 |
write(f,"local self,clone") |
| 387 |
|
| 388 |
# |
| 389 |
# initialize operation records for this and superclasses |
| 390 |
# |
| 391 |
write(f,"initial {\n", |
| 392 |
" if /",self.name,"__oprec then ",self.name,"initialize()") |
| 393 |
if $*self.supers > 0 then |
| 394 |
every (super <- $!self.supers) ~== self.name do |
| 395 |
write(f," if /",super,"__oprec then ",super,"initialize()\n", |
| 396 |
" ",self.name,"__oprec.",super," := ", super,"__oprec") |
| 397 |
write(f," }") |
| 398 |
|
| 399 |
# |
| 400 |
# create self, initialize from constructor parameters |
| 401 |
# |
| 402 |
writes(f," self := ",self.name,"__state(&null,",self.name,"__oprec") |
| 403 |
every writes(f,",",$!self.fields) |
| 404 |
if \self.ifields then every writes(f,",",(!self.ifields).ident) |
| 405 |
write(f,")\n self.__state := self") |
| 406 |
|
| 407 |
# |
| 408 |
# call my own initially section, if any |
| 409 |
# |
| 410 |
if $*self.text > 0 then write(f," ",self.name,"initially(self)") |
| 411 |
|
| 412 |
# |
| 413 |
# call superclasses' initially sections |
| 414 |
# |
| 415 |
if $*self.supers > 0 then { |
| 416 |
every (super <- $!self.supers) ~== self.name do { |
| 417 |
if (classes$lookup(super))$has_initially() then { |
| 418 |
if /madeclone := 1 then { |
| 419 |
write(f," clone := ",self.name,"__state()\n", |
| 420 |
" clone.__state := clone\n", |
| 421 |
" clone.__methods := ",self.name,"__oprec") |
| 422 |
} |
| 423 |
write(f," # inherited initialization from class ",super) |
| 424 |
write(f," every i := 2 to *self do clone[i] := self[i]\n", |
| 425 |
" ",super,"initially(clone)") |
| 426 |
every l := !self.ifields do { |
| 427 |
if l.class == super then |
| 428 |
write(f," self.",l.ident," := clone.",l.ident) |
| 429 |
} |
| 430 |
} |
| 431 |
} |
| 432 |
} |
| 433 |
|
| 434 |
# |
| 435 |
# return the pair that comprises the object: |
| 436 |
# a pointer to the instance (__mystate), and |
| 437 |
# a pointer to the class operation record |
| 438 |
# |
| 439 |
write(f," return idol_object(self,",self.name,"__oprec)\n", |
| 440 |
"end\n") |
| 441 |
|
| 442 |
# |
| 443 |
# write out class initializer procedure to initialize my operation record |
| 444 |
# |
| 445 |
write(f,"procedure ",self.name,"initialize()") |
| 446 |
writes(f," initial ",self.name,"__oprec := ",self.name,"__methods") |
| 447 |
rv := "(" |
| 448 |
every s := ($!self.methods)$name() do { # explicit methods |
| 449 |
if *rv>1 then rv ||:= "," |
| 450 |
rv ||:= self.name||"_"||s |
| 451 |
} |
| 452 |
every me := self.fields$foreachpublic() do { # implicit methods |
| 453 |
if *rv>1 then rv ||:= "," # (for public fields) |
| 454 |
rv ||:= self.name||"_"||me |
| 455 |
} |
| 456 |
every l := !self.imethods do { # inherited methods |
| 457 |
if *rv>1 then rv ||:= "," |
| 458 |
rv ||:= l.class||"_"||l.ident |
| 459 |
} |
| 460 |
write(f,rv,")\n","end") |
| 461 |
# |
| 462 |
# write out initially procedure, if any |
| 463 |
# |
| 464 |
if self$has_initially() then { |
| 465 |
write(f,"procedure ",self.name,"initially(self)") |
| 466 |
self.text$write(f) |
| 467 |
write(f,"end") |
| 468 |
} |
| 469 |
|
| 470 |
# |
| 471 |
# write out implicit methods for public fields |
| 472 |
# |
| 473 |
every me := self.fields$foreachpublic() do { |
| 474 |
write(f,"procedure ",self.name,"_",me,"(self)") |
| 475 |
if \strict then { |
| 476 |
write(f," if type(self.",me,") == ", |
| 477 |
"(\"list\"|\"table\"|\"set\"|\"record\") then\n", |
| 478 |
" runerr(501,\"idol: scalar type expected\")") |
| 479 |
} |
| 480 |
write(f," return .(self.",me,")") |
| 481 |
write(f,"end") |
| 482 |
write(f) |
| 483 |
} |
| 484 |
|
| 485 |
close(f) |
| 486 |
|
| 487 |
end |
| 488 |
|
| 489 |
# |
| 490 |
# resolve -- primary inheritance resolution utility |
| 491 |
# |
| 492 |
method resolve() |
| 493 |
# |
| 494 |
# these are lists of [class , ident] records |
| 495 |
# |
| 496 |
self.imethods := [] |
| 497 |
self.ifields := [] |
| 498 |
ipublics := [] |
| 499 |
addedfields := table() |
| 500 |
addedmethods := table() |
| 501 |
every sc := $!self.supers do { |
| 502 |
if /(superclass := classes$lookup(sc)) then |
| 503 |
halt("class/resolve: couldn't find superclass ",sc) |
| 504 |
every superclassfield := superclass$foreachfield() do { |
| 505 |
if /self.fields$lookup(superclassfield) & |
| 506 |
/addedfields[superclassfield] then { |
| 507 |
addedfields[superclassfield] := superclassfield |
| 508 |
put ( self.ifields , classident(sc,superclassfield) ) |
| 509 |
if superclass$ispublic(superclassfield) then |
| 510 |
put( ipublics, classident(sc,superclassfield) ) |
| 511 |
} else if \strict then { |
| 512 |
warn("class/resolve: '",sc,"' field '",superclassfield, |
| 513 |
"' is redeclared in subclass ",self.name) |
| 514 |
} |
| 515 |
} |
| 516 |
every superclassmethod := (superclass$foreachmethod())$name() do { |
| 517 |
if /self.methods$lookup(superclassmethod) & |
| 518 |
/addedmethods[superclassmethod] then { |
| 519 |
addedmethods[superclassmethod] := superclassmethod |
| 520 |
put ( self.imethods, classident(sc,superclassmethod) ) |
| 521 |
} |
| 522 |
} |
| 523 |
every public := (!ipublics) do { |
| 524 |
if public.class == sc then |
| 525 |
put (self.imethods, classident(sc,public.ident)) |
| 526 |
} |
| 527 |
} |
| 528 |
end |
| 529 |
end |
| 530 |
|
| 531 |
# |
| 532 |
# a class defining operations on methods and procedures |
| 533 |
# |
| 534 |
class method : declaration (class,text) |
| 535 |
method read(line,phase) |
| 536 |
self$declaration.read(line) |
| 537 |
self.text := body() |
| 538 |
if phase = 1 then |
| 539 |
self.text$read() |
| 540 |
end |
| 541 |
method writedecl(f,s) |
| 542 |
decl := self$String() |
| 543 |
if s == "method" then decl[1:upto(white,decl)] := "method" |
| 544 |
else { |
| 545 |
decl[1:upto(white,decl)] := "procedure" |
| 546 |
if *(self.class)>0 then { |
| 547 |
decl[upto(white,decl)] ||:= self.class||"_" |
| 548 |
i := find("(",decl) |
| 549 |
decl[i] ||:= "self" || (((decl[i+1] ~== ")"), ",") | "") |
| 550 |
} |
| 551 |
} |
| 552 |
write(f,decl) |
| 553 |
end |
| 554 |
method write(f) |
| 555 |
if self.name ~== "initially" then |
| 556 |
self$writedecl(f,"procedure") |
| 557 |
self.text$write(f) |
| 558 |
self.text := &null # after writing out text, forget it! |
| 559 |
end |
| 560 |
end |
| 561 |
|
| 562 |
# |
| 563 |
# a class corresponding to an Icon table, with special treatment of empties |
| 564 |
# |
| 565 |
class Table(t) |
| 566 |
method size() |
| 567 |
return (* \ self.t) | 0 |
| 568 |
end |
| 569 |
method insert(x,key) |
| 570 |
/self.t := table() |
| 571 |
/key := x |
| 572 |
if / (self.t[key]) := x then return |
| 573 |
end |
| 574 |
method lookup(key) |
| 575 |
if t := \self.t then return t[key] |
| 576 |
return |
| 577 |
end |
| 578 |
method foreach() |
| 579 |
if t := \self.t then every suspend !self.t |
| 580 |
end |
| 581 |
end |
| 582 |
|
| 583 |
# |
| 584 |
# tabular queues (taques): |
| 585 |
# a class defining objects which maintain synchronized list and table reps |
| 586 |
# Well, what is really provided are loosely-coordinated list/tables |
| 587 |
# |
| 588 |
class taque : Table (l) |
| 589 |
method insert(x,key) |
| 590 |
/self.l := [] |
| 591 |
if self$Table.insert(x,key) then put(self.l,x) |
| 592 |
end |
| 593 |
method foreach() |
| 594 |
if l := \self.l then every suspend !self.l |
| 595 |
end |
| 596 |
method insert_t(x,key) |
| 597 |
self$Table.insert(x,key) |
| 598 |
end |
| 599 |
method foreach_t() |
| 600 |
suspend self$Table.foreach() |
| 601 |
end |
| 602 |
end |
| 603 |
|
| 604 |
# |
| 605 |
# support for taques found as lists of ids separated by punctuation |
| 606 |
# constructor called with (separation char, source string) |
| 607 |
# |
| 608 |
class idTaque : taque(punc) |
| 609 |
method parse(s) |
| 610 |
s ? { |
| 611 |
tab(many(white)) |
| 612 |
while name := tab(find(self.punc)) do { |
| 613 |
self$insert(trim(name)) |
| 614 |
move(1) |
| 615 |
tab(many(white)) |
| 616 |
} |
| 617 |
if any(nonwhite) then self$insert(trim(tab(0))) |
| 618 |
} |
| 619 |
return |
| 620 |
end |
| 621 |
method String() |
| 622 |
if /self.l then return "" |
| 623 |
out := "" |
| 624 |
every id := !self.l do out ||:= id||self.punc |
| 625 |
return out[1:-1] |
| 626 |
end |
| 627 |
end |
| 628 |
|
| 629 |
# |
| 630 |
# parameter lists in which the final argument may have a trailing [] |
| 631 |
# |
| 632 |
class argList : idTaque(public varg) |
| 633 |
method insert(s) |
| 634 |
if \self.varg then halt("variable arg must be final") |
| 635 |
if i := find("[",s) then { |
| 636 |
if not (j := find("]",s)) then halt("variable arg expected ]") |
| 637 |
s[i : j+1] := "" |
| 638 |
self.varg := s := trim(s) |
| 639 |
} |
| 640 |
self$idTaque.insert(s) |
| 641 |
end |
| 642 |
method isvarg(s) |
| 643 |
if s == \self.varg then return s |
| 644 |
end |
| 645 |
method String() |
| 646 |
return self$idTaque.String() || ((\self.varg & "[]") | "") |
| 647 |
end |
| 648 |
initially |
| 649 |
self.punc := "," |
| 650 |
end |
| 651 |
|
| 652 |
# |
| 653 |
# Idol class field lists in which fields may be preceded by a "public" keyword |
| 654 |
# |
| 655 |
class classFields : argList(publics) |
| 656 |
method String(s) |
| 657 |
if *(rv := self$argList.String()) = 0 then return "" |
| 658 |
if /s | (s ~== "class") then return rv |
| 659 |
if self$ispublic(self.l[1]) then rv := "public "||rv |
| 660 |
every field:=self$foreachpublic() do rv[find(","||field,rv)] ||:= "public " |
| 661 |
return rv |
| 662 |
end |
| 663 |
method foreachpublic() |
| 664 |
if \self.publics then every suspend !self.publics |
| 665 |
end |
| 666 |
method ispublic(s) |
| 667 |
if \self.publics then every suspend !self.publics == s |
| 668 |
end |
| 669 |
method insert(s) |
| 670 |
s ? { |
| 671 |
if ="public" & tab(many(white)) then { |
| 672 |
s := tab(0) |
| 673 |
/self.publics := [] |
| 674 |
put(self.publics,s) |
| 675 |
} |
| 676 |
} |
| 677 |
self$argList.insert(s) |
| 678 |
end |
| 679 |
initially |
| 680 |
self.punc := "," |
| 681 |
end |
| 682 |
|
| 683 |
# |
| 684 |
# procedure to read a single Idol source file |
| 685 |
# |
| 686 |
procedure readinput(name,phase,ct2) |
| 687 |
if \loud then write("\t",name) |
| 688 |
fName := name |
| 689 |
fLine := 0 |
| 690 |
fin := sysopen(name,"r") |
| 691 |
ct := \ct2 | constant() |
| 692 |
while line := readln("wrap") do { |
| 693 |
line ? { |
| 694 |
tab(many(white)) |
| 695 |
if ="class" then { |
| 696 |
decl := class() |
| 697 |
decl$read(line,phase) |
| 698 |
if phase=1 then { |
| 699 |
decl$writemethods() |
| 700 |
classes$insert(decl,decl$name()) |
| 701 |
} else classes$insert_t(decl,decl$name()) |
| 702 |
} |
| 703 |
else if ="procedure" then { |
| 704 |
if comp = 0 then comp := 1 |
| 705 |
decl := method("") |
| 706 |
decl$read(line,phase) |
| 707 |
decl$write(fout,"") |
| 708 |
} |
| 709 |
else if ="record" then { |
| 710 |
if comp = 0 then comp := 1 |
| 711 |
decl := declaration(line) |
| 712 |
decl$write(fout,"") |
| 713 |
} |
| 714 |
else if ="global" then { |
| 715 |
if comp = 0 then comp := 1 |
| 716 |
decl := vardecl(line) |
| 717 |
decl$write(fout,"") |
| 718 |
} |
| 719 |
else if ="const" then { |
| 720 |
ct$append ( constdcl(line) ) |
| 721 |
} |
| 722 |
else if ="method" then { |
| 723 |
halt("readinput: method outside class") |
| 724 |
} |
| 725 |
else if ="#include" then { |
| 726 |
savedFName := fName |
| 727 |
savedFLine := fLine |
| 728 |
savedFIn := fin |
| 729 |
tab(many(white)) |
| 730 |
readinput(tab(if ="\"" then find("\"") else many(nonwhite)), |
| 731 |
phase,ct) |
| 732 |
fName := savedFName |
| 733 |
fLine := savedFLine |
| 734 |
fin := savedFIn |
| 735 |
} |
| 736 |
} |
| 737 |
} |
| 738 |
close(fin) |
| 739 |
end |
| 740 |
|
| 741 |
# |
| 742 |
# filter the input translating $ references |
| 743 |
# (also eats comments and trims lines) |
| 744 |
# |
| 745 |
procedure readln(wrap) |
| 746 |
count := 0 |
| 747 |
prefix := "" |
| 748 |
while /finished do { |
| 749 |
|
| 750 |
if not (line := read(fin)) then fail |
| 751 |
fLine +:= 1 |
| 752 |
if match("#include",line) then return line |
| 753 |
line[ 1(x<-find("#",line),notquote(line[1:x])) : 0] := "" |
| 754 |
line := trim(line,white) |
| 755 |
# line := selfdot(line) |
| 756 |
x := 1 |
| 757 |
while ((x := find("$",line,x)) & notquote(line[1:x])) do { |
| 758 |
z := line[x+1:0] ||" " # " " is for bal() |
| 759 |
case line[x+1] of { |
| 760 |
# |
| 761 |
# IBM 370 digraphs |
| 762 |
# |
| 763 |
"(": line[x+:2] := "{" |
| 764 |
")": line[x+:2] := "}" |
| 765 |
"<": line[x+:2] := "[" |
| 766 |
">": line[x+:2] := "]" |
| 767 |
# |
| 768 |
# Invocation operators $! $* $@ $? (for $$ see below) |
| 769 |
# |
| 770 |
"!"|"*"|"@"|"?": { |
| 771 |
z ? { |
| 772 |
move(1) |
| 773 |
tab(many(white)) |
| 774 |
if not (id := tab(many(alphadot))) then { |
| 775 |
if not match("(") then halt("readln can't parse ",line) |
| 776 |
if not (id := tab(&pos<bal())) then |
| 777 |
halt("readln: cant bal ",&subject) |
| 778 |
} |
| 779 |
Op := case line[x+1] of { |
| 780 |
"@": "activate" |
| 781 |
"*": "size" |
| 782 |
"!": "foreach" |
| 783 |
"?": "random" |
| 784 |
} |
| 785 |
count +:= 1 |
| 786 |
line[x:0] := |
| 787 |
"(__self"||count||" := "||id||").__methods."|| |
| 788 |
Op||"(__self"||count||".__state)"||tab(0) |
| 789 |
} |
| 790 |
} |
| 791 |
# |
| 792 |
# x $[ y ] shorthand for x$index(y) |
| 793 |
# |
| 794 |
"[": { |
| 795 |
z ? { |
| 796 |
if not (middle := tab((&pos<bal(&cset,'[',']'))-1)[2:0]) then |
| 797 |
halt("readln: can't bal([) ",&subject) |
| 798 |
tail := tab(0)|"" |
| 799 |
line := line[1:x]||"$index("||middle||")"||(tab(0)|"") |
| 800 |
} |
| 801 |
} |
| 802 |
default: { |
| 803 |
# |
| 804 |
# get the invoking object. |
| 805 |
# |
| 806 |
reverse(line[1:x])||" " ? { |
| 807 |
tab(many(white)) |
| 808 |
if not (id := reverse(tab(many(alphadot)))) then { |
| 809 |
if not match(")") then halt("readln: can't parse") |
| 810 |
if not (id := reverse(tab(&pos<bal(&cset,')','(')))) |
| 811 |
then halt("readln: can't bal ",&subject) |
| 812 |
} |
| 813 |
objlen := &pos-1 |
| 814 |
} |
| 815 |
count +:= 1 |
| 816 |
front := "(__self"||count||" := "||id||").__methods." |
| 817 |
back := "__self"||count||".__state" |
| 818 |
|
| 819 |
# |
| 820 |
# get the method name |
| 821 |
# |
| 822 |
z ? { |
| 823 |
="$" |
| 824 |
tab(many(white)) |
| 825 |
if not (methodname := tab(many(alphadot))) then |
| 826 |
halt("readln: expected a method name after $") |
| 827 |
tab(many(white)) |
| 828 |
methodname ||:= "(" |
| 829 |
if ="(" then { |
| 830 |
tab(many(white)) |
| 831 |
afterlp := &subject[&pos] |
| 832 |
} |
| 833 |
else { |
| 834 |
afterlp := ")" |
| 835 |
back ||:= ")" |
| 836 |
} |
| 837 |
methlen := &pos-1 |
| 838 |
} |
| 839 |
if line[x+1] == "$" then { |
| 840 |
c := if afterlp[1] ~== ")" then "" else "[]" |
| 841 |
methodname[-1] := "!(" |
| 842 |
back := "["||back||"]|||" |
| 843 |
} else { |
| 844 |
c := if (\afterlp)[1] == ")" then "" else "," |
| 845 |
} |
| 846 |
line[x-objlen : (((*line>=(x+methlen+1))|0)\1)] := |
| 847 |
front || methodname || back || c |
| 848 |
} |
| 849 |
} # case |
| 850 |
} # while there's a $ to process |
| 851 |
if /wrap | (prefix==line=="") then finished := line |
| 852 |
else { |
| 853 |
prefix ||:= line || " " # " " is for bal() |
| 854 |
prefix ? { |
| 855 |
# we are done if the line is balanced wrt parens and |
| 856 |
# doesn't end in a continuation character (currently just ,) |
| 857 |
if ((*prefix = bal()) & (not find(",",prefix[-2]))) then |
| 858 |
finished := prefix[1:-1] |
| 859 |
} |
| 860 |
} |
| 861 |
} # while / finished |
| 862 |
return ct$expand(finished) |
| 863 |
end |