Start a Modula-2 experiment

.gitignore

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

Rakefile

@@ -4,12 +4,13 @@ require 'open3'
 
 DFLAGS = ['--warn-no-deprecated', '-L/usr/lib64/gcc-12']
 BINARY = 'build/bin/elna'
-TESTS = FileList['tests/*.elna'].flat_map do |test|
+TESTS = FileList['tests/*.eln'].flat_map do |test|
   build = Pathname.new 'build'
-  asm_test = build + 'asm' + Pathname.new(test).basename('')
+  test_basename = Pathname.new(test).basename('')
 
-  [build + test, asm_test].map { |path| path.sub_ext('').to_path }
+  [build + 'riscv' + test_basename].map { |path| path.sub_ext('').to_path }
 end
+
 SOURCES = FileList['source/**/*.d']
 
 directory 'build'
@@ -17,22 +18,25 @@ directory 'build'
 CLEAN.include 'build'
 CLEAN.include '.dub'
 
-rule(/build\/tests\/[^\/\.]+$/ => ->(file) { test_for_out(file) }) do |t|
-  sh 'gcc', '-o', t.name, "#{t.name}.o"
+rule(/build\/riscv\/[^\/\.]+$/ => ->(file) { test_for_out(file, '.o') }) do |t|
+  sh '/opt/riscv/bin/riscv32-unknown-elf-ld',
+    '-o', t.name,
+    '-L/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/',
+    '-L/opt/riscv/riscv32-unknown-elf/lib',
+    '/opt/riscv/riscv32-unknown-elf/lib/crt0.o',
+    '/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/crtbegin.o',
+    t.source,
+    '--start-group', '-lgcc', '-lc', '-lgloss', '--end-group',
+    '/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/crtend.o'
 end
 
-rule(/build\/asm\/[^\/\.]+$/ => ->(file) { test_for_object(file) }) do |t|
+rule(/build\/riscv\/.+\.o$/ => ->(file) { test_for_object(file, '.eln') }) do |t|
   Pathname.new(t.name).dirname.mkpath
-  Open3.pipeline [BINARY, t.source], ['gcc', '-x', 'assembler', '-o', t.name,  '-']
-end
-
-rule(/build\/tests\/.+\.o$/ => ->(file) { test_for_object(file) }) do |t|
-  Pathname.new(t.name).dirname.mkpath
-  sh BINARY, t.source
+  sh BINARY, '-o', t.name, t.source
 end
 
 file BINARY => SOURCES do |t|
-  sh({ 'DFLAGS' => (DFLAGS * ' ') }, 'dub', 'build', '--compiler=gdc-12')
+  sh({ 'DFLAGS' => (DFLAGS * ' ') }, 'dub', 'build', '--compiler=gdc')
 end
 
 task default: BINARY
