Add A command line parsing procedure

source/CommandLine.def

@@ -0,0 +1,3 @@
+DEFINITION MODULE CommandLine;
+
+END CommandLine.

source/CommandLine.mod

@@ -0,0 +1,3 @@
+MODULE CommandLine;
+
+END CommandLine.

source/CommandLineInterface.def

@@ -0,0 +1,15 @@
+DEFINITION MODULE CommandLineInterface;
+
+FROM Common IMPORT ShortString;
+
+TYPE
+  CommandLine = RECORD
+    input: ShortString;
+    lex: BOOLEAN;
+    parse: BOOLEAN
+  END;
+  PCommandLine = POINTER TO CommandLine;
+
+PROCEDURE parse_command_line(): PCommandLine;
+
+END CommandLineInterface.

source/CommandLineInterface.mod

@@ -0,0 +1,74 @@
+IMPLEMENTATION MODULE CommandLineInterface;
+
+FROM SYSTEM IMPORT ADR, TSIZE;
+
+FROM Args IMPORT GetArg, Narg;
+FROM FIO IMPORT WriteString, WriteChar, WriteLine, StdErr;
+FROM Storage IMPORT ALLOCATE;
+FROM Strings IMPORT CompareStr, Length;
+FROM MemUtils IMPORT MemZero;
+
+FROM Common IMPORT ShortString;
+
+PROCEDURE parse_command_line(): PCommandLine;
+VAR
+  parameter: ShortString;
+  i: CARDINAL;
+  result: PCommandLine;
+  parsed: BOOLEAN;
+BEGIN
+  i := 1;
+  ALLOCATE(result, TSIZE(CommandLine));
+  result^.lex := FALSE;
+  result^.parse := FALSE;
+  MemZero(ADR(result^.input), 256);
+
+  WHILE (i < Narg()) AND (result <> NIL) DO
+    parsed := GetArg(parameter, i);
+    parsed := FALSE;
+
+    IF CompareStr(parameter, '--lex') = 0 THEN
+      parsed := TRUE;
+      result^.lex := TRUE
+    END;
+    IF CompareStr(parameter, '--parse') = 0 THEN
+      parsed := TRUE;
+      result^.parse := TRUE
+    END;
+    IF parameter[0] <> '-' THEN
+      parsed := TRUE;
+
+      IF Length(result^.input) > 0 THEN
+        WriteString(StdErr, 'Fatal error: only one source file can be compiled at once. First given "');
+        WriteString(StdErr, result^.input);
+        WriteString(StdErr, '", then "');
+        WriteString(StdErr, parameter);
+        WriteString(StdErr, '".');
+        WriteLine(StdErr);
+        result := NIL
+      END;
+      IF result <> NIL THEN
+        result^.input := parameter
+      END
+    END;
+    IF parsed = FALSE THEN
+      WriteString(StdErr, 'Fatal error: unknown command line options: ');
+
+      WriteString(StdErr, parameter);
+      WriteChar(StdErr, '.');
+      WriteLine(StdErr);
+
+      result := NIL
+    END;
+
+    i := i + 1
+  END;
+  IF (result <> NIL) AND (Length(result^.input) = 0) THEN
+    WriteString(StdErr, 'Fatal error: no input files.');
+    WriteLine(StdErr);
+    result := NIL
+  END;
+
+  RETURN result
+END parse_command_line;
+END CommandLineInterface.

source/Common.def

@@ -0,0 +1,6 @@
+DEFINITION MODULE Common;
+
+TYPE
+  ShortString = ARRAY[0..255] OF CHAR;
+
+END Common.

source/Common.mod

@@ -0,0 +1,3 @@
+IMPLEMENTATION MODULE Common;
+
+END Common.

source/Compiler.mod

@@ -1,18 +1,50 @@
 MODULE Compiler;
 
-FROM FIO IMPORT StdIn;
+FROM FIO IMPORT Close, IsNoError, File, OpenToRead, StdErr, StdOut, WriteLine, WriteString;
 FROM SYSTEM IMPORT ADR;
+FROM M2RTS IMPORT HALT, ExitOnHalt;
 
 FROM Lexer IMPORT Lexer, lexer_destroy, lexer_initialize;
 FROM Transpiler IMPORT transpile;
+FROM CommandLineInterface IMPORT PCommandLine, parse_command_line;
 
+VAR
+  command_line: PCommandLine;
+
+PROCEDURE compile_from_stream();
 VAR
   lexer: Lexer;
-
+  source_input: File;
 BEGIN
-  lexer_initialize(ADR(lexer), StdIn);
+  source_input := OpenToRead(command_line^.input);
 
-  transpile(ADR(lexer));
+  IF IsNoError(source_input) = FALSE THEN
+    WriteString(StdErr, 'Fatal error: failed to read the input file "');
+    WriteString(StdErr, command_line^.input);
+    WriteString(StdErr, '".');
+    WriteLine(StdErr);
 
-  lexer_destroy(ADR(lexer))
+    ExitOnHalt(2)
+  END;
+  IF IsNoError(source_input) THEN
+    lexer_initialize(ADR(lexer), source_input);
+
+    transpile(ADR(lexer), StdOut);
+
+    lexer_destroy(ADR(lexer));
+
+    Close(source_input)
+  END
+END compile_from_stream;
+BEGIN
+  ExitOnHalt(0);
+  command_line := parse_command_line();
+
+  IF command_line <> NIL THEN
+    compile_from_stream()
+  END;
+  IF command_line = NIL THEN
+    ExitOnHalt(1)
+  END;
+  HALT()
 END Compiler.

source/Parser.def

@@ -0,0 +1,32 @@
+DEFINITION MODULE Parser;
+
+TYPE
+  AstConstantDeclaration = RECORD
+  END;
+  PAstConstantDeclaration = POINTER TO AstConstantDeclaration;
+  PPAstConstantDeclaration = POINTER TO PAstConstantDeclaration;
+
+  AstTypeExpression = RECORD
+  END;
+  PAstTypeExpression = POINTER TO AstTypeExpression;
+
+  AstTypeDeclaration = RECORD
+    identifier: ARRAY[1..256] OF CHAR;
+    type_expression: PAstTypeExpression
+  END;
+  PAstTypeDeclaration = POINTER TO AstTypeDeclaration;
+  PPAstTypeDeclaration = POINTER TO PAstTypeDeclaration;
+
+  AstVariableDeclaration = RECORD
+  END;
+  PAstVariableDeclaration = POINTER TO AstVariableDeclaration;
+  PPAstVariableDeclaration = POINTER TO PAstVariableDeclaration;
+
+  AstModule = RECORD
+    constants: PPAstConstantDeclaration;
+    types: PPAstTypeDeclaration;
+    variables: PPAstVariableDeclaration
+  END;
+  PAstModule = POINTER TO AstModule;
+
+END Parser.

source/Parser.mod

@@ -0,0 +1,3 @@
+IMPLEMENTATION MODULE Parser;
+
+END Parser.

source/Transpiler.def

@@ -1,7 +1,17 @@
 DEFINITION MODULE Transpiler;
 
-FROM Lexer IMPORT PLexer;
+FROM FIO IMPORT File;
 
-PROCEDURE transpile(ALexer: PLexer);
+FROM Lexer IMPORT PLexer, Lexer;
+
+TYPE
+  TranspilerContext = RECORD
+    indentation: CARDINAL;
+    output: File;
+    lexer: PLexer
+  END;
+  PTranspilerContext = POINTER TO TranspilerContext;
+
+PROCEDURE transpile(lexer: PLexer; output: File);
 
 END Transpiler.