home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD2.bin / bbs / dev / oberon-a-1.4ß.lha / Oberon-A / source / Misc / StripComments.mod < prev    next >
Text File  |  1994-08-08  |  10KB  |  399 lines
  1. (*************************************************************************
  2.  
  3.      $RCSfile: StripComments.mod $
  4.   Description: A utility to strip comments from Oberon source files.
  5.  
  6.    Created by: fjc (Frank Copeland)
  7.     $Revision: 1.5 $
  8.       $Author: fjc $
  9.         $Date: 1994/08/08 16:28:19 $
  10.  
  11.   Copyright © 1994, Frank Copeland.
  12.   This file is part of Oberon-A.
  13.   See Oberon-A.doc for conditions of use and distribution.
  14.  
  15. *************************************************************************)
  16.  
  17. MODULE StripComments;
  18.  
  19. (* $P- allow non-portable code *)
  20.  
  21. IMPORT
  22.   SYS := SYSTEM, Exec, Dos, DosUtil, Args, Files, IO := StdIO,
  23.   Str := Strings, Errors;
  24.  
  25. CONST
  26.   VersionTag   = "\0$VER: StripComments 1.1 (5.6.94)";
  27.   VersionStr   = "StripComments 1.1 (5 Jun 1994)\r\n";
  28.   CopyrightStr = "Copyright © 1994, Frank Copeland\n";
  29.   UsageStr     = "see Oberon-A.doc for conditions of use\n";
  30.   FileTag      = "\n\n(* Comments stripped by StripComments 1.1 *)\n";
  31.  
  32. CONST
  33.  
  34.   PathLen = 255;
  35.  
  36. TYPE
  37.  
  38.   Path = ARRAY PathLen + 1 OF CHAR;
  39.  
  40. VAR
  41.  
  42.   pattern,    (* The pattern to be searched for. *)
  43.   dest        (* The destination directory. *)
  44.     : Path;
  45.  
  46.   (*
  47.     These variables are global so that they may be found by the Cleanup()
  48.     procedure in the event of an abnormal exit
  49.   *)
  50.  
  51.   input,      (* The current input file. *)
  52.   output      (* The current output file. *)
  53.     : Files.File;
  54.  
  55.   r, w : Files.Rider;
  56.   ch : CHAR;
  57.  
  58. CONST
  59.  
  60.   CR = 0DX; LF = 0AX; TAB = 09X; SP = " ";
  61.  
  62. VAR
  63.  
  64.   state, line, spaces, blanklines : INTEGER;
  65.   blankline : BOOLEAN;
  66.  
  67. CONST
  68.  
  69.   STARTLINE = 0;
  70.   WHITESPACE = 1;
  71.   COPYCHAR = 2;
  72.   LEFTBRACKET = 3;
  73.   STARTCOMMENT = 4;
  74.   COPYCOMMENT = 5;
  75.   SKIPCOMMENT = 6;
  76.   STAR = 7;
  77.   ENDCOMMENT = 8;
  78.  
  79. (*------------------------------------*)
  80. PROCEDURE Greetings ();
  81.  
  82. BEGIN (* Greetings *)
  83.   IO.WriteStr (VersionStr);
  84.   IO.WriteStr (CopyrightStr);
  85.   IO.WriteStr (UsageStr);
  86.   IO.WriteLn ();
  87. END Greetings;
  88.  
  89. PROCEDURE GetArgs ();
  90.  
  91.   (*------------------------------------*)
  92.   PROCEDURE Usage ();
  93.  
  94.   BEGIN (* Usage *)
  95.     IO.WriteStr ("format  : StripComments <pattern> <destination>\n");
  96.     IO.WriteStr ("template: PATTERN/A, DESTINATION/A\n\n");
  97.     IO.WriteStr ("<pattern>    : files to be converted\n");
  98.     IO.WriteStr ("<destination>: destination directory\n\n");
  99.   END Usage;
  100.  
  101. BEGIN (* GetArgs *)
  102.   (* Check the number of arguments. *)
  103.   IF (Args.argc # 3) THEN Usage (); HALT (Dos.returnWarn) END;
  104.  
  105.   (* Copy the pattern and destination *)
  106.   COPY (Args.argv [1]^, pattern);
  107.   COPY (Args.argv [2]^, dest);
  108.  
  109.   (* The destination needs to be checked. *)
  110.   Errors.Assert
  111.     ( DosUtil.FileExists (dest), "Destination directory doesn't exist" )
  112. END GetArgs;
  113.  
  114. (*$D-*)
  115. PROCEDURE MakeOutputName
  116.   (inputName : ARRAY OF CHAR; VAR outputName : ARRAY OF CHAR);
  117.  
  118.   VAR filePart : Exec.STRPTR;
  119.  
  120. BEGIN (* MakeOutputName *)
  121.   filePart := Dos.base.FilePart (inputName);
  122.   COPY (dest, outputName);
  123.   Errors.Assert
  124.     ( Dos.base.AddPart (outputName, filePart^, PathLen),
  125.       "Output file name too big" )
  126. END MakeOutputName;
  127.  
  128. PROCEDURE WriteSpaces ();
  129.  
  130. BEGIN (* WriteSpaces *)
  131.   WHILE spaces > 0 DO Files.Write (w, SP); DEC (spaces) END
  132. END WriteSpaces;
  133.  
  134. (*$D-*)
  135. PROCEDURE WriteString (s : ARRAY OF CHAR);
  136.  
  137.   VAR i : INTEGER; ch : CHAR;
  138.  
  139. BEGIN (* WriteString *)
  140.   i := 0; ch := s [0];
  141.   WHILE ch # 0X DO Files.Write (w, ch); INC (i); ch := s [i] END
  142. END WriteString;
  143.  
  144. PROCEDURE CopyComment ();
  145.  
  146. BEGIN (* CopyComment *)
  147.   state := COPYCOMMENT;
  148.   LOOP
  149.     Files.Read (r, ch);
  150.     IF r.eof THEN
  151.       IO.WriteStr (" !! End of file encountered in CopyComment()\n"); EXIT
  152.     END;
  153.     Files.Write (w, ch);
  154.     CASE ch OF
  155.       LF :
  156.         INC (line);
  157.         IF (line MOD 10) = 0 THEN IO.WriteInt (line); IO.Write (CR) END;
  158.         state := COPYCOMMENT
  159.       |
  160.       "(" : state := LEFTBRACKET
  161.       |
  162.       "*" :
  163.         IF state = LEFTBRACKET THEN CopyComment (); state := COPYCOMMENT
  164.         ELSE state := STAR
  165.         END
  166.       |
  167.       ")" : IF state = STAR THEN EXIT ELSE state := COPYCOMMENT END
  168.       |
  169.     ELSE state := COPYCOMMENT
  170.     END
  171.   END
  172. END CopyComment;
  173.  
  174. PROCEDURE SkipComment ();
  175.  
  176. BEGIN (* SkipComment *)
  177.   state := SKIPCOMMENT;
  178.   LOOP
  179.     CASE ch OF
  180.       LF :
  181.         INC (line); INC (blanklines);
  182.         IF (line MOD 10) = 0 THEN IO.WriteInt (line); IO.Write (CR) END;
  183.         state := SKIPCOMMENT
  184.       |
  185.       "(" : state := LEFTBRACKET
  186.       |
  187.       "*" :
  188.         IF state = LEFTBRACKET THEN SkipComment (); state := SKIPCOMMENT
  189.         ELSE state := STAR
  190.         END
  191.       |
  192.       ")" : IF state = STAR THEN EXIT ELSE state := SKIPCOMMENT END
  193.       |
  194.     ELSE state := SKIPCOMMENT
  195.     END;
  196.     Files.Read (r, ch);
  197.     IF r.eof THEN
  198.       IO.WriteStr (" !! End of file encountered in SkipComment()\n"); EXIT
  199.     END;
  200.   END
  201. END SkipComment;
  202.  
  203. PROCEDURE ChangeState ();
  204.  
  205. BEGIN (* ChangeState *)
  206.   CASE state OF
  207.     STARTLINE :
  208.       INC (line);
  209.       IF (line MOD 10) = 0 THEN IO.WriteInt (line); IO.Write (CR) END;
  210.       IF blankline THEN INC (blanklines)
  211.       ELSE blanklines := 0; blankline := TRUE
  212.       END;
  213.       IF blanklines < 2 THEN Files.Write (w, LF) END;
  214.       spaces := 0;
  215.       CASE ch OF
  216.         LF : state := STARTLINE
  217.         |
  218.         SP : INC (spaces); state := WHITESPACE
  219.         |
  220.         TAB : INC (spaces, 8); state := WHITESPACE
  221.         |
  222.         "(" : state := LEFTBRACKET
  223.         |
  224.       ELSE
  225.         Files.Write (w, ch); state := COPYCHAR
  226.       END;
  227.     |
  228.     WHITESPACE :
  229.       CASE ch OF
  230.         LF : state := STARTLINE
  231.         |
  232.         SP : INC (spaces); state := WHITESPACE
  233.         |
  234.         TAB : INC (spaces, 8); state := WHITESPACE
  235.         |
  236.         "(" : state := LEFTBRACKET
  237.         |
  238.       ELSE
  239.         WriteSpaces(); Files.Write (w, ch); state := COPYCHAR
  240.       END;
  241.     |
  242.     COPYCHAR :
  243.       blankline := FALSE;
  244.       CASE ch OF
  245.         LF : state := STARTLINE
  246.         |
  247.         SP : INC (spaces); state := WHITESPACE
  248.         |
  249.         TAB : INC (spaces, 8); state := WHITESPACE
  250.         |
  251.         "(" : state := LEFTBRACKET
  252.         |
  253.       ELSE
  254.         Files.Write (w, ch); state := COPYCHAR
  255.       END;
  256.     |
  257.     LEFTBRACKET :
  258.       CASE ch OF
  259.         "*" : state := STARTCOMMENT
  260.         |
  261.         LF :
  262.           WriteSpaces (); Files.Write (w, "("); state := STARTLINE
  263.         |
  264.         SP :
  265.           WriteSpaces (); Files.Write (w, "("); spaces := 1;
  266.           blankline := FALSE; state := WHITESPACE
  267.         |
  268.         TAB :
  269.           WriteSpaces (); Files.Write (w, "("); spaces := 8;
  270.           blankline := FALSE; state := WHITESPACE
  271.         |
  272.         "(" :
  273.           WriteSpaces (); Files.Write (w, "("); blankline := FALSE;
  274.           state := LEFTBRACKET
  275.         |
  276.       ELSE
  277.         WriteSpaces (); Files.Write (w, "("); Files.Write (w, ch);
  278.         state := COPYCHAR
  279.       END;
  280.     |
  281.     STARTCOMMENT :
  282.       IF ch = "!" THEN
  283.         WriteSpaces(); WriteString ("(*"); CopyComment ();
  284.         blankline := FALSE
  285.       ELSE
  286.         SkipComment ()
  287.       END;
  288.       state := ENDCOMMENT
  289.     |
  290.     ENDCOMMENT :
  291.       CASE ch OF
  292.         LF : state := STARTLINE
  293.         |
  294.         SP : INC (spaces); state := WHITESPACE
  295.         |
  296.         TAB : INC (spaces, 8); state := WHITESPACE
  297.         |
  298.         "(" : state := LEFTBRACKET
  299.         |
  300.       ELSE
  301.         Files.Write (w, ch); state := COPYCHAR
  302.       END;
  303.     |
  304.   END
  305. END ChangeState;
  306.  
  307. (*$D-*)
  308. PROCEDURE Strip (inputName : ARRAY OF CHAR);
  309.  
  310.   VAR outputName : Path;
  311.  
  312. BEGIN (* Strip *)
  313.   input := Files.Old (inputName);
  314.   IF input # NIL THEN
  315.     MakeOutputName (inputName, outputName);
  316.     output := Files.New (outputName);
  317.     IF output # NIL THEN
  318.       IO.WriteF2
  319.         (" !! %s -> %s\n", SYS.ADR (inputName), SYS.ADR (outputName));
  320.       Files.Set (r, input, 0);
  321.       Files.Set (w, output, 0);
  322.       spaces := 0; state := WHITESPACE; line := 1; blankline := FALSE;
  323.       WHILE ~r.eof DO
  324.         Files.Read (r, ch);
  325.         ChangeState ()
  326.       END;
  327.       WriteString (FileTag);
  328.       IO.WriteStr (". reached #1\n");
  329.       Files.Register (output)
  330.       ;IO.WriteStr (". reached #2\n")
  331.     ELSE
  332.       IO.WriteF1 (" !! Could not open %s\n", SYS.ADR (outputName))
  333.     END;
  334.     Files.Close (input)
  335.   ELSE
  336.     IO.WriteF1 (" !! Could not open %s\n", SYS.ADR (inputName))
  337.   END;
  338.  
  339.   in