Transpile type section

.gitignore

@@ -1,3 +1,3 @@
 a.out
-/dub.selections.json
+/boot/
 /build/

Rakefile

@@ -13,13 +13,13 @@ directory 'build/self'
 CLEAN.include 'build'
 
 rule(/build\/stage1\/.+\.o$/ => ->(file) {
-  path = Pathname.new('source') + Pathname.new(file).basename
+  path = Pathname.new('boot/stage1/source') + Pathname.new(file).basename
 
   ['build/stage1', path.sub_ext('.def'), path.sub_ext('.elna')]
 }) do |t|
   sources = t.prerequisites.filter { |f| f.end_with? '.elna' }
 
-  sh M2C, '-fmod=.elna', '-c', '-I', 'source', '-o', t.name, *sources
+  sh M2C, '-fmod=.elna', '-c', '-I', 'boot/stage1/source', '-o', t.name, *sources
 end
 
 file 'build/stage1/elna' => FileList['boot/stage1/source/*'].map { |file|
@@ -28,7 +28,7 @@ file 'build/stage1/elna' => FileList['boot/stage1/source/*'].map { |file|
   sh M2C, '-o', t.name, *t.prerequisites
 end
 
-file 'build/stage1/Compiler.o' => ['build/stage1', 'source/Compiler.elna'] do |t|
+file 'build/stage1/Compiler.o' => ['build/stage1', 'boot/stage1/source/Compiler.elna'] do |t|
   sources = t.prerequisites.filter { |f| f.end_with? '.elna' }
 
   sh M2C, '-fscaffold-main', '-fmod=.elna', '-c', '-I', 'boot/stage1/source', '-o', t.name, *sources

source/Compiler.elna

@@ -1,10 +1,10 @@
-MODULE Compiler;
+module Compiler;
 
-FROM FIO IMPORT StdIn;
+from FIO import StdIn;
-FROM SYSTEM IMPORT ADR;
+from SYSTEM import ADR;
 
-FROM Lexer IMPORT Lexer, LexerDestroy, LexerInitialize;
+from Lexer import Lexer, LexerDestroy, LexerInitialize;
-FROM Transpiler IMPORT Transpile;
+from Transpiler import Transpile;
 
 VAR
   ALexer: Lexer;

source/Lexer.def

@@ -71,8 +71,8 @@ TYPE
     lexerKindCharacter,
     lexerKindString,
     lexerKindFrom,
-    lexerKindExclamation,
+    lexerKindPointer,
-    lexerKindArrow,
+    lexerKindArray,
     lexerKindTrait,
     lexerKindProgram,
     lexerKindModule,

source/Lexer.elna

@@ -1,16 +1,17 @@
-IMPLEMENTATION MODULE Lexer;
+implementation module Lexer;
 
-FROM FIO IMPORT ReadNBytes;
+from FIO import ReadNBytes;
-FROM SYSTEM IMPORT ADR;
+from SYSTEM import ADR;
 
-FROM Storage IMPORT DEALLOCATE, ALLOCATE;
+from Storage import DEALLOCATE, ALLOCATE;
-FROM Strings IMPORT Length;
+from Strings import Length;
-FROM MemUtils IMPORT MemZero;
+from MemUtils import MemZero;
+from StrCase import Lower;
 
-CONST
+const
   ChunkSize = 65536;
 
-TYPE
+type
   (*
    * Classification table assigns each possible character to a group (class). All
   * characters of the same group a handled equivalently.
@@ -59,11 +60,11 @@ TYPE
     transitionStateDecimalSuffix,
     transitionStateEnd
   );
-  TransitionAction = PROCEDURE(PLexer, PLexerToken);
+  TransitionAction = procedure(PLexer, PLexerToken);
-  Transition = RECORD
+  Transition = record
     Action: TransitionAction;
     NextState: TransitionState
-  END;
+  end;
 
 VAR
   Classification: ARRAY[1..128] OF TransitionClass;
@@ -210,7 +211,7 @@ BEGIN
   Result := TRUE;
 
   WHILE (Index < Length(Keyword)) AND (TokenStart <> TokenEnd) AND Result DO
-    Result := Keyword[Index] = TokenStart^;
+    Result := (Keyword[Index] = TokenStart^) OR (Lower(Keyword[Index]) = TokenStart^);
     INC(TokenStart);
     INC(Index)
   END;
@@ -344,6 +345,10 @@ BEGIN
     AToken^.Kind := lexerKindModule
   ELSIF CompareKeyword('IMPLEMENTATION', ALexer^.Start, ALexer^.Current) THEN
     AToken^.Kind := lexerKindImplementation
+  ELSIF CompareKeyword('POINTER', ALexer^.Start, ALexer^.Current) THEN
+    AToken^.Kind := lexerKindPointer
+  ELSIF CompareKeyword('ARRAY', ALexer^.Start, ALexer^.Current) THEN
+    AToken^.Kind := lexerKindArray
   ELSIF CompareKeyword('TRUE', ALexer^.Start, ALexer^.Current) THEN
     AToken^.Kind := lexerKindBoolean;
     AToken^.booleanKind := TRUE
@@ -685,7 +690,6 @@ VAR
   Result: LexerToken;
 BEGIN
   ALexer^.Current := ALexer^.Start;
-  Result.Kind := lexerKindTrait;
   CurrentState := transitionStateStart;
 
   WHILE CurrentState <> transitionStateEnd DO

source/Transpiler.elna

@@ -1,15 +1,16 @@
-IMPLEMENTATION MODULE Transpiler;
+implementation module Transpiler;
 
-FROM FIO IMPORT WriteNBytes, StdOut;
+from FIO import WriteNBytes, StdOut;
-FROM SYSTEM IMPORT ADR, ADDRESS;
+from SYSTEM import ADR, ADDRESS;
 
-FROM Terminal IMPORT Write, WriteLn, WriteString;
+from Terminal import Write, WriteLn, WriteString;
-FROM Lexer IMPORT Lexer, LexerToken, LexerCurrent, LexerLex, LexerKind;
+from Lexer import Lexer, LexerToken, LexerCurrent, LexerLex, LexerKind;
 
-TYPE
+type
-  TranspilerContext = RECORD
+  PTranspilerContext = pointer to TranspilerContext;
-  END;
+  TranspilerContext = record
-  PTranspilerContext = POINTER TO TranspilerContext;
+    Indentation: CARDINAL
+  end;
 
 (* Calls LexerLex() but skips the comments. *)
 PROCEDURE TranspilerLex(ALexer: PLexer): LexerToken;
@@ -138,6 +139,7 @@ BEGIN
   Token := TranspilerLex(ALexer);
   TranspileImportPart(AContext, ALexer);
   TranspileConstantPart(AContext, ALexer);
+  TranspileTypePart(AContext, ALexer);
 
   Token := LexerCurrent(ALexer);
   WHILE Token.Kind <> lexerKindEof DO
@@ -148,6 +150,165 @@ BEGIN
   END
 END TranspileModule;
 
+PROCEDURE TranspileTypeFields(AContext: PTranspilerContext; ALexer: PLexer);
+VAR
+  Token: LexerToken;
+  WrittenBytes: CARDINAL;
+BEGIN
+  Token := TranspilerLex(ALexer);
+
+  WHILE Token.Kind <> lexerKindEnd DO
+    WriteString('    ');
+    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+    Token := TranspilerLex(ALexer);
+    WriteString(': ');
+    TranspileTypeExpression(AContext, ALexer);
+	Token := TranspilerLex(ALexer);
+
+	IF Token.Kind = lexerKindSemicolon THEN
+      Token := TranspilerLex(ALexer);
+	  WriteSemicolon()
+    ELSE
+      WriteLn()
+    END
+  END
+END TranspileTypeFields;
+
+PROCEDURE TranspileRecordType(AContext: PTranspilerContext; ALexer: PLexer);
+VAR
+  Token: LexerToken;
+BEGIN
+  WriteString('RECORD');
+  WriteLn();
+  TranspileTypeFields(AContext, ALexer);
+  WriteString('  END')
+END TranspileRecordType;
+
+PROCEDURE TranspilePointerType(AContext: PTranspilerContext; ALexer: PLexer);
+VAR
+  Token: LexerToken;
+  WrittenBytes: CARDINAL;
+BEGIN
+  WriteString('POINTER TO ');
+  Token := TranspilerLex(ALexer);
+  TranspileTypeExpression(AContext, ALexer)
+END TranspilePointerType;
+
+PROCEDURE TranspileArrayType(AContext: PTranspilerContext; ALexer: PLexer);
+VAR
+  Token: LexerToken;
+BEGIN
+END TranspileArrayType;
+
+PROCEDURE TranspileEnumerationType(AContext: PTranspilerContext; ALexer: PLexer);
+VAR
+  Token: LexerToken;
+  WrittenBytes: CARDINAL;
+BEGIN
+  WriteString('(');
+  WriteLn();
+  WriteString('    ');
+
+  Token := TranspilerLex(ALexer);
+  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+
+  Token := TranspilerLex(ALexer);
+
+  WHILE Token.Kind = lexerKindComma DO
+    Write(',');
+	WriteLn();
+	WriteString('    ');
+    Token := TranspilerLex(ALexer);
+    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+
+	Token := TranspilerLex(ALexer)
+  END;
+  WriteLn();
+  WriteString('  )')
+END TranspileEnumerationType;
+
+PROCEDURE TranspileUnionType(AContext: PTranspilerContext; ALexer: PLexer);
+VAR
+  Token: LexerToken;
+END TranspileUnionType;
+
+PROCEDURE TranspileProcedureType(AContext: PTranspilerContext; ALexer: PLexer);
+VAR
+  Token: LexerToken;
+  WrittenBytes: CARDINAL;
+BEGIN
+  Token := TranspilerLex(ALexer);
+  WriteString('PROCEDURE(');
+
+  Token := TranspilerLex(ALexer);
+
+  WHILE Token.Kind <> lexerKindRightParen DO
+    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+
+    Token := TranspilerLex(ALexer);
+    IF Token.Kind = lexerKindComma THEN
+      Token := TranspilerLex(ALexer);
+      WriteString(', ')
+    END
+  END;
+  Write(')')
+END TranspileProcedureType;
+
+PROCEDURE TranspileTypeExpression(AContext: PTranspilerContext; ALexer: PLexer);
+VAR
+  Token: LexerToken;
+  WrittenBytes: CARDINAL;
+BEGIN
+  Token := TranspilerLex(ALexer);
+  IF Token.Kind = lexerKindRecord THEN
+    TranspileRecordType(AContext, ALexer)
+  ELSIF Token.Kind = lexerKindLeftParen THEN
+    TranspileEnumerationType(AContext, ALexer)
+  ELSIF Token.Kind = lexerKindArray THEN
+    TranspileArrayType(AContext, ALexer)
+  ELSIF Token.Kind = lexerKindPointer THEN
+    TranspilePointerType(AContext, ALexer)
+  ELSIF Token.Kind = lexerKindProc THEN
+    TranspileProcedureType(AContext, ALexer)
+  ELSE
+    WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start)
+  END
+END TranspileTypeExpression;
+
+PROCEDURE TranspileTypeDeclaration(AContext: PTranspilerContext; ALexer: PLexer);
+VAR
+  Token: LexerToken;
+  WrittenBytes: CARDINAL;
+BEGIN
+  WriteString('  ');
+  Token := LexerCurrent(ALexer);
+  WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
+
+  Token := TranspilerLex(ALexer);
+  WriteString(' = ');
+  TranspileTypeExpression(AContext, ALexer);
+  Token := TranspilerLex(ALexer);
+  WriteSemicolon();
+END TranspileTypeDeclaration;
+
+PROCEDURE TranspileTypePart(AContext: PTranspilerContext; ALexer: PLexer);
+VAR
+  Token: LexerToken;
+BEGIN
+  Token := LexerCurrent(ALexer);
+
+  IF Token.Kind = lexerKindType THEN
+    WriteString('TYPE');
+    WriteLn();
+    Token := TranspilerLex(ALexer);
+
+    WHILE Token.Kind = lexerKindIdentifier DO
+	  TranspileTypeDeclaration(AContext, ALexer);
+      Token := TranspilerLex(ALexer)
+    END
+  END
+END TranspileTypePart;
+
 PROCEDURE Transpile(ALexer: PLexer);
 VAR
   Token: LexerToken;