tools/Coco/CRP.obn

   1 (* parser module generated by Coco-R *)
   2 MODULE CRP;
   3
   4 IMPORT CRS, CRT, CRA, CRX, Sets, Texts, Oberon;
   5
   6 CONST
   7         maxP        = 39;
   8   maxT        = 38;
   9   nrSets = 18;
  10
  11         setSize = 32;  nSets = (maxT DIV setSize) + 1;
  12
  13 TYPE
  14         SymbolSet = ARRAY nSets OF SET;
  15
  16 VAR
  17         sym:     INTEGER;   (* current input symbol *)
  18         symSet:  ARRAY nrSets OF SymbolSet;
  19
  20 CONST
  21   ident = 0; string = 1; (*symbol kind*)
  22
  23 VAR
  24   str: ARRAY 32 OF CHAR;
  25   w:   Texts.Writer;
  26   genScanner: BOOLEAN;
  27
  28
  29 PROCEDURE SemErr(nr: INTEGER);
  30 BEGIN
  31   CRS.Error(200+nr, CRS.pos);
  32 END SemErr;
  33
  34 PROCEDURE MatchLiteral(sp: INTEGER); (*store string either as token or as literal*)
  35   VAR sn, sn1: CRT.SymbolNode; matchedSp: INTEGER;
  36 BEGIN
  37   CRT.GetSym(sp, sn);
  38   CRA.MatchDFA(sn.name, sp, matchedSp);
  39   IF matchedSp # CRT.noSym THEN
  40     CRT.GetSym(matchedSp, sn1); sn1.struct := CRT.classLitToken; CRT.PutSym(matchedSp, sn1);
  41     sn.struct := CRT.litToken
  42   ELSE sn.struct := CRT.classToken;
  43   END;
  44   CRT.PutSym(sp, sn)
  45 END MatchLiteral;
  46
  47 PROCEDURE SetCtx(gp: INTEGER); (*set transition code to CRT.contextTrans*)
  48   VAR gn: CRT.GraphNode;
  49 BEGIN
  50   WHILE gp > 0 DO
  51     CRT.GetNode(gp, gn);
  52     IF gn.typ IN {CRT.char, CRT.class} THEN
  53         gn.p2 := CRT.contextTrans; CRT.PutNode(gp, gn)
  54     ELSIF gn.typ IN {CRT.opt, CRT.iter} THEN SetCtx(gn.p1)
  55     ELSIF gn.typ = CRT.alt THEN SetCtx(gn.p1); SetCtx(gn.p2)
  56     END;
  57     gp := gn.next
  58   END
  59 END SetCtx;
  60
  61 PROCEDURE SetDDT(s: ARRAY OF CHAR);
  62   VAR name: ARRAY 64 OF CHAR; i: INTEGER; ch: CHAR;
  63 BEGIN
  64   i := 1;
  65   WHILE s[i] # 0X DO
  66     ch := s[i]; INC(i);
  67     IF (ch >= "0") & (ch <= "9") THEN CRT.ddt[ORD(ch)-ORD("0")] := TRUE END
  68   END
  69 END SetDDT;
  70
  71 PROCEDURE FixString (VAR s: ARRAY OF CHAR; len: INTEGER);
  72         VAR double: BOOLEAN; i: INTEGER;
  73 BEGIN
  74         double := FALSE;
  75         FOR i := 0 TO len-2 DO
  76                 IF s[i] = '"' THEN double := TRUE END
  77         END;
  78         IF ~ double THEN s[0] := '"'; s[len-1] := '"' END
  79 END FixString;
  80
  81 (*-------------------------------------------------------------------------*)
  82
  83
  84 PROCEDURE Error (n: INTEGER);
  85 BEGIN CRS.Error(n, CRS.nextPos)
  86 END Error;
  87
  88 PROCEDURE Get;
  89 BEGIN
  90         LOOP CRS.Get(sym);
  91     IF sym > maxT THEN
  92       IF sym = 39 THEN
  93          CRS.GetName(CRS.nextPos, CRS.nextLen, str); SetDDT(str)
  94       END;
  95       CRS.nextPos := CRS.pos;
  96       CRS.nextCol := CRS.col;
  97       CRS.nextLine := CRS.line;
  98       CRS.nextLen := CRS.len;
  99     ELSE EXIT
 100     END
 101 END
 102
 103 END Get;
 104
 105 PROCEDURE Expect(n: INTEGER);
 106 BEGIN IF sym = n THEN Get ELSE Error(n) END
 107 END Expect;
 108
 109 PROCEDURE StartOf(s: INTEGER): BOOLEAN;
 110 BEGIN RETURN (sym MOD setSize) IN symSet[s, sym DIV setSize]
 111 END StartOf;
 112
 113 PROCEDURE ExpectWeak(n, follow: INTEGER);
 114 BEGIN
 115         IF sym = n THEN Get
 116         ELSE Error(n); WHILE ~ StartOf(follow) DO Get END
 117         END
 118 END ExpectWeak;
 119
 120 PROCEDURE WeakSeparator(n, syFol, repFol: INTEGER): BOOLEAN;
 121         VAR s: SymbolSet; i: INTEGER;
 122 BEGIN
 123         IF sym = n THEN Get; RETURN TRUE
 124         ELSIF StartOf(repFol) THEN RETURN FALSE
 125         ELSE
 126                 i := 0; WHILE i < nSets DO s[i] := symSet[syFol, i] + symSet[repFol, i] + symSet[0, i]; INC(i) END;
 127                 Error(n); WHILE ~ ((sym MOD setSize) IN s[sym DIV setSize]) DO Get END;
 128                 RETURN StartOf(syFol)
 129         END
 130 END WeakSeparator;
 131
 132 PROCEDURE ^TokenFactor(VAR gL, gR: INTEGER);
 133 PROCEDURE ^TokenTerm(VAR gL, gR: INTEGER);
 134 PROCEDURE ^Factor(VAR gL, gR: INTEGER);
 135 PROCEDURE ^Term(VAR gL, gR: INTEGER);
 136 PROCEDURE ^Symbol(VAR name: CRT.Name; VAR kind: INTEGER);
 137 PROCEDURE ^SimSet(VAR set: CRT.Set);
 138 PROCEDURE ^Set(VAR set: CRT.Set);
 139 PROCEDURE ^TokenExpr(VAR gL, gR: INTEGER);
 140 PROCEDURE ^TokenDecl(typ: INTEGER);
 141 PROCEDURE ^SetDecl;
 142 PROCEDURE ^Expression(VAR gL, gR: INTEGER);
 143 PROCEDURE ^SemText(VAR semPos: CRT.Position);
 144 PROCEDURE ^Attribs(VAR attrPos: CRT.Position);
 145 PROCEDURE ^Declaration;
 146 PROCEDURE ^CR;
 147
 148 PROCEDURE TokenFactor(VAR gL, gR: INTEGER);
 149   VAR kind, c: INTEGER; set: CRT.Set; name: CRT.Name;
 150 BEGIN
 151   gL :=0; gR := 0 ;
 152   IF (sym = 1) OR (sym = 2) THEN
 153     Symbol(name, kind);
 154     IF kind = ident THEN
 155       c := CRT.ClassWithName(name);
 156       IF c < 0 THEN
 157         SemErr(15);
 158         Sets.Clear(set); c := CRT.NewClass(name, set)
 159       END;
 160       gL := CRT.NewNode(CRT.class, c, 0); gR := gL
 161     ELSE (*string*)
 162       CRT.StrToGraph(name, gL, gR)
 163     END ;
 164   ELSIF (sym = 23) THEN
 165     Get;
 166     TokenExpr(gL, gR);
 167     Expect(24);
 168   ELSIF (sym = 28) THEN
 169     Get;
 170     TokenExpr(gL, gR);
 171     Expect(29);
 172     CRT.MakeOption(gL, gR) ;
 173   ELSIF (sym = 30) THEN
 174     Get;
 175     TokenExpr(gL, gR);
 176     Expect(31);
 177     CRT.MakeIteration(gL, gR) ;
 178   ELSE Error(39)
 179   END;
 180 END TokenFactor;
 181
 182 PROCEDURE TokenTerm(VAR gL, gR: INTEGER);
 183   VAR gL2, gR2: INTEGER;
 184 BEGIN
 185   TokenFactor(gL, gR);
 186   WHILE StartOf(1)  DO
 187     TokenFactor(gL2, gR2);
 188     CRT.ConcatSeq(gL, gR, gL2, gR2) ;
 189   END;
 190   IF (sym = 33) THEN
 191     Get;
 192     Expect(23);
 193     TokenExpr(gL2, gR2);
 194     SetCtx(gL2); CRT.ConcatSeq(gL, gR, gL2, gR2) ;
 195     Expect(24);
 196   END;
 197 END TokenTerm;
 198
 199 PROCEDURE Factor(VAR gL, gR: INTEGER);
 200   VAR sp, kind, c: INTEGER; name: CRT.Name;
 201       gn: CRT.GraphNode; sn: CRT.SymbolNode;
 202       set: CRT.Set;
 203       undef, weak: BOOLEAN;
 204       pos: CRT.Position;
 205 BEGIN
 206   gL :=0; gR := 0; weak := FALSE ;
 207   CASE sym OF
 208   | 1,2,27:     IF (sym = 27) THEN
 209       Get;
 210       weak := TRUE ;
 211     END;
 212     Symbol(name, kind);
 213     sp := CRT.FindSym(name); undef := sp = CRT.noSym;
 214     IF undef THEN
 215       IF kind = ident THEN  (*forward nt*)
 216         sp := CRT.NewSym(CRT.nt, name, 0)
 217       ELSE  (*undefined string in production*)
 218         sp := CRT.NewSym(CRT.t, name, CRS.line);
 219         MatchLiteral(sp)
 220       END
 221     END;
 222     CRT.GetSym(sp, sn);
 223     IF ~(sn.typ IN {CRT.t,CRT.nt}) THEN SemErr(4) END;
 224     IF weak THEN
 225       IF sn.typ = CRT.t THEN sn.typ := CRT.wt ELSE SemErr(23) END
 226     END;
 227     gL := CRT.NewNode(sn.typ, sp, CRS.line); gR := gL ;
 228     IF (sym = 34) THEN
 229       Attribs(pos);
 230       CRT.GetNode(gL, gn); gn.pos := pos; CRT.PutNode(gL, gn);
 231       CRT.GetSym(sp, sn);
 232       IF undef THEN
 233         sn.attrPos := pos; CRT.PutSym(sp, sn)
 234       ELSIF sn.attrPos.beg < 0 THEN SemErr(5)
 235       END;
 236       IF kind # ident THEN SemErr(3) END ;
 237     ELSIF StartOf(2)  THEN
 238       CRT.GetSym(sp, sn);
 239       IF sn.attrPos.beg >= 0 THEN SemErr(6) END ;
 240     ELSE Error(40)
 241     END;
 242   | 23:     Get;
 243     Expression(gL, gR);
 244     Expect(24);
 245   | 28:     Get;
 246     Expression(gL, gR);
 247     Expect(29);
 248     CRT.MakeOption(gL, gR) ;
 249   | 30:     Get;
 250     Expression(gL, gR);
 251     Expect(31);
 252     CRT.MakeIteration(gL, gR) ;
 253   | 36:     SemText(pos);
 254     gL := CRT.NewNode(CRT.sem, 0, 0);
 255     gR := gL;
 256     CRT.GetNode(gL, gn); gn.pos := pos; CRT.PutNode(gL, gn) ;
 257   | 25:     Get;
 258     Sets.Fill(set); Sets.Excl(set, CRT.eofSy);
 259     gL := CRT.NewNode(CRT.any, CRT.NewSet(set), 0); gR := gL ;
 260   | 32:     Get;
 261     gL := CRT.NewNode(CRT.sync, 0, 0); gR := gL ;
 262   ELSE Error(41)
 263   END;
 264 END Factor;
 265
 266 PROCEDURE Term(VAR gL, gR: INTEGER);
 267   VAR gL2, gR2: INTEGER;
 268 BEGIN
 269   gL := 0; gR := 0 ;
 270   IF StartOf(3)  THEN
 271     Factor(gL, gR);
 272     WHILE StartOf(3)  DO
 273       Factor(gL2, gR2);
 274       CRT.ConcatSeq(gL, gR, gL2, gR2) ;
 275     END;
 276   ELSIF StartOf(4)  THEN
 277     gL := CRT.NewNode(CRT.eps, 0, 0); gR := gL ;
 278   ELSE Error(42)
 279   END;
 280 END Term;
 281
 282 PROCEDURE Symbol(VAR name: CRT.Name; VAR kind: INTEGER);
 283 BEGIN
 284   IF (sym = 1) THEN
 285     Get;
 286     kind := ident ;
 287   ELSIF (sym = 2) THEN
 288     Get;
 289     kind := string ;
 290   ELSE Error(43)
 291   END;
 292   CRS.GetName(CRS.pos, CRS.len, name);
 293   IF kind = string THEN FixString(name, CRS.len) END ;
 294 END Symbol;
 295
 296 PROCEDURE SimSet(VAR set: CRT.Set);
 297   VAR c, n, i: INTEGER; name: CRT.Name; s: ARRAY 128 OF CHAR;
 298 BEGIN
 299   IF (sym = 1) THEN
 300     Get;
 301     CRS.GetName(CRS.pos, CRS.len, name);
 302     c := CRT.ClassWithName(name);
 303     IF c < 0 THEN SemErr(15); Sets.Clear(set)
 304     ELSE CRT.GetClass(c, set)
 305     END ;
 306   ELSIF (sym = 2) THEN
 307     Get;
 308     CRS.GetName(CRS.pos, CRS.len, s);
 309     Sets.Clear(set); i := 1;
 310     WHILE s[i] # s[0] DO
 311       Sets.Incl(set, ORD(s[i])); INC(i)
 312     END ;
 313   ELSIF (sym = 22) THEN
 314     Get;
 315     Expect(23);
 316     Expect(3);
 317     CRS.GetName(CRS.pos, CRS.len, name);
 318     n := 0; i := 0;
 319     WHILE name[i] # 0X DO
 320       n := 10 * n + (ORD(name[i]) - ORD("0"));
 321       INC(i)
 322     END;
 323     Sets.Clear(set); Sets.Incl(set, n) ;
 324     Expect(24);
 325   ELSIF (sym = 25) THEN
 326     Get;
 327     Sets.Fill(set) ;
 328   ELSE Error(44)
 329   END;
 330 END SimSet;
 331
 332 PROCEDURE Set(VAR set: CRT.Set);
 333   VAR set2: CRT.Set;
 334 BEGIN
 335   SimSet(set);
 336   WHILE (sym = 20) OR (sym = 21) DO
 337     IF (sym = 20) THEN
 338       Get;
 339       SimSet(set2);
 340       Sets.Unite(set, set2) ;
 341     ELSE
 342       Get;
 343       SimSet(set2);
 344       Sets.Differ(set, set2) ;
 345     END;
 346   END;
 347 END Set;
 348
 349 PROCEDURE TokenExpr(VAR gL, gR: INTEGER);
 350   VAR gL2, gR2: INTEGER; first: BOOLEAN;
 351 BEGIN
 352   TokenTerm(gL, gR);
 353   first := TRUE ;
 354   WHILE WeakSeparator(26, 1, 5)  DO
 355     TokenTerm(gL2, gR2);
 356     IF first THEN
 357       CRT.MakeFirstAlt(gL, gR); first := FALSE
 358     END;
 359     CRT.ConcatAlt(gL, gR, gL2, gR2) ;
 360   END;
 361 END TokenExpr;
 362
 363 PROCEDURE TokenDecl(typ: INTEGER);
 364   VAR sp, kind, gL, gR: INTEGER; sn: CRT.SymbolNode;
 365       pos: CRT.Position; name: CRT.Name;
 366 BEGIN
 367   Symbol(name, kind);
 368   IF CRT.FindSym(name) # CRT.noSym THEN SemErr(7)
 369   ELSE
 370     sp := CRT.NewSym(typ, name, CRS.line);
 371     CRT.GetSym(sp, sn); sn.struct := CRT.classToken;
 372     CRT.PutSym(sp, sn)
 373   END ;
 374   WHILE ~( StartOf(6) ) DO Error(45); Get END;
 375   IF (sym = 8) THEN
 376     Get;
 377     TokenExpr(gL, gR);
 378     Expect(9);
 379     IF kind # ident THEN SemErr(13) END;
 380     CRT.CompleteGraph(gR);
 381     CRA.ConvertToStates(gL, sp) ;
 382   ELSIF StartOf(7)  THEN
 383     IF kind = ident THEN genScanner := FALSE
 384     ELSE MatchLiteral(sp)
 385     END ;
 386   ELSE Error(46)
 387   END;
 388   IF (sym = 36) THEN
 389     SemText(pos);
 390     IF typ = CRT.t THEN SemErr(14) END;
 391     CRT.GetSym(sp, sn); sn.semPos := pos; CRT.PutSym(sp, sn) ;
 392   END;
 393 END TokenDecl;
 394
 395 PROCEDURE SetDecl;
 396   VAR c: INTEGER; set: CRT.Set; name: CRT.Name;
 397 BEGIN
 398   Expect(1);
 399   CRS.GetName(CRS.pos, CRS.len, name);
 400   c := CRT.ClassWithName(name); IF c >= 0 THEN SemErr(7) END ;
 401   Expect(8);
 402   Set(set);
 403   c := CRT.NewClass(name, set) ;
 404   Expect(9);
 405 END SetDecl;
 406
 407 PROCEDURE Expression(VAR gL, gR: INTEGER);
 408   VAR gL2, gR2: INTEGER; first: BOOLEAN;
 409 BEGIN
 410   Term(gL, gR);
 411   first := TRUE ;
 412   WHILE WeakSeparator(26, 2, 8)  DO
 413     Term(gL2, gR2);
 414     IF first THEN
 415       CRT.MakeFirstAlt(gL, gR); first := FALSE
 416     END;
 417     CRT.ConcatAlt(gL, gR, gL2, gR2) ;
 418   END;
 419 END Expression;
 420
 421 PROCEDURE SemText(VAR semPos: CRT.Position);
 422 BEGIN
 423   Expect(36);
 424   semPos.beg := CRS.nextPos; semPos.col := CRS.nextCol ;
 425   WHILE StartOf(9)  DO
 426     Get;
 427   END;
 428   Expect(37);
 429   semPos.len := SHORT(CRS.pos - semPos.beg) ;
 430 END SemText;
 431
 432 PROCEDURE Attribs(VAR attrPos: CRT.Position);
 433 BEGIN
 434   Expect(34);
 435   attrPos.beg := CRS.nextPos; attrPos.col := CRS.nextCol ;
 436   WHILE StartOf(10)  DO
 437     Get;
 438   END;
 439   Expect(35);
 440   attrPos.len := SHORT(CRS.pos - attrPos.beg) ;
 441 END Attribs;
 442
 443 PROCEDURE Declaration;
 444   VAR gL1, gR1, gL2, gR2: INTEGER; nested: BOOLEAN;
 445 BEGIN
 446   IF (sym = 11) THEN
 447     Get;
 448     WHILE (sym = 1) DO
 449       SetDecl;
 450     END;
 451   ELSIF (sym = 12) THEN
 452     Get;
 453     WHILE (sym = 1) OR (sym = 2) DO
 454       TokenDecl(CRT.t);
 455     END;
 456   ELSIF (sym = 13) THEN
 457     Get;
 458     WHILE (sym = 1) OR (sym = 2) DO
 459       TokenDecl(CRT.pr);
 460     END;
 461   ELSIF (sym = 14) THEN
 462     Get;
 463     Expect(15);
 464     TokenExpr(gL1, gR1);
 465     Expect(16);
 466     TokenExpr(gL2, gR2);
 467     IF (sym = 17) THEN
 468       Get;
 469       nested := TRUE ;
 470     ELSIF StartOf(11)  THEN
 471       nested := FALSE ;
 472     ELSE Error(47)
 473     END;
 474     CRA.NewComment(gL1, gL2, nested) ;
 475   ELSIF (sym = 18) THEN
 476     Get;
 477     IF (sym = 19) THEN
 478       Get;
 479       CRT.ignoreCase := TRUE ;
 480     ELSIF StartOf(12)  THEN
 481       Set(CRT.ignored);
 482     ELSE Error(48)
 483     END;
 484   ELSE Error(49)
 485   END;
 486 END Declaration;
 487
 488 PROCEDURE CR;
 489   VAR undef, hasAttrs, ok, ok1: BOOLEAN; eofSy, gR: INTEGER;
 490       gramLine, sp: INTEGER;
 491       gn: CRT.GraphNode; sn: CRT.SymbolNode;
 492       name, gramName: CRT.Name;
 493 BEGIN
 494   Expect(4);
 495   Texts.OpenWriter(w);
 496   CRT.Init; CRX.Init; CRA.Init;
 497   gramLine := CRS.line;
 498   eofSy := CRT.NewSym(CRT.t, "EOF", 0);
 499   genScanner := TRUE;
 500   CRT.ignoreCase := FALSE;
 501   ok := TRUE;
 502   Sets.Clear(CRT.ignored) ;
 503   Expect(1);
 504   CRS.GetName(CRS.pos, CRS.len, gramName);
 505   CRT.semDeclPos.beg := CRS.nextPos; CRT.importPos.beg := -1; ;
 506   WHILE StartOf(13)  DO
 507     IF (sym = 5) THEN
 508       Get;
 509       CRT.importPos.beg := CRS.nextPos ;
 510       WHILE StartOf(14)  DO
 511         Get;
 512       END;
 513       Expect(6);
 514       CRT.importPos.len := SHORT(CRS.pos - CRT.importPos.beg);
 515       CRT.importPos.col := 0;
 516       CRT.semDeclPos.beg := CRS.nextPos ;
 517     ELSE
 518       Get;
 519     END;
 520   END;
 521   CRT.semDeclPos.len := SHORT(CRS.nextPos - CRT.semDeclPos.beg);
 522   CRT.semDeclPos.col := 0 ;
 523   WHILE StartOf(15)  DO
 524     Declaration;
 525   END;
 526   WHILE ~( (sym = 0) OR (sym = 7)) DO Error(50); Get END;
 527   Expect(7);
 528   IF genScanner THEN CRA.MakeDeterministic(ok) END;
 529   CRT.nNodes := 0 ;
 530   WHILE (sym = 1) DO
 531     Get;
 532     CRS.GetName(CRS.pos, CRS.len, name);
 533     sp := CRT.FindSym(name); undef := sp = CRT.noSym;
 534     IF undef THEN
 535       sp := CRT.NewSym(CRT.nt, name, CRS.line);
 536       CRT.GetSym(sp, sn);
 537     ELSE
 538       CRT.GetSym(sp, sn);
 539       IF sn.typ = CRT.nt THEN
 540         IF sn.struct > 0 THEN SemErr(7) END
 541       ELSE SemErr(8)
 542       END;
 543       sn.line := CRS.line
 544     END;
 545     hasAttrs := sn.attrPos.beg >= 0 ;
 546     IF (sym = 34) THEN
 547       Attribs(sn.attrPos);
 548       IF ~undef & ~hasAttrs THEN SemErr(9) END;
 549       CRT.PutSym(sp, sn) ;
 550     ELSIF (sym = 8) OR (sym = 36) THEN
 551       IF ~undef & hasAttrs THEN SemErr(10) END ;
 552     ELSE Error(51)
 553     END;
 554     IF (sym = 36) THEN
 555       SemText(sn.semPos);
 556     END;
 557     ExpectWeak(8, 16);
 558     Expression(sn.struct, gR);
 559     CRT.CompleteGraph(gR); CRT.PutSym(sp, sn);
 560     IF CRT.ddt[2] THEN CRT.PrintGraph END ;
 561     ExpectWeak(9, 17);
 562   END;
 563   sp := CRT.FindSym(gramName);
 564   IF sp = CRT.noSym THEN SemErr(11);
 565   ELSE
 566     CRT.GetSym(sp, sn);
 567     IF sn.attrPos.beg >= 0 THEN SemErr(12) END;
 568     CRT.root := CRT.NewNode(CRT.nt, sp, gramLine);
 569   END ;
 570   Expect(10);
 571   Expect(1);
 572   CRS.GetName(CRS.pos, CRS.len, name);
 573   IF name # gramName THEN SemErr(17) END;
 574   IF CRS.errors = 0 THEN
 575     Texts.WriteString(w, " checking"); Texts.Append(Oberon.Log, w.buf);
 576     CRT.CompSymbolSets;
 577     IF ok THEN CRT.TestCompleteness(ok) END;
 578     IF ok THEN
 579       CRT.TestIfAllNtReached(ok1); CRT.FindCircularProductions(ok)
 580     END;
 581     IF ok THEN CRT.TestIfNtToTerm(ok) END;
 582     IF ok THEN CRT.LL1Test(ok1) END;
 583     IF CRT.ddt[0] THEN CRA.PrintStates END;
 584     IF CRT.ddt[7] THEN CRT.XRef END;
 585     IF ok THEN
 586       Texts.WriteString(w, " +parser");
 587       Texts.Append(Oberon.Log, w.buf);
 588       CRX.GenCompiler;
 589       IF genScanner THEN
 590         Texts.WriteString(w, " +scanner");
 591         Texts.Append(Oberon.Log, w.buf);
 592         CRA.WriteScanner
 593       END;
 594       IF CRT.ddt[8] THEN CRX.WriteStatistics END
 595     END
 596   ELSE ok := FALSE
 597   END;
 598   IF CRT.ddt[6] THEN CRT.PrintSymbolTable END;
 599   IF ok THEN Texts.WriteString(w, " done") END;
 600   Texts.WriteLn(w); Texts.Append(Oberon.Log, w.buf) ;
 601   Expect(9);
 602 END CR;
 603
 604
 605
 606 PROCEDURE Parse*;
 607 BEGIN
 608         Get;
 609   CR;
 610
 611 END Parse;
 612
 613 BEGIN
 614   symSet[0, 0] := {0,1,2,7,8,11,12,13,14,18};
 615   symSet[0, 1] := {4};
 616   symSet[1, 0] := {1,2,23,28,30};
 617   symSet[1, 1] := {};
 618   symSet[2, 0] := {1,2,9,23,24,25,26,27,28,29,30,31};
 619   symSet[2, 1] := {0,4};
 620   symSet[3, 0] := {1,2,23,25,27,28,30};
 621   symSet[3, 1] := {0,4};
 622   symSet[4, 0] := {9,24,26,29,31};
 623   symSet[4, 1] := {};
 624   symSet[5, 0] := {7,9,11,12,13,14,16,17,18,24,29,31};
 625   symSet[5, 1] := {};
 626   symSet[6, 0] := {0,1,2,7,8,11,12,13,14,18};
 627   symSet[6, 1] := {4};
 628   symSet[7, 0] := {1,2,7,11,12,13,14,18};
 629   symSet[7, 1] := {4};
 630   symSet[8, 0] := {9,24,29,31};
 631   symSet[8, 1] := {};
 632   symSet[9, 0] := {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
 633   symSet[9, 1] := {0,1,2,3,4,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
 634   symSet[10, 0] := {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
 635   symSet[10, 1] := {0,1,2,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
 636   symSet[11, 0] := {7,11,12,13,14,18};
 637   symSet[11, 1] := {};
 638   symSet[12, 0] := {1,2,22,25};
 639   symSet[12, 1] := {};
 640   symSet[13, 0] := {1,2,3,4,5,6,8,9,10,15,16,17,19,20,21,22,23,24,25,26,27,28,29,30,31};
 641   symSet[13, 1] := {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
 642   symSet[14, 0] := {1,2,3,4,5,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
 643   symSet[14, 1] := {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
 644   symSet[15, 0] := {11,12,13,14,18};
 645   symSet[15, 1] := {};
 646   symSet[16, 0] := {0,1,2,7,8,9,11,12,13,14,18,23,25,26,27,28,30};
 647   symSet[16, 1] := {0,4};
 648   symSet[17, 0] := {0,1,2,7,8,10,11,12,13,14,18};
 649   symSet[17, 1] := {4};
 650
 651 END CRP.
 652   |  0: Msg("EOF expected")
 653   |  1: Msg("ident expected")
 654   |  2: Msg("string expected")
 655   |  3: Msg("number expected")
 656   |  4: Msg("'COMPILER' expected")
 657   |  5: Msg("'IMPORT' expected")
 658   |  6: Msg("';' expected")
 659   |  7: Msg("'PRODUCTIONS' expected")
 660   |  8: Msg("'=' expected")
 661   |  9: Msg("'.' expected")
 662   | 10: Msg("'END' expected")
 663   | 11: Msg("'CHARACTERS' expected")
 664   | 12: Msg("'TOKENS' expected")
 665   | 13: Msg("'PRAGMAS' expected")
 666   | 14: Msg("'COMMENTS' expected")
 667   | 15: Msg("'FROM' expected")
 668   | 16: Msg("'TO' expected")
 669   | 17: Msg("'NESTED' expected")
 670   | 18: Msg("'IGNORE' expected")
 671   | 19: Msg("'CASE' expected")
 672   | 20: Msg("'+' expected")
 673   | 21: Msg("'-' expected")
 674   | 22: Msg("'CHR' expected")
 675   | 23: Msg("'(' expected")
 676   | 24: Msg("')' expected")
 677   | 25: Msg("'ANY' expected")
 678   | 26: Msg("'|' expected")
 679   | 27: Msg("'WEAK' expected")
 680   | 28: Msg("'[' expected")
 681   | 29: Msg("']' expected")
 682   | 30: Msg("'{' expected")
 683   | 31: Msg("'}' expected")
 684   | 32: Msg("'SYNC' expected")
 685   | 33: Msg("'CONTEXT' expected")
 686   | 34: Msg("'<' expected")
 687   | 35: Msg("'>' expected")
 688   | 36: Msg("'(.' expected")
 689   | 37: Msg("'.)' expected")
 690   | 38: Msg("??? expected")
 691   | 39: Msg("invalid TokenFactor")
 692   | 40: Msg("invalid Factor")
 693   | 41: Msg("invalid Factor")
 694   | 42: Msg("invalid Term")
 695   | 43: Msg("invalid Symbol")
 696   | 44: Msg("invalid SimSet")
 697   | 45: Msg("this symbol not expected in TokenDecl")
 698   | 46: Msg("invalid TokenDecl")
 699   | 47: Msg("invalid Declaration")
 700   | 48: Msg("invalid Declaration")
 701   | 49: Msg("invalid Declaration")
 702   | 50: Msg("this symbol not expected in CR")
 703   | 51: Msg("invalid CR")