Shorten the module declaration

source/Parser.elna

@@ -1,4 +1,4 @@
-implementation module Parser;
+module;
 
 from SYSTEM import TSIZE;
 
@@ -337,4 +337,130 @@ begin
   return result
 end;
 
+proc parse_constant_declaration(lexer: PLexer) -> PAstConstantDeclaration;
+var
+  token: LexerToken;
+  result: PAstConstantDeclaration;
+begin
+  ALLOCATE(result, TSIZE(AstConstantDeclaration));
+
+  token := lexer_current(lexer);
+  result^.constant_name := token.identifierKind;
+
+  token := transpiler_lex(lexer);
+
+  token := transpiler_lex(lexer);
+  result^.constant_value := token.integerKind;
+
+  token := transpiler_lex(lexer);
+
+  return result
+end;
+
+proc parse_constant_part(lexer: PLexer) -> PPAstConstantDeclaration;
+var
+  token: LexerToken;
+  result: PPAstConstantDeclaration;
+  current_declaration: PPAstConstantDeclaration;
+  declaration_count: CARDINAL;
+begin
+  token := lexer_current(lexer);
+
+  ALLOCATE(result, TSIZE(PAstConstantDeclaration));
+  current_declaration := result;
+  declaration_count := 0;
+
+  if token.kind = lexerKindConst then
+    token := transpiler_lex(lexer);
+
+    while token.kind = lexerKindIdentifier do
+      INC(declaration_count);
+
+      REALLOCATE(result, TSIZE(PAstConstantDeclaration) * (declaration_count + 1));
+      current_declaration := result;
+      INC(current_declaration, TSIZE(PAstConstantDeclaration) * (declaration_count - 1));
+
+      current_declaration^ := parse_constant_declaration(lexer);
+      token := transpiler_lex(lexer)
+    end
+  end;
+  if declaration_count <> 0 then
+    INC(current_declaration, TSIZE(PAstConstantDeclaration))
+  end;
+  current_declaration^ := nil;
+
+  return result
+end;
+
+proc parse_import_statement(lexer: PLexer) -> PAstImportStatement;
+var
+  result: PAstImportStatement;
+  token: LexerToken;
+  symbol_count: CARDINAL;
+  current_symbol: PIdentifier;
+begin
+  ALLOCATE(result, TSIZE(AstImportStatement));
+  symbol_count := 1;
+
+  token := transpiler_lex(lexer);
+  result^.package := token.identifierKind;
+
+  token := transpiler_lex(lexer);
+  ALLOCATE(result^.symbols, TSIZE(Identifier) * 2);
+
+  current_symbol := result^.symbols;
+
+  token := transpiler_lex(lexer);
+  current_symbol^ := token.identifierKind;
+
+  token := transpiler_lex(lexer);
+  while token.kind <> lexerKindSemicolon do
+    token := transpiler_lex(lexer);
+    INC(symbol_count);
+
+    REALLOCATE(result^.symbols, TSIZE(Identifier) * (symbol_count + 1));
+    current_symbol := result^.symbols;
+	INC(current_symbol, TSIZE(Identifier) * (symbol_count - 1));
+
+    current_symbol^ := token.identifierKind;
+    token := transpiler_lex(lexer)
+  end;
+  INC(current_symbol, TSIZE(Identifier));
+  MemZero(current_symbol, TSIZE(Identifier));
+
+  token := transpiler_lex(lexer);
+
+  return result
+end;
+
+proc parse_import_part(lexer: PLexer) -> PPAstImportStatement;
+var
+  token: LexerToken;
+  import_statement: PPAstImportStatement;
+  result: PPAstImportStatement;
+  import_count: CARDINAL;
+begin
+  token := lexer_current(lexer);
+  ALLOCATE(result, TSIZE(PAstImportStatement));
+  import_statement := result;
+  import_count := 0;
+
+  while token.kind = lexerKindFrom do
+    INC(import_count);
+
+    REALLOCATE(result, TSIZE(PAstImportStatement) * (import_count + 1));
+    import_statement := result;
+    INC(import_statement, TSIZE(PAstImportStatement) * (import_count - 1));
+
+    import_statement^ := parse_import_statement(lexer);
+    token := lexer_current(lexer)
+  end;
+  if import_count > 0 then
+    INC(import_statement, TSIZE(PAstImportStatement))
+  end;
+  import_statement^ := nil;
+
+  return result
+end;
+
 end.