@@ -45,14 +49,27 @@ task test: BINARY do
       .new(test)
       .sub_ext('.txt')
       .sub(/^build\/[[:alpha:]]+\//, 'tests/expectations/')
-      .read
-      .to_i
+      .to_path
 
     puts "Running #{test}"
-    system test
-    actual = $?.exitstatus
+    if test.include? '/riscv/'
+      spike = [
+        '/opt/riscv/bin/spike',
+        '--isa=RV32IMAC',
+        '/opt/riscv/riscv32-unknown-elf/bin/pk',
+        test
+      ]
+      diff = ['diff', '-Nur', '--color', expected, '-']
+      tail = ['tail', '-n', '1']
 
-    fail "#{test}: Expected #{expected}, got #{actual}" unless expected == actual
+      last_stdout, wait_threads = Open3.pipeline_r spike, tail, diff
+    else
+      raise 'Unsupported test platform'
+    end
+    print last_stdout.read
+    last_stdout.close
+
+    fail unless wait_threads.last.value.exitstatus.zero?
   end
 end
 
@@ -61,18 +78,18 @@ task unittest: SOURCES do |t|
   sh('dub', 'test', '--compiler=gdc-12')
 end
 
-def test_for_object(out_file)
+def test_for_object(out_file, extension)
   test_source = Pathname
     .new(out_file)
-    .sub_ext('.elna')
+    .sub_ext(extension)
     .sub(/^build\/[[:alpha:]]+\//, 'tests/')
     .to_path
   [test_source, BINARY]
 end
 
-def test_for_out(out_file)
+def test_for_out(out_file, extension)
   Pathname
     .new(out_file)
-    .sub_ext('.o')
+    .sub_ext(extension)
     .to_path
 end

compiler.mod

@@ -0,0 +1,522 @@
+MODULE Compiler;
+
+FROM Terminal IMPORT WriteString, WriteLn;
+
+TYPE
+  (*
+  Classification table assigns each possible character to a group (class). All
+  characters of the same group a handled equivalently.
+
+  Classification:
+  *)
+  TransitionClass = (
+    transitionClassInvalid,
+    transitionClassDigit,
+    transitionClassCharacter,
+    transitionClassSpace,
+    transitionClassColon,
+    transitionClassEquals,
+    transitionClassLeftParen,
+    transitionClassRightParen,
+    transitionClassAsterisk,
+    transitionClassUnderscore,
+    transitionClassSingle,
+    transitionClassHex,
+    transitionClassZero,
+    transitionClassX,
+    transitionClassEof,
+    transitionClassDot,
+    transitionClassMinus,
+    transitionClassQuote,
+    transitionClassGreater,
+    transitionClassLess,
+    transitionClassOther
+  );
+  TransitionState = (
+    transitionStateStart,
+    transitionStateColon,
+    transitionStateIdentifier,
+    transitionStateDecimal,
+    transitionStateGreater,
+    transitionStateMinus,
+    transitionStateLeftParen,
+    transitionStateLess,
+    transitionStateHexadecimal,
+    transitionStateComment,
+    transitionStateClosingComment,
+    transitionStateString,
+    transitionStateLeadingZero,
+    transitionStateHexadecimalPrefix,
+    transitionStateEnd
+  );
+  TransitionAction = PROCEDURE();
+  Transition = RECORD
+    Action: TransitionAction;
+    NextState: TransitionState
+  END;
+
+VAR
+  Classification: ARRAY[1..128] OF TransitionClass;
+  Transitions: ARRAY[0..MAX(TransitionState)] OF ARRAY[0..MAX(TransitionClass)] OF Transition;
+
+PROCEDURE InitializeClassification();
+BEGIN
+  Classification[1] := transitionClassEof; (* NUL *)
+  Classification[2] := transitionClassInvalid; (* SOH *)
+  Classification[3] := transitionClassInvalid; (* STX *)
+  Classification[4] := transitionClassInvalid; (* ETX *)
+  Classification[5] := transitionClassInvalid; (* EOT *)
+  Classification[6] := transitionClassInvalid; (* EMQ *)
+  Classification[7] := transitionClassInvalid; (* ACK *)
+  Classification[8] := transitionClassInvalid; (* BEL *)
+  Classification[9] := transitionClassInvalid; (* BS *)
+  Classification[10] := transitionClassSpace; (* HT *)
+  Classification[11] := transitionClassSpace; (* LF *)
+  Classification[12] := transitionClassInvalid; (* VT *)
+  Classification[13] := transitionClassInvalid; (* FF *)
+  Classification[14] := transitionClassSpace; (* CR *)
+  Classification[15] := transitionClassInvalid; (* SO *)
+  Classification[16] := transitionClassInvalid; (* SI *)
+  Classification[17] := transitionClassInvalid; (* DLE *)
+  Classification[18] := transitionClassInvalid; (* DC1 *)
+  Classification[19] := transitionClassInvalid; (* DC2 *)
+  Classification[20] := transitionClassInvalid; (* DC3 *)
+  Classification[21] := transitionClassInvalid; (* DC4 *)
+  Classification[22] := transitionClassInvalid; (* NAK *)
+  Classification[23] := transitionClassInvalid; (* SYN *)
+  Classification[24] := transitionClassInvalid; (* ETB *)
+  Classification[25] := transitionClassInvalid; (* CAN *)
+  Classification[26] := transitionClassInvalid; (* EM *)
+  Classification[27] := transitionClassInvalid; (* SUB *)
+  Classification[28] := transitionClassInvalid; (* ESC *)
+  Classification[29] := transitionClassInvalid; (* FS *)
+  Classification[30] := transitionClassInvalid; (* GS *)
+  Classification[31] := transitionClassInvalid; (* RS *)
+  Classification[32] := transitionClassInvalid; (* US *)
+  Classification[33] := transitionClassSpace; (* Space *)
+  Classification[34] := transitionClassSingle; (* ! *)
+  Classification[35] := transitionClassQuote; (* " *)
+  Classification[36] := transitionClassOther; (* # *)
+  Classification[37] := transitionClassOther; (* $ *)
+  Classification[38] := transitionClassSingle; (* % *)
+  Classification[39] := transitionClassSingle; (* & *)
+  Classification[40] := transitionClassQuote; (* ' *)
+  Classification[41] := transitionClassLeftParen; (* ( *)
+  Classification[42] := transitionClassRightParen; (* ) *)
+  Classification[43] := transitionClassAsterisk; (* * *)
+  Classification[44] := transitionClassSingle; (* + *)
+  Classification[45] := transitionClassSingle; (* , *)
+  Classification[46] := transitionClassMinus; (* - *)
+  Classification[47] := transitionClassDot; (* . *)
+  Classification[48] := transitionClassSingle; (* / *)
+  Classification[49] := transitionClassZero; (* 0 *)
+  Classification[50] := transitionClassDigit; (* 1 *)
+  Classification[51] := transitionClassDigit; (* 2 *)
+  Classification[52] := transitionClassDigit; (* 3 *)
+  Classification[53] := transitionClassDigit; (* 4 *)
+  Classification[54] := transitionClassDigit; (* 5 *)
+  Classification[55] := transitionClassDigit; (* 6 *)
+  Classification[56] := transitionClassDigit; (* 7 *)
+  Classification[57] := transitionClassDigit; (* 8 *)
+  Classification[58] := transitionClassDigit; (* 9 *)
+  Classification[59] := transitionClassColon; (* : *)
+  Classification[60] := transitionClassSingle; (* ; *)
+  Classification[61] := transitionClassLess; (* < *)
+  Classification[62] := transitionClassEquals; (* = *)
+  Classification[63] := transitionClassGreater; (* > *)
+  Classification[64] := transitionClassOther; (* ? *)
+  Classification[65] := transitionClassSingle; (* @ *)
+  Classification[66] := transitionClassCharacter; (* A *)
+  Classification[67] := transitionClassCharacter; (* B *)
+  Classification[68] := transitionClassCharacter; (* C *)
+  Classification[69] := transitionClassCharacter; (* D *)
+  Classification[70] := transitionClassCharacter; (* E *)
+  Classification[71] := transitionClassCharacter; (* F *)
+  Classification[72] := transitionClassCharacter; (* G *)
+  Classification[73] := transitionClassCharacter; (* H *)
+  Classification[74] := transitionClassCharacter; (* I *)
+  Classification[75] := transitionClassCharacter; (* J *)
+  Classification[76] := transitionClassCharacter; (* K *)
+  Classification[77] := transitionClassCharacter; (* L *)
+  Classification[78] := transitionClassCharacter; (* M *)
+  Classification[79] := transitionClassCharacter; (* N *)
+  Classification[80] := transitionClassCharacter; (* O *)
+  Classification[81] := transitionClassCharacter; (* P *)
+  Classification[82] := transitionClassCharacter; (* Q *)
+  Classification[83] := transitionClassCharacter; (* R *)
+  Classification[84] := transitionClassCharacter; (* S *)
+  Classification[85] := transitionClassCharacter; (* T *)
+  Classification[86] := transitionClassCharacter; (* U *)
+  Classification[67] := transitionClassCharacter; (* V *)
+  Classification[88] := transitionClassCharacter; (* W *)
+  Classification[89] := transitionClassCharacter; (* X *)
+  Classification[90] := transitionClassCharacter; (* Y *)
+  Classification[91] := transitionClassCharacter; (* Z *)
+  Classification[92] := transitionClassSingle; (* [ *)
+  Classification[93] := transitionClassOther; (* \ *)
+  Classification[94] := transitionClassSingle; (* ] *)
+  Classification[95] := transitionClassSingle; (* ^ *)
+  Classification[96] := transitionClassUnderscore; (* _ *)
+  Classification[97] := transitionClassOther; (* ` *)
+  Classification[98] := transitionClassHex; (* a *)
+  Classification[99] := transitionClassHex; (* b *)
+  Classification[100] := transitionClassHex; (* c *)
+  Classification[101] := transitionClassHex; (* d *)
+  Classification[102] := transitionClassHex; (* e *)
+  Classification[103] := transitionClassHex; (* f *)
+  Classification[104] := transitionClassCharacter; (* g *)
+  Classification[105] := transitionClassCharacter; (* h *)
+  Classification[106] := transitionClassCharacter; (* i *)
+  Classification[107] := transitionClassCharacter; (* j *)
+  Classification[108] := transitionClassCharacter; (* k *)
+  Classification[109] := transitionClassCharacter; (* l *)
+  Classification[110] := transitionClassCharacter; (* m *)
+  Classification[111] := transitionClassCharacter; (* n *)
+  Classification[112] := transitionClassCharacter; (* o *)
+  Classification[113] := transitionClassCharacter; (* p *)
+  Classification[114] := transitionClassCharacter; (* q *)
+  Classification[115] := transitionClassCharacter; (* r *)
+  Classification[116] := transitionClassCharacter; (* s *)
+  Classification[117] := transitionClassCharacter; (* t *)
+  Classification[118] := transitionClassCharacter; (* u *)
+  Classification[119] := transitionClassCharacter; (* v *)
+  Classification[120] := transitionClassCharacter; (* w *)
+  Classification[121] := transitionClassX; (* x *)
+  Classification[122] := transitionClassCharacter; (* y *)
+  Classification[123] := transitionClassCharacter; (* z *)
+  Classification[124] := transitionClassOther; (* { *)
+  Classification[125] := transitionClassSingle; (* | *)
+  Classification[126] := transitionClassOther; (* } *)
+  Classification[127] := transitionClassSingle; (* ~ *)
+  Classification[128] := transitionClassInvalid (* DEL *)
+END InitializeClassification;
+
+(* 0x00. No action. *)
+PROCEDURE TransitionActionNo();
+BEGIN
+END TransitionActionNo;
+
+(* 0x01. Accumulate action. *)
+PROCEDURE TransitionActionAccumulate();
+BEGIN
+END TransitionActionAccumulate;
+
+(* 0x02. Print action. *)
+PROCEDURE TransitionActionPrint();
+BEGIN
+END TransitionActionPrint;
+
+(* 0x03. Skip action. *)
+PROCEDURE TransitionActionSkip();
+BEGIN
+END TransitionActionSkip;
+
+(* 0x04. Delimited string action. *)
+PROCEDURE TransitionActionDelimited();
+BEGIN
+END TransitionActionDelimited;
+
+(* 0x05. Finalize identifier action. *)
+PROCEDURE TransitionActionFinalize();
+BEGIN
+END TransitionActionFinalize;
+
+(* 0x06. Single character symbol action. *)
+PROCEDURE TransitionActionSingle();
+BEGIN
+END TransitionActionSingle;
+
+(* 0x07. An action for symbols containing multiple characters. *)
+PROCEDURE TransitionActionComposite();
+BEGIN
+END TransitionActionComposite;
+
+(* 0x08. Integer action. *)
+PROCEDURE TransitionActionInteger();
+BEGIN
+END TransitionActionInteger;
+
+PROCEDURE SetDefaultTransition(currentState: TransitionState; DefaultAction: TransitionAction; NextState: TransitionState);
+VAR DefaultTransition: Transition;
+BEGIN
+  DefaultTransition.Action := DefaultAction;
+  DefaultTransition.NextState := NextState;
+
+  Transitions[ORD(currentState)][ORD(transitionClassInvalid)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassDigit)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassCharacter)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassSpace)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassColon)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassEquals)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassLeftParen)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassRightParen)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassAsterisk)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassUnderscore)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassSingle)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassHex)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassZero)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassX)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassEof)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassDot)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassMinus)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassQuote)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassGreater)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassLess)] := DefaultTransition;
+  Transitions[ORD(currentState)][ORD(transitionClassOther)] := DefaultTransition;
+END SetDefaultTransition;
+
+(*
+ * The transition table describes transitions from one state to another, given
+ * a symbol (character class).
+ *
+ * The table has m rows and n columns, where m is the amount of states and n is
+ * the amount of classes. So given the current state and a classified character
+ * the table can be used to look up the next state.
+ *
+ * Each cell is a word long.
+ * - The least significant byte of the word is a row number (beginning with 0).
+ *   It specifies the target state. "ff" means that this is an end state and no
+ *   transition is possible.
+ * - The next byte is the action that should be performed when transitioning.
+ *   For the meaning of actions see labels in the lex_next function, which
+ *   handles each action.
+ *)
+PROCEDURE InitializeTransitions();
+BEGIN
+  (* Start state. *)
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassDigit)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassDigit)].NextState := transitionStateDecimal;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassCharacter)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassCharacter)].NextState := transitionStateIdentifier;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassSpace)].Action := TransitionActionSkip;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassSpace)].NextState := transitionStateStart;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassColon)].NextState := transitionStateColon;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassEquals)].Action := TransitionActionSingle;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassLeftParen)].NextState := transitionStateLeftParen;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassRightParen)].Action := TransitionActionSingle;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassRightParen)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].Action := TransitionActionSingle;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassAsterisk)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassUnderscore)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassUnderscore)].NextState := transitionStateIdentifier;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].Action := TransitionActionSingle;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassSingle)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassHex)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassHex)].NextState := transitionStateIdentifier;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassZero)].NextState := transitionStateLeadingZero;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassX)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassX)].NextState := transitionStateIdentifier;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassEof)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassDot)].Action := TransitionActionSingle;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassDot)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassMinus)].NextState := transitionStateMinus;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassQuote)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassQuote)].NextState := transitionStateString;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassGreater)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassGreater)].NextState := transitionStateGreater;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassLess)].NextState := transitionStateLess;
+
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateStart)][ORD(transitionClassOther)].NextState := transitionStateEnd;
+
+  (* Colon state. *)
+  SetDefaultTransition(transitionStateColon, TransitionActionPrint, transitionStateEnd);
+
+  Transitions[ORD(transitionStateColon)][ORD(transitionClassEquals)].Action := TransitionActionComposite;
+  Transitions[ORD(transitionStateColon)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
+
+  (* Identifier state. *)
+  SetDefaultTransition(transitionStateIdentifier, TransitionActionFinalize, transitionStateEnd);
+
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassDigit)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassDigit)].NextState := transitionStateIdentifier;
+
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassCharacter)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassCharacter)].NextState := transitionStateIdentifier;
+
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassUnderscore)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassUnderscore)].NextState := transitionStateIdentifier;
+
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassHex)].NextState := transitionStateIdentifier;
+
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassZero)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassZero)].NextState := transitionStateIdentifier;
+
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateIdentifier)][ORD(transitionClassX)].NextState := transitionStateIdentifier;
+
+  (* Decimal state. *)
+  SetDefaultTransition(transitionStateDecimal, TransitionActionInteger, transitionStateEnd);
+
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassDigit)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassDigit)].NextState := transitionStateDecimal;
+
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassCharacter)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassCharacter)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassUnderscore)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassHex)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassHex)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassZero)].NextState := transitionStateDecimal;
+
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassX)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateDecimal)][ORD(transitionClassX)].NextState := transitionStateEnd;
+
+  (* Greater state. *)
+  SetDefaultTransition(transitionStateGreater, TransitionActionPrint, transitionStateEnd);
+
+  Transitions[ORD(transitionStateGreater)][ORD(transitionClassEquals)].Action := TransitionActionDelimited;
+  Transitions[ORD(transitionStateGreater)][ORD(transitionClassEquals)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateGreater)][ORD(transitionClassGreater)].Action := TransitionActionDelimited;
+  Transitions[ORD(transitionStateGreater)][ORD(transitionClassGreater)].NextState := transitionStateEnd;
+
+  (* Minus state. *)
+  SetDefaultTransition(transitionStateGreater, TransitionActionSingle, transitionStateEnd);
+
+  Transitions[ORD(transitionStateMinus)][ORD(transitionClassGreater)].Action := TransitionActionDelimited;
+  Transitions[ORD(transitionStateMinus)][ORD(transitionClassGreater)].NextState := transitionStateEnd;
+
+  (* Left paren state. *)
+  SetDefaultTransition(transitionStateLeftParen, TransitionActionSingle, transitionStateEnd);
+
+  Transitions[ORD(transitionStateLeftParen)][ORD(transitionClassAsterisk)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateLeftParen)][ORD(transitionClassAsterisk)].NextState := transitionStateComment;
+
+  (* Less state. *)
+  SetDefaultTransition(transitionStateLess, TransitionActionSingle, transitionStateEnd);
+
+  Transitions[ORD(transitionStateLess)][ORD(transitionClassLess)].Action := TransitionActionDelimited;
+  Transitions[ORD(transitionStateLess)][ORD(transitionClassLess)].NextState := transitionStateEnd;
+
+  (* Hexadecimal after 0x. *)
+  SetDefaultTransition(transitionStateHexadecimal, TransitionActionInteger, transitionStateEnd);
+
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassDigit)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassDigit)].NextState := transitionStateHexadecimal;
+
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassCharacter)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassCharacter)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassUnderscore)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassUnderscore)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassHex)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassHex)].NextState := transitionStateHexadecimal;
+
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassZero)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassZero)].NextState := transitionStateHexadecimal;
+
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassX)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateHexadecimal)][ORD(transitionClassX)].NextState := transitionStateEnd;
+
+  (* Comment. *)
+  SetDefaultTransition(transitionStateComment, TransitionActionAccumulate, transitionStateComment);
+
+  Transitions[ORD(transitionStateComment)][ORD(transitionClassAsterisk)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment;
+
+  Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateComment)][ORD(transitionClassEof)].NextState := transitionStateEnd;
+
+  (* Closing comment. *)
+  SetDefaultTransition(transitionStateClosingComment, TransitionActionAccumulate, transitionStateComment);
+
+  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassInvalid)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassRightParen)].Action := TransitionActionDelimited;
+  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassRightParen)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassAsterisk)].NextState := transitionStateClosingComment;
+
+  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateClosingComment)][ORD(transitionClassEof)].NextState := transitionStateEnd;
+
+  (* String. *)
+  SetDefaultTransition(transitionStateString, TransitionActionAccumulate, transitionStateString);
+
+  Transitions[ORD(transitionStateString)][ORD(transitionClassInvalid)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateString)][ORD(transitionClassInvalid)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateString)][ORD(transitionClassEof)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateString)][ORD(transitionClassQuote)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateString)][ORD(transitionClassQuote)].NextState := transitionStateEnd;
+
+  (* Leading zero. *)
+  SetDefaultTransition(transitionStateLeadingZero, TransitionActionInteger, transitionStateEnd);
+
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassDigit)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassDigit)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassCharacter)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassCharacter)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassUnderscore)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassUnderscore)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassHex)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassHex)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassZero)].Action := TransitionActionNo;
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassZero)].NextState := transitionStateEnd;
+
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassX)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateLeadingZero)][ORD(transitionClassX)].NextState := transitionStateHexadecimalPrefix;
+
+  (* Leading zero. *)
+  SetDefaultTransition(transitionStateHexadecimalPrefix, TransitionActionNo, transitionStateEnd);
+
+  Transitions[ORD(transitionStateHexadecimalPrefix)][ORD(transitionClassDigit)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateHexadecimalPrefix)][ORD(transitionClassDigit)].NextState := transitionStateHexadecimal;
+
+  Transitions[ORD(transitionStateHexadecimalPrefix)][ORD(transitionClassHex)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateHexadecimalPrefix)][ORD(transitionClassHex)].NextState := transitionStateHexadecimal;
+
+  Transitions[ORD(transitionStateHexadecimalPrefix)][ORD(transitionClassZero)].Action := TransitionActionAccumulate;
+  Transitions[ORD(transitionStateHexadecimalPrefix)][ORD(transitionClassZero)].NextState := transitionStateHexadecimal
+END InitializeTransitions;
+
+BEGIN
+  InitializeClassification();
+  InitializeTransitions();
+
+  WriteString('Elna');
+  WriteLn()
+END Compiler.

dub.json

@@ -1,9 +0,0 @@
-{
-	"dependencies": {
-		"tanya": "~>0.18.0"
-	},
-	"name": "elna",
-	"targetType": "executable",
-	"targetPath": "build/bin",
-	"mainSourceFile": "source/main.d"
-}

source/elna/arguments.d

@@ -1,146 +0,0 @@
-/**
- * Argument parsing.
- */
-module elna.arguments;
-
-import std.algorithm;
-import std.range;
-import std.sumtype;
-
-struct ArgumentError
-{
-    enum Type
-    {
-        expectedOutputFile,
-        noInput,
-    }
-
-    private Type type_;
-    private string argument_;
-
-    @property Type type() const @nogc nothrow pure @safe
-    {
-        return this.type_;
-    }
-
-    @property string argument() const @nogc nothrow pure @safe
-    {
-        return this.argument_;
-    }
-
-    void toString(OR)(OR range)
-    if (isOutputRage!OR)
-    {
-        final switch (Type)
-        {
-            case Type.expectedOutputFile:
-                put(range, "Expected an output filename after -o");
-                break;
-            case Type.noInput:
-                put(range, "No input files specified");
-                break;
-        }
-    }
-}
-
-/**
- * Supported compiler arguments.
- */
-struct Arguments
-{
-    private bool assembler_;
-    private string output_;
-    private string[] inFiles_;
-
-    @property string[] inFiles() @nogc nothrow pure @safe
-    {
-        return this.inFiles_;
-    }
-
-    /**
-     * Returns: Whether to generate assembly instead of an object file.
-     */
-    @property bool assembler() const @nogc nothrow pure @safe
-    {
-        return this.assembler_;
-    }
-
-    /**
-     * Returns: Output file.
-     */
-    @property string output() const @nogc nothrow pure @safe
-    {
-        return this.output_;
-    }
-
-    /**
-     * Parse command line arguments.
-     *
-     * The first argument is expected to be the program name (and it is
-     * ignored).
-     *
-     * Params:
-     *   arguments = Command line arguments.
-     *
-     * Returns: Parsed arguments or an error.
-     */
-    static SumType!(ArgumentError, Arguments) parse(string[] arguments)
-    @nogc nothrow pure @safe
-    {
-        if (!arguments.empty)
-        {
-            arguments.popFront;
-        }
-        alias ReturnType = typeof(return);
-
-        return parseArguments(arguments).match!(
-            (Arguments parsed) {
-                if (parsed.inFiles.empty)
-                {
-                    return ReturnType(ArgumentError(ArgumentError.Type.noInput));
-                }
-                return ReturnType(parsed);
-            },
-            (ArgumentError argumentError) => ReturnType(argumentError)
-        );
-    }
-
-    private static SumType!(ArgumentError, Arguments) parseArguments(ref string[] arguments)
-    @nogc nothrow pure @safe
-    {
-        Arguments parsed;
-
-        while (!arguments.empty)
-        {
-            if (arguments.front == "-s")
-            {
-                parsed.assembler_ = true;
-            }
-            else if (arguments.front == "-o")
-            {
-                if (arguments.empty)
-                {
-                    return typeof(return)(ArgumentError(
-                        ArgumentError.Type.expectedOutputFile,
-                        arguments.front
-                    ));
-                }
-                arguments.popFront;
-                parsed.output_ = arguments.front;
-            }
-            else if (arguments.front == "--")
-            {
-                arguments.popFront;
-                parsed.inFiles_ = arguments;
-                break;
-            }
-            else if (!arguments.front.startsWith("-"))
-            {
-                parsed.inFiles_ = arguments;
-                break;
-            }
-            arguments.popFront;
-        }
-        return typeof(return)(parsed);
-    }
-}

source/elna/extended.d

@@ -1,9 +0,0 @@
-/**
- * File I/O that can be moved into more generic library when and if finished.
- */
-module elna.extended;
-
-struct File
-{
-    @disable this(this);
-}

source/elna/generator.d

@@ -1,660 +0,0 @@
-module elna.generator;
-
-import core.stdc.stdio;
-import core.stdc.stdlib;
-import core.stdc.string;
-import elna.ir;
-import tanya.container.array;
-import tanya.container.string;
-import tanya.memory.mmappool;
-import tanya.format;
-
-/// Unsigned program address.
-alias Elf64_Addr = void*;
-/// Unsigned file offset.
-alias Elf64_Off = ulong;
-/// Unsigned medium integer.
-alias Elf64_Half = ushort;
-/// Unsigned integer.
-alias Elf64_Word = uint;
-/// Signed integer.
-alias Elf64_Sword = int;
-/// Unsigned long integer.
-alias Elf64_Xword = ulong;
-/// Signed long integer.
-alias Elf64_Sxword = long;
-
-enum size_t EI_INDENT = 16;
-
-/**
- * File header.
- */
-struct Elf64_Ehdr
-{
-    /// ELF identification.
-    ubyte[EI_INDENT] e_ident;
-    /// Object file type.
-    Elf64_Half e_type;
-    /// Machine type.
-    Elf64_Half e_machine;
-    /// Object file version
-    Elf64_Word e_version;
-    /// Entry point address.
-    Elf64_Addr e_entry;
-    /// Program header offset.
-    Elf64_Off e_phoff;
-    /// Section header offset.
-    Elf64_Off e_shoff;
-    /// Processor-specific flags.
-    Elf64_Word e_flags;
-    /// ELF header size.
-    Elf64_Half e_ehsize;
-    /// Size of program header entry.
-    Elf64_Half e_phentsize;
-    /// Number of program header entries.
-    Elf64_Half e_phnum;
-    /// Size of section header entry.
-    Elf64_Half e_shentsize;
-    /// Number of section header entries.
-    Elf64_Half e_shnum;
-    /// Section name string table index.
-    Elf64_Half e_shstrndx;
-}
-
-/**
- * Section header.
- */
-struct Elf64_Shdr
-{
-    /// Section name.
-    Elf64_Word sh_name;
-    /// Section type.
-    Elf64_Word sh_type;
-    /// Section attributes.
-    Elf64_Xword sh_flags;
-    /// Virtual address in memory.
-    Elf64_Addr sh_addr;
-    /// Offset in file.
-    Elf64_Off sh_offset;
-    /// Size of section.
-    Elf64_Xword sh_size;
-    /// Link to other section.
-    Elf64_Word sh_link;
-    /// Miscellaneous information.
-    Elf64_Word sh_info;
-    /// Address alignment boundary.
-    Elf64_Xword sh_addralign;
-    /// Size of entries, if section has table.
-    Elf64_Xword sh_entsize;
-}
-
-struct Elf64_Sym
-{
-    /// Symbol name.
-    Elf64_Word st_name;
-    /// Type and Binding attributes.
-    ubyte st_info;
-    /// Reserved.
-    ubyte st_other;
-    /// Section table index.
-    Elf64_Half st_shndx;
-    /// Symbol value.
-    Elf64_Addr st_value;
-    /// Size of object (e.g., common).
-    Elf64_Xword st_size;
-}
-
-/// Section Types, sh_type.
-enum : Elf64_Word
-{
-    /// Marks an unused section header.
-    SHT_NULL = 0,
-    ///  Contains information defined by the program.
-    SHT_PROGBITS = 1,
-    /// Contains a linker symbol table.
-    SHT_SYMTAB = 2,
-    /// Contains a string table.
-    SHT_STRTAB = 3,
-    /// Contains “Rela” type relocation entries.
-    SHT_RELA = 4,
-    /// Contains a symbol hash table
-    SHT_HASH = 5,
-    /// Contains dynamic linking tables
-    SHT_DYNAMIC = 6,
-    /// Contains note information
-    SHT_NOTE = 7,
-    /// Contains uninitialized space; does not occupy any space in the file.
-    SHT_NOBITS = 8,
-    /// Contains "Rel" type relocation entries.
-    SHT_REL = 9,
-    /// Reserved.
-    SHT_SHLIB = 10,
-    /// Contains a dynamic loader symbol table.
-    SHT_DYNSYM = 11,
-    /// Environment-specific use.
-    SHT_LOOS = 0x60000000,
-    SHT_HIOS = 0x6FFFFFFF,
-    /// Processor-specific use.
-    SHT_LOPROC = 0x70000000,
-    SHT_HIPROC = 0x7FFFFFFF,
-}
-
-/**
- * Section Attributes, sh_flags.
- */
-enum : Elf64_Xword
-{
-    /// Section contains writable data.
-    SHF_WRITE = 0x1,
-    /// Section is allocated in memory image of program.
-    SHF_ALLOC = 0x2,
-    /// Section contains executable instructions.
-    SHF_EXECINSTR = 0x4,
-    /// Environment-specific use.
-    SHF_MASKOS = 0x0F000000,
-    /// Processor-specific use.
-    SHF_MASKPROC = 0xF0000000,
-}
-
-enum : Elf64_Word
-{
-    /// Not visible outside the object file.
-    STB_LOCAL = 0,
-    /// Global symbol, visible to all object files.
-    STB_GLOBAL = 1,
-    /// Global scope, but with lower precedence than global symbols.
-    STB_WEAK = 2,
-    /// Environment-specific use.
-    STB_LOOS = 10,
-    STB_HIOS = 12,
-    /// Processor-specific use.
-    STB_LOPROC = 13,
-    STB_HIPROC = 15,
-}
-
-enum : Elf64_Word
-{
-    /// No type specified (e.g., an absolute symbol).
-    STT_NOTYPE = 0,
-    /// Data object.
-    STT_OBJECT = 1,
-    /// Function entry point.
-    STT_FUNC = 2,
-    /// Symbol is associated with a section.
-    STT_SECTION = 3,
-    /// Source file associated with the object file.
-    STT_FILE = 4,
-    /// Environment-specific use.
-    STT_LOOS = 10,
-    STT_HIOS = 12,
-    /// Processor-specific use.
-    STT_LOPROC = 13,
-    STT_HIPROC = 15,
-}
-
-Elf64_Ehdr makeFileHeader(Elf64_Off sectionHeaderOffset,
-        Elf64_Half sectionHeaderCount,
-        Elf64_Half stringIndex) @nogc
-{
-    Elf64_Ehdr header;
-
-    // Magic number.
-    header.e_ident[0] = '\x7f';
-    header.e_ident[1] = 'E';
-    header.e_ident[2] = 'L';
-    header.e_ident[3] = 'F';
-
-    // File class.
-    header.e_ident[4] = EI_CLASS.ELFCLASS64;
-
-    // Data encoding.
-    header.e_ident[5] = EI_DATA.ELFDATA2LSB;
-
-    // Version.
-    header.e_ident[6] = EV_CURRENT;
-
-    // OS/ABI identification.
-    header.e_ident[7] = EI_OSABI.ELFOSABI_SYSV;
-
-    // ABI version.
-    header.e_ident[8] = 0;
-
-    // Size of e_ident[].
-    header.e_ident[15] = 0;
-
-    header.e_type = ET_REL;
-    header.e_machine = 0x3e; // EM_X86_64: AMD x86-64 architecture
-    header.e_version = EV_CURRENT;
-    header.e_entry = null;
-    header.e_phoff = 0;
-    header.e_shoff = sectionHeaderOffset;
-    header.e_flags = 0;
-    header.e_ehsize = Elf64_Ehdr.sizeof;
-    header.e_phentsize = 0;
-    header.e_phnum = 0;
-    header.e_shentsize = Elf64_Shdr.sizeof;
-    header.e_shnum = sectionHeaderCount;
-    header.e_shstrndx = stringIndex;
-
-    return header;
-}
-
-enum char[33] sectionStringTable = "\0.symtab\0.strtab\0.shstrtab\0.text\0";
-
-Elf64_Shdr makeTextHeader(Elf64_Off offset, Elf64_Xword size) @nogc
-{
-    Elf64_Shdr table;
-
-    table.sh_name = 0x1b;
-    table.sh_type = SHT_PROGBITS;
-    table.sh_flags = SHF_EXECINSTR | SHF_ALLOC;
-    table.sh_addr = null;
-    table.sh_offset = offset;
-    table.sh_size = size;
-    table.sh_link = SHN_UNDEF;
-    table.sh_info = 0;
-    table.sh_addralign = 1;
-    table.sh_entsize = 0;
-
-    return table;
-}
-
-Elf64_Shdr makeDataHeader(Elf64_Off offset, Elf64_Xword size) @nogc
-{
-    Elf64_Shdr table;
-
-    table.sh_name = 0x21;
-    table.sh_type = SHT_PROGBITS;
-    table.sh_flags = SHF_WRITE | SHF_ALLOC;
-    table.sh_addr = null;
-    table.sh_offset = offset;
-    table.sh_size = size;
-    table.sh_link = SHN_UNDEF;
-    table.sh_info = 0;
-    table.sh_addralign = 1;
-    table.sh_entsize = 0;
-
-    return table;
-}
-
-Elf64_Shdr makeSymtableHeader(Elf64_Off offset, Elf64_Xword size, Elf64_Word entriesCount) @nogc
-{
-    Elf64_Shdr table;
-
-    table.sh_name = 0x01;
-    table.sh_type = SHT_SYMTAB;
-    table.sh_flags = 0;
-    table.sh_addr = null;
-    table.sh_offset = offset;
-    table.sh_size = size;
-    table.sh_link = 0x03; // String table used by entries in this section.
-    table.sh_info = entriesCount;
-    table.sh_addralign = 8;
-    table.sh_entsize = Elf64_Sym.sizeof;
-
-    return table;
-}
-
-Elf64_Shdr makeStringHeader(Elf64_Word stringIndex, Elf64_Off offset, Elf64_Xword size) @nogc
-{
-    Elf64_Shdr table;
-
-    table.sh_name = stringIndex;
-    table.sh_type = SHT_STRTAB;
-    table.sh_flags = 0;
-    table.sh_addr = null;
-    table.sh_offset = offset;
-    table.sh_size = size;
-    table.sh_link = SHN_UNDEF;
-    table.sh_info = 0;
-    table.sh_addralign = 1;
-    table.sh_entsize = 0;
-
-    return table;
-}
-
-Elf64_Shdr makeInitialHeader() @nogc
-{
-    Elf64_Shdr table;
-
-    table.sh_name = 0;
-    table.sh_type = SHT_NULL;
-    table.sh_flags = 0;
-    table.sh_addr = null;
-    table.sh_offset = 0;
-    table.sh_size = 0;
-    table.sh_link = SHN_UNDEF;
-    table.sh_info = 0;
-    table.sh_addralign = 0;
-    table.sh_entsize = 0;
-
-    return table;
-}
-
-Elf64_Sym makeInitialSymTable() @nogc
-{
-    Elf64_Sym table;
-
-    table.st_name = 0;
-    table.st_info = 0;
-    table.st_other = 0;
-    table.st_shndx = 0;
-    table.st_value = null;
-    table.st_size = 0;
-
-    return table;
-}
-
-Elf64_Sym makeMainSymTable(Elf64_Half textIndex) @nogc
-{
-    Elf64_Sym table;
-
-    table.st_name = 0x01;
-    table.st_info = ELF32_ST_INFO(STB_GLOBAL, STT_FUNC);
-    table.st_other = 0;
-    table.st_shndx = textIndex;
-    table.st_value = null;
-    table.st_size = 0;
-
-    return table;
-}
-
-ubyte ELF32_ST_BIND(ubyte i) @nogc nothrow pure @safe
-{
-    return i >> 4;
-}
-
-ubyte ELF32_ST_TYPE(ubyte i) @nogc nothrow pure @safe
-{
-    return i & 0xf;
-}
-
-ubyte ELF32_ST_INFO(ubyte b, ubyte t) @nogc nothrow pure @safe
-{
-    return cast(ubyte) ((b << 4) + (t & 0xf));
-}
-
-/// Special Section Indices.
-enum : Elf64_Half
-{
-    /// Used to mark an undefined or meaningless section reference.
-    SHN_UNDEF = 0,
-    /// Processor-specific use.
-    SHN_LOPROC = 0xFF00,
-    SHN_HIPROC = 0xFF1F,
-    /// Environment-specific use.
-    SHN_LOOS = 0xFF20,
-    SHN_HIOS = 0xFF3F,
-    /// Indicates that the corresponding reference is an absolute value.
-    SHN_ABS = 0xFFF1,
-    /**
-     * Indicates a symbol that has been declared as a common block (Fortran
-     * COMMON or C tentative declaration).
-     */
-    SHN_COMMON = 0xFFF2,
-}
-
-/**
- * Object File Classes, e_ident[EI_CLASS].
- */
-enum EI_CLASS : ubyte
-{
-    /// 32-bit objects.
-    ELFCLASS32 = 1,
-    /// 64-bit objects.
-    ELFCLASS64 = 2,
-}
-
-enum ubyte EV_CURRENT = 1;
-
-/**
- * Data Encodings, e_ident[EI_DATA].
- */
-enum EI_DATA : ubyte
-{
-    /// Object file data structures are little-endian.
-    ELFDATA2LSB = 1,
-    /// Object file data structures are big-endian.
-    ELFDATA2MSB = 2,
-}
-
-/**
- * Operating System and ABI Identifiers, e_ident[EI_OSABI].
- */
-enum EI_OSABI : ubyte
-{
-    /// System V ABI.
-    ELFOSABI_SYSV = 0,
-    /// HP-UX operating system.
-    ELFOSABI_HPUX = 1,
-    /// Standalone (embedded) application.
-    ELFOSABI_STANDALONE = 255,
-}
-
-enum : Elf64_Half
-{
-    ET_NONE = 0, /// No file type.
-    ET_REL = 1, /// Relocatable object file.
-    ET_EXEC = 2, /// Executable file.
-    ET_DYN = 3, /// Shared object file.
-    ET_CORE = 4, /// Core file.
-    ET_LOOS = 0xFE00, /// Environment-specific use.
-    ET_HIOS = 0xFEFF,
-    ET_LOPROC = 0xFF00, /// Processor-specific use.
-    ET_HIPROC = 0xFFFF,
-}
-
-private size_t pad(size_t value) @nogc
-{
-    return (value / 8 + 1) * 8;
-}
-
-struct Symbol
-{
-    String name;
-    Array!ubyte instructions;
-}
-
-/*
-.text
-    .globl main
-    .type main, @function
-main:
-    movl $3, %eax
-    ret
-*/
-immutable ubyte[] instructions = [
-    // Opcode of pushq is “0x50 + r”, where “r” is the register opcode.
-    // Register opcode of %rbq is 5.
-    0x50 + 5, // push% %rbp
-    0x48, 0x89, 0xe5, // movq %rsp, %rbp
-
-    0xb8, 0x03, 0x00, 0x00, 0x00, // movl $3, %eax
-
-    // Epilogue.
-    0x48, 0x89, 0xec, // movq %rbp, %rsp
-    0x58 + 5, // popq %rbp
-    0xc3, // ret
-];
-
-void writeObject(Definition ast, String outputFilename) @nogc
-{
-    auto handle = fopen(outputFilename.toStringz, "wb");
-
-    if (handle is null)
-    {
-        perror("writing sample");
-        return;
-    }
-    scope (exit)
-    {
-        fclose(handle);
-    }
-
-    size_t currentOffset = Elf64_Ehdr.sizeof;
-    Array!Elf64_Shdr sectionHeaders;
-    Array!Elf64_Sym symbolEntries;
-
-    // Prologue
-    Array!ubyte asmTemplate = Array!ubyte(cast(ubyte[]) [
-        // Opcode of pushq is “0x50 + r”, where “r” is the register opcode.
-        // Register opcode of %rbq is 5.
-        0x50 + 5, // pushq %rbp
-        0x48, 0x89, 0xe5, // movq %rsp, %rbp
-    ]);
-    int i = 1;
-    foreach (statement; ast.statements[])
-    {
-        if ((cast(Number) statement.subroutine.lhs) !is null)
-        {
-            // Opcode of mov is “0xb8 + r”, where “r” is the register opcode.
-            // Register opcode of %eax is 0.
-            asmTemplate.insertBack(cast(ubyte) 0xb8); // movl $x, %eax; where $x is a number.
-            asmTemplate.insertBack((cast(ubyte*) &(cast(Number) statement.subroutine.lhs).value)[0 .. int.sizeof]);
-        }
-        else if ((cast(Variable) statement.subroutine.lhs) !is null)
-        {
-            // movl -x(%rbp), %ebx; where x is a number.
-            asmTemplate.insertBack(cast(ubyte[]) [0x8b, 0x45]);
-            const disposition = (cast(Variable) statement.subroutine.lhs).counter * (-4);
-            asmTemplate.insertBack((cast(ubyte*) &disposition)[0 .. 1]);
-        }
-        if ((cast(Number) statement.subroutine.rhs) !is null)
-        {
-            // Opcode of mov is “0xb8 + r”, where “r” is the register opcode.
-            // Register opcode of %ebx is 3.
-            asmTemplate.insertBack(cast(ubyte) 0xbb); // movl $x, %ebx; where $x is a number.
-            asmTemplate.insertBack((cast(ubyte*) &(cast(Number) statement.subroutine.rhs).value)[0 .. int.sizeof]);
-        }
-        else if ((cast(Variable) statement.subroutine.rhs) !is null)
-        {
-            // movl -x(%rbp), %ebx; where x is a number.
-            asmTemplate.insertBack(cast(ubyte[]) [0x8b, 0x5d]);
-            const disposition = (cast(Variable) statement.subroutine.rhs).counter * (-4);
-            asmTemplate.insertBack((cast(ubyte*) &disposition)[0 .. 1]);
-        }
-        // Calculate the result and assign it to a variable on the stack.
-        asmTemplate.insertBack(cast(ubyte[]) [0x01, 0xd8]); // add %ebx, %eax
-
-        asmTemplate.insertBack(cast(ubyte[]) [0x89, 0x45]); // movl %eax, -x(%rbp); where x is a number.
-        const disposition = i * (-4);
-        asmTemplate.insertBack((cast(ubyte*) &disposition)[0 .. 1]);
-        ++i;
-    }
-    // Epilogue.
-    asmTemplate.insertBack(cast(ubyte[]) [
-        0x48, 0x89, 0xec, // movq %rbp, %rsp
-        0x58 + 5, // popq %rbp
-        0xc3, // ret
-    ]);
-
-    Symbol[1] symbols = [Symbol(String("main"), asmTemplate)];
-
-    sectionHeaders.insertBack(makeInitialHeader());
-    symbolEntries.insertBack(makeInitialSymTable());
-
-    String stringTable = String("\0");
-    foreach (symbol; symbols[])
-    {
-        stringTable.insertBack(symbol.name[]);
-        stringTable.insertBack('\0');
-
-        sectionHeaders.insertBack(makeTextHeader(currentOffset, symbol.instructions.length));
-        currentOffset = pad(currentOffset + symbol.instructions.length);
-
-        symbolEntries.insertBack(makeMainSymTable(cast(Elf64_Half) (sectionHeaders.length - 1)));
-    }
-
-    const symbolTableSize = (symbols.length + 1) * Elf64_Sym.sizeof;
-    sectionHeaders.insertBack(makeSymtableHeader(currentOffset, symbolTableSize, symbols.length));
-    currentOffset += symbolTableSize;
-
-    sectionHeaders.insertBack(makeStringHeader(0x09, currentOffset, stringTable.length));
-    currentOffset += stringTable.length;
-
-    sectionHeaders.insertBack(makeStringHeader(0x11, currentOffset, sectionStringTable.length));
-    currentOffset = pad(currentOffset + sectionStringTable.length);
-
-    auto fileHeader = makeFileHeader(currentOffset, 5, 4);
-
-    version (none)
-    {
-        printf("%.2x\n", cast(uint) currentOffset);
-    }
-    ubyte[8] padding = 0;
-    size_t codeLength = stringTable.length + sectionStringTable.length;
-
-    fwrite(&fileHeader, 8, Elf64_Ehdr.sizeof / 8, handle);
-    foreach (symbol; symbols[])
-    {
-        immutable size_t instructionsLength = pad(symbol.instructions.length);
-        fwrite(symbol.instructions.get.ptr, 1, symbol.instructions.length, handle);
-        fwrite(padding.ptr, 1, instructionsLength - symbol.instructions.length, handle);
-        codeLength += instructionsLength;
-    }
-    fwrite(symbolEntries.get.ptr, Elf64_Sym.sizeof, symbolEntries.length, handle);
-    fwrite(stringTable.get.ptr, 1, stringTable.length, handle);
-    fwrite(sectionStringTable.ptr, 1, sectionStringTable.length, handle);
-    fwrite(padding.ptr, pad(codeLength) - codeLength, 1, handle);
-    fwrite(sectionHeaders.get.ptr, Elf64_Shdr.sizeof, sectionHeaders.length, handle);
-}
-
-String generate(Definition ast) @nogc
-{
-    // Prologue
-    String asmTemplate = ".text
-    .globl main
-    .type main, @function
-main:
-    pushq %rbp
-    movq %rsp, %rbp
-";
-
-    /* Allocate space on the stack for local variables.
-    asmTemplate.insertBack("    sub $");
-    asmTemplate.insertBack(format!"{}"(ast.statements.length)[]);
-    asmTemplate.insertBack(", $esp\n"); */
-
-    int i = 1;
-    foreach (statement; ast.statements[])
-    {
-        if ((cast(Number) statement.subroutine.lhs) !is null)
-        {
-            asmTemplate.insertBack("    movl $");
-            asmTemplate.insertBack(format!"{}"((cast(Number) statement.subroutine.lhs).value)[]);
-            asmTemplate.insertBack(", %eax\n");
-        }
-        else if ((cast(Variable) statement.subroutine.lhs) !is null)
-        {
-            asmTemplate.insertBack("    movl -");
-            asmTemplate.insertBack(format!"{}"((cast(Variable) statement.subroutine.lhs).counter * 4)[]);
-            asmTemplate.insertBack("(%rbp), %eax\n");
-        }
-        if ((cast(Number) statement.subroutine.rhs) !is null)
-        {
-            asmTemplate.insertBack("    movl $");
-            asmTemplate.insertBack(format!"{}"((cast(Number) statement.subroutine.rhs).value)[]);
-            asmTemplate.insertBack(", %ebx\n");
-        }
-        else if ((cast(Variable) statement.subroutine.rhs) !is null)
-        {
-            asmTemplate.insertBack("    movl -");
-            asmTemplate.insertBack(format!"{}"((cast(Variable) statement.subroutine.rhs).counter * 4)[]);
-            asmTemplate.insertBack("(%rbp), %ebx\n");
-        }
-        // Calculate the result and assign it to a variable on the stack.
-        asmTemplate.insertBack("    add %ebx, %eax\n");
-        asmTemplate.insertBack("    movl %eax, -");
-        asmTemplate.insertBack(format!"{}"(i * 4)[]);
-        asmTemplate.insertBack("(%rbp)\n");
-        ++i;
-    }
-
-    // Epilogue.
-    asmTemplate.insertBack("    movq %rbp, %rsp
-    popq %rbp
-    ret
-");
-
-    return asmTemplate;
-}

source/elna/ir.d

@@ -1,144 +0,0 @@
-module elna.ir;
-
-import parser = elna.parser;
-import tanya.container.array;
-import tanya.container.hashtable;
-import tanya.container.string;
-import tanya.memory.allocator;
-import tanya.memory.mmappool;
-
-/**
- * Definition.
- */
-class Definition
-{
-    char[] identifier;
-    Array!Statement statements;
-    Array!VariableDeclaration variableDeclarations;
-}
-
-class Statement
-{
-    Subroutine subroutine;
-}
-
-abstract class Expression
-{
-}
-
-class Number : Expression
-{
-    int value;
-}
-
-class Variable : Expression
-{
-    size_t counter;
-}
-
-class VariableDeclaration
-{
-    String identifier;
-}
-
-class Subroutine
-{
-    Expression lhs, rhs;
-}
-
-private Number transformNumber(parser.Number number) @nogc
-{
-    return MmapPool.instance.make!Number(number.value);
-}
-
-private Variable transformSubroutine(parser.Subroutine subroutine,
-        ref Array!Statement statements,
-        ref HashTable!(String, int) constants) @nogc
-{
-    auto target = MmapPool.instance.make!Subroutine;
-    target.lhs = transformExpression(subroutine.lhs, statements, constants);
-    target.rhs = transformExpression(subroutine.rhs, statements, constants);
-
-    auto newStatement = MmapPool.instance.make!Statement;
-    newStatement.subroutine = target;
-    statements.insertBack(newStatement);
-
-    auto newVariable = MmapPool.instance.make!Variable;
-    newVariable.counter = statements.length;
-
-    return newVariable;
-}
-
-private Expression transformExpression(parser.Expression expression,
-        ref Array!Statement statements,
-        ref HashTable!(String, int) constants) @nogc
-{
-    if ((cast(parser.Number) expression) !is null)
-    {
-        auto numberExpression = MmapPool.instance.make!Number;
-        numberExpression.value = (cast(parser.Number) expression).value;
-
-        return numberExpression;
-    }
-    if ((cast(parser.Variable) expression) !is null)
-    {
-        auto numberExpression = MmapPool.instance.make!Number;
-        numberExpression.value = constants[(cast(parser.Variable) expression).identifier];
-
-        return numberExpression;
-    }
-    else if ((cast(parser.Subroutine) expression) !is null)
-    {
-        return transformSubroutine(cast(parser.Subroutine) expression, statements, constants);
-    }
-    return null;
-}
-
-Expression transformStatement(parser.Statement statement,
-        ref Array!Statement statements,
-        ref HashTable!(String, int) constants) @nogc
-{
-    if ((cast(parser.BangStatement) statement) !is null)
-    {
-        return transformExpression((cast(parser.BangStatement) statement).expression, statements, constants);
-    }
-    return null;
-}
-
-HashTable!(String, int) transformConstants(ref Array!(parser.Definition) definitions) @nogc
-{
-    typeof(return) constants;
-
-    foreach (definition; definitions[])
-    {
-        constants[definition.identifier] = definition.number.value;
-    }
-
-    return constants;
-}
-
-Array!VariableDeclaration transformVariableDeclarations(ref Array!(parser.VariableDeclaration) variableDeclarations)
-@nogc
-{
-    typeof(return) variables;
-
-    foreach (ref variableDeclaration; variableDeclarations)
-    {
-        auto newDeclaration = MmapPool.instance.make!VariableDeclaration;
-        newDeclaration.identifier = variableDeclaration.identifier;
-        variables.insertBack(newDeclaration);
-    }
-
-    return variables;
-}
-
-Definition transform(parser.Block block) @nogc
-{
-    auto target = MmapPool.instance.make!Definition;
-    auto constants = transformConstants(block.definitions);
-
-    transformStatement(block.statement, target.statements, constants);
-    target.variableDeclarations = transformVariableDeclarations(block.variableDeclarations);
-
-    return target;
-}

source/elna/lexer.d

@@ -1,252 +0,0 @@
-module elna.lexer;
-
-import core.stdc.stdlib;
-import core.stdc.ctype;
-import core.stdc.string;
-import elna.result;
-import std.range;
-import tanya.container.array;
-import tanya.container.string;
-import tanya.memory.mmappool;
-
-struct Token
-{
-    enum Type
-    {
-        number,
-        subroutine, // Operator.
-        let,
-        identifier,
-        equals,
-        var,
-        semicolon,
-        leftParen,
-        rightParen,
-        bang,
-        dot,
-        comma,
-    }
-
-    union Value
-    {
-        int number;
-        String identifier;
-    }
-
-    private Type type;
-    private Value value_;
-    private Position position_;
-
-    @disable this();
-
-    this(Type type, Position position) @nogc nothrow pure @safe
-    {
-        this.type = type;
-        this.position_ = position;
-    }
-
-    this(Type type, int value, Position position) @nogc nothrow pure @trusted
-    in (type == Type.number)
-    {
-        this(type, position);
-        this.value_.number = value;
-    }
-
-    this()(Type type, auto ref String value, Position position)
-    @nogc nothrow pure @trusted
-    in (type == Type.identifier)
-    {
-        this(type, position);
-        this.value_.identifier = value;
-    }
-
-    /**
-     * Params:
-     *   type = Expected type.
-     *
-     * Returns: Whether this token is of the expected type.
-     */
-    bool ofType(Type type) const @nogc nothrow pure @safe
-    {
-        return this.type == type;
-    }
-
-    @property auto value(Type type)() @nogc nothrow pure @trusted
-    in (ofType(type))
-    {
-        static if (type == Type.number)
-        {
-            return this.value_.number;
-        }
-        else static if (type == Type.identifier)
-        {
-            return this.value_.identifier;
-        }
-        else
-        {
-            static assert(false, "This type doesn't have a value");
-        }
-    }
-
-    /**
-     * Returns: The token position in the source text.
-     */
-    @property const(Position) position() const @nogc nothrow pure @safe
-    {
-        return this.position_;
-    }
-}
-
-/**
- * Range over the source text that keeps track of the current position.
- */
-struct Source
-{
-    char[] buffer;
-    Position position;
-
-    this(char[] buffer) @nogc nothrow pure @safe
-    {
-        this.buffer = buffer;
-    }
-
-    @disable this();
-
-    bool empty() @nogc nothrow pure @safe
-    {
-        return this.length == 0;
-    }
-
-    char front() @nogc nothrow pure @safe
-    in (!empty)
-    {
-        return this.buffer[0];
-    }
-
-    void popFront() @nogc nothrow pure @safe
-    in (!empty)
-    {
-        this.buffer = buffer[1 .. $];
-        ++this.position.column;
-    }
-
-    void breakLine() @nogc nothrow pure @safe
-    in (!empty)
-    {
-        this.buffer = buffer[1 .. $];
-        ++this.position.line;
-        this.position.column = 1;
-    }
-
-    @property size_t length() const @nogc nothrow pure @safe
-    {
-        return this.buffer.length;
-    }
-
-    char opIndex(size_t index) @nogc nothrow pure @safe
-    in (index < length)
-    {
-        return this.buffer[index];
-    }
-
-    char[] opSlice(size_t i, size_t j) @nogc nothrow pure @safe
-    in
-    {
-        assert(i <= j);
-        assert(j <= length);
-    }
-    do
-    {
-        return this.buffer[i .. j];
-    }
-}
-
-Array!Token lex(char[] buffer) @nogc
-{
-    Array!Token tokens;
-    auto source = Source(buffer);
-
-    while (!source.empty)
-    {
-        if (source.front == ' ')
-        {
-            source.popFront;
-        }
-        else if (source.front >= '0' && source.front <= '9') // Multi-digit.
-        {
-            tokens.insertBack(Token(Token.Type.number, source.front - '0', source.position));
-            source.popFront;
-        }
-        else if (source.front == '=')
-        {
-            tokens.insertBack(Token(Token.Type.equals, source.position));
-            source.popFront;
-        }
-        else if (source.front == '(')
-        {
-            tokens.insertBack(Token(Token.Type.leftParen, source.position));
-            source.popFront;
-        }
-        else if (source.front == ')')
-        {
-            tokens.insertBack(Token(Token.Type.rightParen, source.position));
-            source.popFront;
-        }
-        else if (source.front == ';')
-        {
-            tokens.insertBack(Token(Token.Type.semicolon, source.position));
-            source.popFront;
-        }
-        else if (source.front == ',')
-        {
-            tokens.insertBack(Token(Token.Type.comma, source.position));
-            source.popFront;
-        }
-        else if (source.front == '!')
-        {
-            tokens.insertBack(Token(Token.Type.bang, source.position));
-            source.popFront;
-        }
-        else if (source.front == '.')
-        {
-            tokens.insertBack(Token(Token.Type.dot, source.position));
-            source.popFront;
-        }
-        else if (isalpha(source.front))
-        {
-            size_t i = 1;
-            while (i < source.length && isalpha(source[i]))
-            {
-                ++i;
-            }
-            if (source[0 .. i] == "const")
-            {
-                tokens.insertBack(Token(Token.Type.let, source.position));
-            }
-            else if (source[0 .. i] == "var")
-            {
-                tokens.insertBack(Token(Token.Type.var, source.position));
-            }
-            else
-            {
-                auto identifier = String(source[0 .. i]);
-                tokens.insertBack(Token(Token.Type.identifier, identifier, source.position));
-            }
-            source.popFrontN(i);
-        }
-        else if (source.front == '+') // Multi-character, random special characters.
-        {
-            tokens.insertBack(Token(Token.Type.subroutine, source.position));
-            source.popFront;
-        }
-        else if (source.front == '\n')
-        {
-            source.breakLine;
-        }
-        else
-        {
-            return typeof(tokens)(); // Error.
-        }
-    }
-    return tokens;
-}

source/elna/parser.d

@@ -1,269 +0,0 @@
-module elna.parser;
-
-import elna.lexer;
-import elna.result;
-import tanya.container.array;
-import tanya.container.string;
-import tanya.memory.allocator;
-import tanya.memory.mmappool;
-
-/**
- * Constant definition.
- */
-class Definition
-{
-    Number number;
-    String identifier;
-}
-
-/**
- * Variable declaration.
- */
-class VariableDeclaration
-{
-    String identifier;
-}
-
-abstract class Statement
-{
-}
-
-class BangStatement : Statement
-{
-    Expression expression;
-}
-
-class Block
-{
-    Array!Definition definitions;
-    Array!VariableDeclaration variableDeclarations;
-    Statement statement;
-}
-
-abstract class Expression
-{
-}
-
-class Number : Expression
-{
-    int value;
-}
-
-class Variable : Expression
-{
-    String identifier;
-}
-
-class Subroutine : Expression
-{
-    Expression lhs, rhs;
-}
-
-private Result!Expression parseExpression(ref Array!(Token).Range tokens) @nogc
-in (!tokens.empty, "Expected expression, got end of stream")
-{
-    if (tokens.front.ofType(Token.Type.number))
-    {
-        auto number = MmapPool.instance.make!Number;
-        number.value = tokens.front.value!(Token.Type.number);
-        tokens.popFront;
-        return Result!Expression(number);
-    }
-    else if (tokens.front.ofType(Token.Type.identifier))
-    {
-        auto variable = MmapPool.instance.make!Variable;
-        variable.identifier = tokens.front.value!(Token.Type.identifier);
-        tokens.popFront;
-        return Result!Expression(variable);
-    }
-    else if (tokens.front.ofType(Token.Type.subroutine))
-    {
-        auto subroutine = MmapPool.instance.make!Subroutine;
-        tokens.popFront;
-        auto expression = parseExpression(tokens);
-        if (expression.valid)
-        {
-            subroutine.lhs = expression.result;
-        }
-        else
-        {
-            return Result!Expression("Expected left-hand side to be an expression", tokens.front.position);
-        }
-        expression = parseExpression(tokens);
-        if (expression.valid)
-        {
-            subroutine.rhs = expression.result;
-        }
-        else
-        {
-            return Result!Expression("Expected left-hand side to be an expression", tokens.front.position);
-        }
-        return Result!Expression(subroutine);
-    }
-    else if (tokens.front.ofType(Token.Type.leftParen))
-    {
-        tokens.popFront;
-
-        auto expression = parseExpression(tokens);
-
-        tokens.popFront;
-        return expression;
-    }
-    return Result!Expression("Expected an expression", tokens.front.position);
-}
-
-private Result!Definition parseDefinition(ref Array!Token.Range tokens) @nogc
-in (!tokens.empty, "Expected definition, got end of stream")
-{
-    auto definition = MmapPool.instance.make!Definition;
-    definition.identifier = tokens.front.value!(Token.Type.identifier); // Copy.
-
-    tokens.popFront();
-    tokens.popFront(); // Skip the equals sign.
-
-    if (tokens.front.ofType(Token.Type.number))
-    {
-        auto number = MmapPool.instance.make!Number;
-        number.value = tokens.front.value!(Token.Type.number);
-        definition.number = number;
-        tokens.popFront;
-        return Result!Definition(definition);
-    }
-    return Result!Definition("Expected a number", tokens.front.position);
-}
-
-private Result!Statement parseStatement(ref Array!Token.Range tokens) @nogc
-in (!tokens.empty, "Expected block, got end of stream")
-{
-    if (tokens.front.ofType(Token.Type.bang))
-    {
-        tokens.popFront;
-        auto statement = MmapPool.instance.make!BangStatement;
-        auto expression = parseExpression(tokens);
-        if (expression.valid)
-        {
-            statement.expression = expression.result;
-        }
-        else
-        {
-            return Result!Statement(expression.error.get);
-        }
-        return Result!Statement(statement);
-    }
-    return Result!Statement("Expected ! statement", tokens.front.position);
-}
-
-private Result!(Array!Definition) parseDefinitions(ref Array!Token.Range tokens) @nogc
-in (!tokens.empty, "Expected definition, got end of stream")
-{
-    tokens.popFront; // Skip const.
-
-    Array!Definition definitions;
-
-    while (!tokens.empty)
-    {
-        auto definition = parseDefinition(tokens);
-        if (!definition.valid)
-        {
-            return typeof(return)(definition.error.get);
-        }
-        definitions.insertBack(definition.result);
-        if (tokens.front.ofType(Token.Type.semicolon))
-        {
-            break;
-        }
-        if (tokens.front.ofType(Token.Type.comma))
-        {
-            tokens.popFront;
-        }
-    }
-
-    return typeof(return)(definitions);
-}
-
-private Result!(Array!VariableDeclaration) parseVariableDeclarations(ref Array!Token.Range tokens) @nogc
-in (!tokens.empty, "Expected variable declarations, got end of stream")
-{
-    tokens.popFront; // Skip var.
-
-    Array!VariableDeclaration variableDeclarations;
-
-    while (!tokens.empty)
-    {
-        auto currentToken = tokens.front;
-        if (currentToken.ofType(Token.Type.identifier))
-        {
-            auto variableDeclaration = MmapPool.instance.make!VariableDeclaration;
-            variableDeclaration.identifier = currentToken.value!(Token.Type.identifier);
-            variableDeclarations.insertBack(variableDeclaration);
-            tokens.popFront;
-        }
-        else
-        {
-            return typeof(return)("Expected variable name", tokens.front.position);
-        }
-        if (tokens.empty)
-        {
-            return typeof(return)("Expected \";\" or \",\" name", currentToken.position);
-        }
-        if (tokens.front.ofType(Token.Type.semicolon))
-        {
-            break;
-        }
-        if (tokens.front.ofType(Token.Type.comma))
-        {
-            tokens.popFront;
-        }
-    }
-
-    return typeof(return)(variableDeclarations);
-}
-
-private Result!Block parseBlock(ref Array!Token.Range tokens) @nogc
-in (!tokens.empty, "Expected block, got end of stream")
-{
-    auto block = MmapPool.instance.make!Block;
-    if (tokens.front.ofType(Token.Type.let))
-    {
-        auto constDefinitions = parseDefinitions(tokens);
-        if (constDefinitions.valid)
-        {
-            block.definitions = constDefinitions.result;
-        }
-        else
-        {
-            return Result!Block(constDefinitions.error.get);
-        }
-        tokens.popFront;
-    }
-    if (tokens.front.ofType(Token.Type.var))
-    {
-        auto variableDeclarations = parseVariableDeclarations(tokens);
-        if (variableDeclarations.valid)
-        {
-            block.variableDeclarations = variableDeclarations.result;
-        }
-        else
-        {
-            return Result!Block(variableDeclarations.error.get);
-        }
-        tokens.popFront;
-    }
-    auto statement = parseStatement(tokens);
-    if (statement.valid)
-    {
-        block.statement = statement.result;
-    }
-    else
-    {
-        return Result!Block(statement.error.get);
-    }
-
-    return Result!Block(block);
-}
-
-Result!Block parse(ref Array!Token tokenStream) @nogc
-{
-    auto tokens = tokenStream[];
-    return parseBlock(tokens);
-}

source/elna/result.d

@@ -1,84 +0,0 @@
-module elna.result;
-
-import std.typecons;
-
-/**
- * Position in the source text.
- */
-struct Position
-{
-    /// Line.
-    size_t line = 1;
-
-    /// Column.
-    size_t column = 1;
-}
-
-struct CompileError
-{
-    private string message_;
-
-    private Position position_;
-
-    @disable this();
-
-    /**
-     * Params:
-     *   message = Error text.
-     *   position = Error position in the source text.
-     */
-    this(string message, Position position) @nogc nothrow pure @safe
-    {
-        this.message_ = message;
-        this.position_ = position;
-    }
-
-    /// Error text.
-    @property string message() const @nogc nothrow pure @safe
-    {
-        return this.message_;
-    }
-
-    /// Error line in the source text.
-    @property size_t line() const @nogc nothrow pure @safe
-    {
-        return this.position_.line;
-    }
-
-    /// Error column in the source text.
-    @property size_t column() const @nogc nothrow pure @safe
-    {
-        return this.position_.column;
-    }
-}
-
-struct Result(T)
-{
-    Nullable!CompileError error;
-    T result;
-
-    this(T result)
-    {
-        this.result = result;
-        this.error = typeof(this.error).init;
-    }
-
-    this(string message, Position position)
-    {
-        this.result = T.init;
-        this.error = CompileError(message, position);
-    }
-
-    this(CompileError compileError)
-    {
-        this.result = null;
-        this.error = compileError;
-    }
-
-    @disable this();
-
-    @property bool valid() const
-    {
-        return error.isNull;
-    }
-}

source/main.d

@@ -1,72 +0,0 @@
-import core.stdc.stdio;
-import core.stdc.string;
-import core.stdc.stdlib;
-import elna.lexer;
-import elna.parser;
-import elna.generator;
-import elna.ir;
-import tanya.container.string;
-import tanya.memory.allocator;
-import tanya.memory.mmappool;
-
-private char[] readSource(size_t N)(string source, out char[N] buffer) @nogc
-{
-    memcpy(buffer.ptr, source.ptr, source.length + 1);
-    buffer[source.length] = '\0';
-    auto handle = fopen(buffer.ptr, "r");
-    if (handle is null)
-    {
-        perror(buffer.ptr);
-        return null;
-    }
-    fseek(handle, 0, SEEK_END);
-    size_t fsize = ftell(handle);
-    rewind(handle);
-
-    fread(buffer.ptr, fsize, 1, handle);
-    fclose(handle);
-    buffer[fsize] = '\0';
-
-    return buffer[0 .. fsize];
-}
-
-int main(string[] args)
-{
-    char[255] buffer;
-
-    defaultAllocator = MmapPool.instance;
-
-    if (args.length < 2)
-    {
-        return 4;
-    }
-    auto sourceText = readSource(args[1], buffer);
-    if (sourceText is null)
-    {
-        return 3;
-    }
-    auto tokens = lex(sourceText);
-    if (tokens.length == 0)
-    {
-        printf("Lexical analysis failed.\n");
-        return 1;
-    }
-    auto ast = parse(tokens);
-    if (!ast.valid)
-    {
-        auto compileError = ast.error.get;
-        printf("%lu:%lu: %s\n", compileError.line, compileError.column, compileError.message.ptr);
-        return 2;
-    }
-    auto ir = transform(ast.result);
-
-    String outputFilename = String("build/");
-    outputFilename.insertBack(args[1][0 .. $ - 4]);
-    outputFilename.insertBack("o");
-    writeObject(ir, outputFilename);
-
-    auto code = generate(ir);
-    printf("%s", code.toStringz());
-
-    return 0;
-}

tests/const_list.elna

@@ -1,3 +0,0 @@
-const a = 1, b = 2;
-! + a b
-.

tests/expectations/const_list.txt

@@ -1 +0,0 @@
-3

tests/expectations/sum.txt

@@ -1 +0,0 @@
-8

tests/expectations/sums.txt

@@ -1 +0,0 @@
-8

tests/sum.elna

@@ -1,2 +0,0 @@
-! + 1 7
-.

tests/sums.elna

@@ -1,2 +0,0 @@
-! + 1 (+ 3 4)
-.