Mac-Source 1994 July/Mac-Source_July_1994.iso/Modula/Utilities/Makefiles/MakeParser.MOD

Modula Implementation | 1988-01-24 | 6.0 KB | 173 lines | [TEXT/????]

IMPLEMENTATION MODULE MakeParser;

  (*
   * MAKEMAKE.  Create a MAKEFILE for a MODULA-2 program.
   *
   * Written by Steve Tynor, 30 September 1986.
   *            UUCP  : tynor@gitpyr
   *            USNAIL: 2550 Akers Mill Rd. T-2, Atlanta GA. 30339
   *
   * Permission is granted to distribute, copy and change this program as long
   * as this notice remains...
   ---
   *
   * Make.
   * Modified and extended for MacMETH by :
   * J?rgen N?rgaard, 23 october 1987.
   *            UUCP  : [e-mail]
   *            MAIL  : Dybb?lvej 29, v?r. 2+3, 8240 Risskov, DENMARK
   *
   * Essentially only the parser remains from the original.
   * Extensions are a dependency-tree and a make-like facility.
   *
   *)

IMPORT System;
IMPORT StringLib0;
IMPORT MakeForest;
IMPORT MakeToken;
IMPORT MakeLibraries;

IMPORT InOut;
  (*----------------------------------------------------------------------*)
  PROCEDURE ModulenameToFilename (VAR modulename : ARRAY OF CHAR;
                                      defOrMod   : FileType;
                                  VAR fname      : ARRAY OF CHAR);
  CONST
    EOS = 0C;
  VAR
    c : INTEGER;
  BEGIN
    c := 0;
    WHILE (c < HIGH(modulename)) AND (c <= (HIGH(fname) - 4))
          AND (modulename[c] <> EOS) DO
      fname[c] := modulename[c];
      INC (c);
    END; (* WHILE *)
    fname[c] := '.';
    IF defOrMod = def THEN
      fname[c+1] := 'D'; fname[c+2] := 'E'; fname[c+3] := 'F';
      fname[c+4] := EOS;
    ELSE
      fname[c+1] := 'M'; fname[c+2] := 'O'; fname[c+3] := 'D';
      fname[c+4] := EOS;
    END; (* IF *)
  END ModulenameToFilename;

  (*----------------------------------------------------------------------*)
  PROCEDURE TerminatingToken(VAR token : ARRAY OF CHAR) : BOOLEAN;
  VAR
    temp : BOOLEAN;
  BEGIN
    (* had to split up due to compiler limitation... *)
    temp := StringLib0.Equal (token, 'CONST') OR
            StringLib0.Equal (token, 'TYPE')  OR
            StringLib0.Equal (token, 'VAR')   OR
            StringLib0.Equal (token, 'MODULE');
    RETURN  temp OR
            StringLib0.Equal (token, 'PROCEDURE') OR
            StringLib0.Equal (token, 'BEGIN')     OR
            StringLib0.Equal (token, 'END');
  END TerminatingToken;

  (*----------------------------------------------------------------------*)
  PROCEDURE ParseFROM (  VAR dp       : MakeForest.DepTree;
                         VAR eof      : BOOLEAN;
                         VAR filename : System.Path;
                         VAR succeded   : BOOLEAN);
  VAR
    modulename : MakeForest.NameString;
    de : MakeForest.EntityPtr;
  BEGIN
    MakeToken.NextToken (modulename, eof);
    IF MakeForest.AddModule(modulename, dp, de) THEN
      ParseModule (modulename, def, de, filename, succeded);
      ParseModule (modulename, mod, de, filename, succeded);
    END;
    MakeToken.SkipTillSemicolon (eof);
  END ParseFROM;

  (*----------------------------------------------------------------------*)
  PROCEDURE ParseIMPORT ( VAR dp       : MakeForest.DepTree;
                          VAR eof      : BOOLEAN;
                          VAR filename : System.Path;
                         VAR succeded   : BOOLEAN);
  VAR
    modulename : MakeForest.NameString;
    de : MakeForest.EntityPtr;
  BEGIN
    MakeToken.NextToken (modulename, eof);
    WHILE (modulename[0] <> ';') AND succeded DO
      IF MakeForest.AddModule(modulename, dp, de) THEN
        ParseModule (modulename, def, de, filename, succeded);
        ParseModule (modulename, mod, de, filename, succeded);
      END;
      MakeToken.NextToken (modulename, eof);
    END; (* WHILE *)
  END ParseIMPORT;

  (*----------------------------------------------------------------------*)
  PROCEDURE ParseModule (VAR modulename : MakeForest.NameString;
                             type       : FileType;
                         VAR de         : MakeForest.EntityPtr;
                         VAR filename   : System.Path;
                         VAR succeded   : BOOLEAN);
  VAR
    token    : ARRAY [0 .. 132] OF CHAR;
    success,
    eof      : BOOLEAN;
    tempName : System.Path;
  BEGIN
    ModulenameToFilename (modulename, type, filename);
    succeded := TRUE;
    IF MakeLibraries.IsALibraryModule (modulename) THEN
      de^.library := TRUE;
      InOut.WriteString(modulename);
      InOut.WriteString(' (Library)');
      InOut.WriteLn;
    ELSE
      MakeToken.OpenFile (filename, success);
      IF type = def THEN
        de^.defName := filename;
      ELSE
        de^.impName := filename;
      END;
      InOut.WriteString('- ');
      InOut.WriteString(filename);
      IF NOT success THEN
        InOut.WriteString(', File Not Found'); InOut.WriteLn;
        succeded := FALSE;
      ELSE
        MakeToken.NextToken (token, eof);
        IF    (type = def) AND NOT StringLib0.Equal(token, 'DEFINITION') THEN
          InOut.WriteString('Expected a "DEFINITION"-MODULE');
        ELSIF (type = mod) AND NOT StringLib0.Equal(token, 'IMPLEMENTATION') THEN
          InOut.WriteString('Expected a "IMPLEMENTATION"-MODULE');
        ELSIF (type = main) AND NOT StringLib0.Equal(token, 'MODULE') THEN
          InOut.WriteString('Expected a "MODULE"-MODULE');
        END; (* IF / ELSE / ENDIF *)
        InOut.WriteLn;
        MakeToken.SkipTillSemicolon (eof);
        token := ';';
        WHILE (NOT eof) AND (NOT TerminatingToken(token)) DO
          IF StringLib0.Equal (token, 'FROM') THEN
            IF type = def THEN
              ParseFROM (de^.DEFDepends, eof, tempName, succeded);
            ELSE
              ParseFROM (de^.MODDepends, eof, tempName, succeded);
            END;
          ELSIF StringLib0.Equal (token, 'IMPORT') THEN
            IF type = def THEN
              ParseIMPORT (de^.DEFDepends, eof, tempName, succeded);
            ELSE
              ParseIMPORT (de^.MODDepends, eof, tempName, succeded);
            END;
          END; (* IF *)
          MakeToken.NextToken (token, eof);
        END; (* WHILE *)
      END; (* IF file opened *)
      MakeToken.CloseFile;
    END;(* IF ELSE we need to check this one *)
  END ParseModule;
END MakeParser.