home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / demos / 108 / modula / makepars.mod < prev    next >
Encoding:
Modula Implementation  |  1987-02-20  |  5.2 KB  |  145 lines
  1. IMPLEMENTATION MODULE MakeParse;
  2.  
  3.   (*
  4.    * MAKEMAKE.  Create a MAKEFILE for a MODULA-2 program.
  5.    *
  6.    * Written by Steve Tynor, 30 September 1986.
  7.    *            UUCP  : tynor@gitpyr
  8.    *            USNAIL: 2550 Akers Mill Rd. T-2, Atlanta GA. 30339
  9.    *
  10.    * Permission is granted to distribute, copy and change this program as long
  11.    * as this notice remains...
  12.    *)
  13.  
  14. IMPORT MakeToken;
  15. IMPORT MakeForest;
  16. IMPORT Strings;
  17. IMPORT MakeLibraries;
  18.  
  19.   (*----------------------------------------------------------------------*)
  20.   PROCEDURE ModulenameToFilename (VAR modulename : ARRAY OF CHAR;
  21.                                       defOrMod   : FileType;
  22.                                   VAR fname      : ARRAY OF CHAR);
  23.   CONST
  24.     EOS = 0C;
  25.   VAR
  26.     c : CARDINAL;
  27.   BEGIN
  28.     c := 0;
  29.     WHILE (c < HIGH (modulename)) AND (c < 8) AND (modulename[c] <> EOS) DO
  30.       fname[c] := modulename[c];
  31.       INC (c);
  32.     END; (* WHILE *)
  33.     fname[c] := '.';
  34.     IF defOrMod = def THEN
  35.       fname[c+1] := 'D'; fname[c+2] := 'E'; fname[c+3] := 'F'; 
  36.       fname[c+4] := EOS;
  37.     ELSE
  38.       fname[c+1] := 'M'; fname[c+2] := 'O'; fname[c+3] := 'D';
  39.       fname[c+4] := EOS;
  40.     END; (* IF *)
  41.   END ModulenameToFilename;
  42.  
  43.  
  44.   (*----------------------------------------------------------------------*)
  45.   PROCEDURE TerminatingToken(VAR token : ARRAY OF CHAR) : BOOLEAN;
  46.   VAR
  47.     temp : BOOLEAN;
  48.   BEGIN
  49.     (* had to split up due to compiler limitation... *)
  50.     temp := (Strings.Compare (token, 'CONST')     = Strings.Equal) OR
  51.             (Strings.Compare (token, 'TYPE')      = Strings.Equal) OR
  52.             (Strings.Compare (token, 'VAR')       = Strings.Equal) OR
  53.             (Strings.Compare (token, 'MODULE')    = Strings.Equal);
  54.     RETURN  temp OR
  55.             (Strings.Compare (token, 'PROCEDURE') = Strings.Equal) OR
  56.             (Strings.Compare (token, 'BEGIN')     = Strings.Equal) OR
  57.             (Strings.Compare (token, 'END')       = Strings.Equal);
  58.   END TerminatingToken;
  59.  
  60.  
  61.   (*----------------------------------------------------------------------*)
  62.   PROCEDURE ParseFROM (      fileDef : MakeForest.FileDefinitionList;
  63.                          VAR eof     : BOOLEAN );
  64.   VAR
  65.     modulename, filename : ARRAY [0 .. 100] OF CHAR;
  66.   BEGIN
  67.     MakeToken.NextToken (modulename, eof);
  68.     ParseModule (modulename, def, filename);
  69.     MakeForest.AddImport (fileDef, filename);
  70.     MakeToken.SkipTillSemicolon (eof);
  71.  
  72.     ParseModule (modulename, mod, filename);
  73.   END ParseFROM;
  74.  
  75.   (*----------------------------------------------------------------------*)
  76.   PROCEDURE ParseIMPORT (    fileDef : MakeForest.FileDefinitionList;
  77.                          VAR eof     : BOOLEAN );
  78.   VAR
  79.     modulename, filename : ARRAY [0 .. 100] OF CHAR;
  80.   BEGIN
  81.     MakeToken.NextToken (modulename, eof);
  82.     WHILE modulename[0] <> ';' DO
  83.       ParseModule (modulename, def, filename);
  84.       MakeForest.AddImport (fileDef, filename);
  85.  
  86.       ParseModule (modulename, mod, filename);
  87.       MakeToken.NextToken (modulename, eof);
  88.     END; (* WHILE *)
  89.   END ParseIMPORT;
  90.  
  91.   (*----------------------------------------------------------------------*)
  92.   PROCEDURE ParseModule (VAR modulename : ARRAY OF CHAR;
  93.                              type       : FileType;
  94.                          VAR filename   : ARRAY OF CHAR);
  95.   VAR 
  96.     token    : ARRAY [0 .. 132] OF CHAR;
  97.     fileDef  : MakeForest.FileDefinitionList;
  98.     success,
  99.     eof      : BOOLEAN;
  100.  
  101.   BEGIN
  102.     ModulenameToFilename (modulename, type, filename);
  103.  
  104.     IF MakeForest.AddFile (filename, fileDef) THEN
  105.       MakeToken.OpenFile (filename, success);
  106.  
  107.       IF NOT success THEN
  108.         IF MakeLibraries.IsALibraryModule (modulename) THEN
  109.           fileDef^.library := TRUE;
  110.         ELSE
  111.           MakeForest.AddImport (fileDef, "## SOURCE FILE NOT FOUND ##");
  112.         END; (* IF *)
  113.       ELSE
  114.         MakeToken.NextToken (token, eof);
  115.         IF    (type = def) AND NOT
  116.               (Strings.Compare (token, 'DEFINITION') = Strings.Equal) THEN
  117.           MakeForest.AddImport (fileDef, 
  118.                                 "## Expected a 'DEFINITION' module ##");
  119.         ELSIF (type = mod) AND NOT
  120.               (Strings.Compare (token, 'IMPLEMENTATION') = Strings.Equal) THEN
  121.           MakeForest.AddImport (fileDef, 
  122.                                 "## Expected an 'IMPLEMENTATION' module ##");
  123.         ELSIF (type = main) AND NOT
  124.               (Strings.Compare (token, 'MODULE') = Strings.Equal) THEN
  125.           MakeForest.AddImport (fileDef, 
  126.                                 "## Expected a 'MODULE' module ##");
  127.         END; (* IF / ELSE / ENDIF *)
  128.         MakeToken.SkipTillSemicolon (eof);
  129.         token := ';';
  130.         WHILE (NOT eof) AND (NOT TerminatingToken(token)) DO
  131.           IF Strings.Compare (token, 'FROM') = Strings.Equal THEN
  132.             ParseFROM (fileDef, eof);
  133.           ELSIF Strings.Compare (token, 'IMPORT') = Strings.Equal THEN
  134.             ParseIMPORT (fileDef, eof);
  135.           END; (* IF *)
  136.           MakeToken.NextToken (token, eof);
  137.         END; (* WHILE *)
  138.       END; (* IF file opened *)
  139.       MakeToken.CloseFile;
  140.     END; (* IF we need to check this one *)
  141.  
  142.   END ParseModule;
  143.  
  144. END MakeParse.
  145.