cr.mod

来自「一个Modula-2语言分析器」· MOD 代码 · 共 480 行 · 第 1/2 页

      | 38: Msg("'.>' expected")
      | 39: Msg("'(.' expected")
      | 40: Msg("'.)' expected")
      | 41: Msg("not expected")
      | 42: Msg("invalid TokenFactor")
      | 43: Msg("invalid Factor")
      | 44: Msg("invalid Factor")
      | 45: Msg("invalid Term")
      | 46: Msg("invalid Symbol")
      | 47: Msg("invalid SimSet")
      | 48: Msg("invalid NameDecl")
      | 49: Msg("this symbol not expected in TokenDecl")
      | 50: Msg("invalid TokenDecl")
      | 51: Msg("invalid Attribs")
      | 52: Msg("invalid Declaration")
      | 53: Msg("invalid Declaration")
      | 54: Msg("invalid Declaration")
      | 55: Msg("this symbol not expected in CR")
      | 56: Msg("invalid CR")
      
      | 102: Msg("string literal may not extend over line end");
      | 103: Msg("a literal must not have attributes");
      | 104: Msg("this symbol kind not allowed in production");
      | 105: Msg("attribute mismatch between declaration and use");
      | 106: Msg("undefined string in production");
      | 107: Msg("name declared twice");
      | 108: Msg("this type not allowed on left side of production");
      | 109: Msg("earlier semantic action was not terminated");
      | 111: Msg("no production found for grammar name");
      | 112: Msg("grammar symbol must not have attributes");
      | 113: Msg("a literal must not be declared with a structure")
      | 114: Msg("semantic action not allowed here")
      | 115: Msg("undefined name")
      | 116: Msg("attributes not allowed in token declaration")
      | 117: Msg("name does not match grammar name")
      | 118: Msg("unacceptable constant value")
      | 119: Msg("may not ignore CHR(0)")
      | 120: Msg("token may not be empty")
      | 121: Msg("token must not start with an iteration")
      | 122: Msg("only characters allowed in comment declaration")
      | 123: Msg("only terminals may be weak")
      | 124: Msg("literal tokens may not contain white space")
      | 125: Msg("comment delimiter must be 1 or 2 characters long")
      | 126: Msg("character set contains more than one character")
      | 127: Msg("could not make deterministic automaton")
      | 128: Msg("semantic action text too long - please split it")
      | 129: Msg("literal tokens may not be empty")
      ELSE Msg("Error: "); FileIO.WriteInt(lst, nr, 1);
      END;
      FileIO.WriteLn(lst)
    END PrintErr;

  PROCEDURE PrintListing;
  (* Print a source listing with error messages *)
    VAR
      nextErr:   Err;
      eof:       BOOLEAN;
      lnr, errC: INTEGER;
      srcPos:    INT32;
      line:      ARRAY [0 .. 255] OF CHAR;
    BEGIN
      FileIO.WriteString(lst, "Listing:");
      FileIO.WriteLn(lst); FileIO.WriteLn(lst);
      srcPos := FileIO.Long0; nextErr := firstErr;
      GetLine(srcPos, line, eof); lnr := 1; errC := 0;
      WHILE ~ eof DO
        FileIO.WriteInt(lst, lnr, 5); FileIO.WriteString(lst, "  ");
        FileIO.WriteString(lst, line); FileIO.WriteLn(lst);
        WHILE (nextErr # NIL) & (nextErr^.line = lnr) DO
          PrintErr(line, nextErr^.nr, nextErr^.col); INC(errC);
          nextErr := nextErr^.next
        END;
        GetLine(srcPos, line, eof); INC(lnr);
      END;
      IF nextErr # NIL THEN
        FileIO.WriteInt(lst, lnr, 5); FileIO.WriteLn(lst);
        WHILE nextErr # NIL DO
          PrintErr(line, nextErr^.nr, nextErr^.col); INC(errC);
          nextErr := nextErr^.next
        END
      END;
      FileIO.WriteLn(lst);
      FileIO.WriteInt(lst, errC, 5); FileIO.WriteString(lst, " error");
      IF errC # 1 THEN FileIO.Write(lst, "s") END;
      FileIO.WriteLn(lst); FileIO.WriteLn(lst); FileIO.WriteLn(lst);
    END PrintListing;

  BEGIN
    firstErr := NIL; Extra := 1;
  END ListHandler;

  PROCEDURE SetOption (s: ARRAY OF CHAR);
  (* Set compiler options *)
    VAR
      i: CARDINAL;
    BEGIN
      i := 1;
      WHILE s[i] # 0C DO
        s[i] := CAP(s[i]);
        IF (s[i] >= "A") AND (s[i] <= "Z") THEN CRT.ddt[s[i]] := TRUE END;
        INC(i);
      END;
    END SetOption;

  PROCEDURE Msg (S: ARRAY OF CHAR);
    BEGIN
      FileIO.WriteString(FileIO.StdOut, S); FileIO.WriteLn(FileIO.StdOut);
    END Msg;

  (* --------------------------- Help ------------------------------- *)

  PROCEDURE Help;
    BEGIN
      Msg("Usage: COCOR [-Options] [Grammar[.atg]] [-Options]");
      Msg("Example: COCOR -mcs Test");
      Msg("");
      Msg("Options are");
      Msg("a  - Trace automaton");
      Msg("c  - Generate compiler module");
      Msg("d  - Suppress generation of Definition Modules");
      Msg("f  - Give Start and Follower sets");
      Msg("g  - Print top-down graph");
      Msg("i  - Trace start set computations");
      Msg("l  - Force listing");
      Msg("m  - (Multipass) Suppress FORWARD declarations");
      Msg("n  - Generate symbolic names");
      Msg("p  - Generate parser only");
      Msg("s  - Print symbol table");
      Msg("t  - Grammar tests only - no code generated");
      Msg("x  - Print cross reference list");
      Msg("COMPILER.FRM, SCANNER.FRM and PARSER.FRM must be in the working directory,");
      Msg("or on the path specified by the environment variable CRFRAMES");
    END Help;

  BEGIN (* CR *)
    FileIO.WriteString(FileIO.StdOut, "Coco/R (WinTel) - Compiler-Compiler V");
    FileIO.WriteString(FileIO.StdOut, Version);
    FileIO.WriteLn(FileIO.StdOut);
    FileIO.WriteString(FileIO.StdOut, "Released by Pat Terry ");
    FileIO.WriteString(FileIO.StdOut, ReleaseDate);
    FileIO.WriteLn(FileIO.StdOut);
    FileIO.NextParameter(GrammarName);
    IF (GrammarName[0] = "?")
        OR (GrammarName[0] = "/") AND (GrammarName[1] = "?") THEN
      Help; FileIO.QuitExecution
    END;
    IF GrammarName[0] = 0C THEN
      FileIO.WriteString(FileIO.StdOut, "(COCOR ? gives short help screen)");
      FileIO.WriteLn(FileIO.StdOut);
    END;
    WHILE (GrammarName[0] = "-") OR (GrammarName[0] = "/") DO
      (* accept options before filename *)
      SetOption(GrammarName); FileIO.NextParameter(GrammarName)
    END;
    ok := GrammarName[0] # 0C;
    REPEAT
      IF ~ ok THEN
        FileIO.WriteString(FileIO.StdOut, "Grammar[.atg] ? : ");
        FileIO.ReadString(FileIO.StdIn, GrammarName);
        IF ~ FileIO.Okay THEN FileIO.QuitExecution END;
        FileIO.ReadLn(FileIO.StdIn);
      END;
      FileIO.AppendExtension(GrammarName, ATGExt, ATGFileName);
      GrammarName := ATGFileName;
      FileIO.Open(src, GrammarName, FALSE);
      ok := FileIO.Okay;
      IF ~ ok THEN
        FileIO.WriteString(FileIO.StdOut, "File <");
        FileIO.WriteString(FileIO.StdOut, GrammarName);
        FileIO.WriteString(FileIO.StdOut, "> not found.");
        FileIO.WriteLn(FileIO.StdOut);
      END
    UNTIL ok;
    FileIO.NextParameter(Options);
    IF Options[0] # 0C THEN SetOption(Options) END;
    FileIO.ExtractDirectory(GrammarName, directory);
    FileIO.ChangeExtension(GrammarName, LSTExt, lstFileName);
    FileIO.Open(lst, lstFileName, TRUE);
    FileIO.WriteString(lst, "Coco/R - Compiler-Compiler V");
    FileIO.WriteString(lst, Version);
    FileIO.WriteLn(lst);
    FileIO.WriteString(lst, "Released by Pat Terry ");
    FileIO.WriteString(lst, ReleaseDate);
    FileIO.WriteLn(lst);
    FileIO.WriteString(lst, "Source file: ");
    FileIO.WriteString(lst, GrammarName);
    FileIO.WriteLn(lst); FileIO.WriteLn(lst);
    FileIO.WriteLn(FileIO.StdOut);
    FileIO.WriteString(FileIO.StdOut, "parsing file ");
    FileIO.WriteString(FileIO.StdOut, GrammarName);
    FileIO.WriteLn(FileIO.StdOut);
    CRS.Error := StoreError;
    CRP.Parse;
    IF errors = 0 THEN
      Msg("testing grammar");
      FileIO.WriteString(lst, "Grammar Tests:");
      FileIO.WriteLn(lst); FileIO.WriteLn(lst);
      CRT.CompSymbolSets;
      CRT.TestCompleteness(ok);
      IF ok THEN CRT.TestIfAllNtReached(ok) END;
      IF ok THEN CRT.FindCircularProductions(ok) END;
      IF ok THEN CRT.TestIfNtToTerm(ok) END;
      IF ok THEN CRT.LL1Test(ll1) END;
      FileIO.WriteLn(lst);
      IF CRT.genScanner & CRT.ddt["A"] THEN CRA.PrintStates END;
      IF ~ ok OR ~ ll1 OR CRT.ddt["L"] OR CRT.ddt["X"] THEN
        Msg("listing");
        PrintListing; IF CRT.ddt["X"] THEN CRT.XRef; END;
      END;
      IF CRT.ddt["N"] OR CRT.symNames THEN
        Msg("symbol name assignment");
        CRT.AssignSymNames(CRT.ddt["N"], CRT.symNames);
      END;
      IF ok AND ~ CRT.ddt["T"] THEN
        Msg("generating parser");
        CRX.GenCompiler;
        IF CRT.genScanner AND ~ CRT.ddt["P"] THEN
          Msg("generating scanner");
          CRA.WriteScanner;
        END;
        IF CRT.ddt["C"] THEN
          Msg("generating compiler");
          CRC.WriteDriver;
        END;
        CRX.WriteStatistics;
      END;
      IF ~ ok THEN Msg("Compilation ended with errors in grammar tests.");
        ELSIF ~ ll1 THEN Msg("Compilation ended with LL(1) errors.");
        ELSE Msg("Compilation completed. No errors detected.");
      END;
    ELSE
      Msg("listing");
      PrintListing; IF CRT.ddt["X"] THEN CRT.XRef END;
      Msg("*** errors detected ***");
    END;
    IF CRT.ddt["G"] THEN CRT.PrintGraph END;
    IF CRT.ddt["S"] THEN CRT.PrintSymbolTable END;
    FileIO.Close(lst); FileIO.Close(src);
  END CR.