belka/elna
1
0
Fork 0
Code Issues 5 Pull Requests Releases Activity

Shorten the array syntax

Browse Source
This commit is contained in:
Eugen Wissner 2025-05-30 12:56:11 +02:00
parent 273e26b119
commit 15135f14d8
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
3 changed files with 665 additions and 647 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
source/Compiler.mod
View File

@ -7,12 +7,12 @@ FROM Lexer IMPORT Lexer, lexer_destroy, lexer_initialize;
FROM Transpiler IMPORT transpile; FROM Transpiler IMPORT transpile;
VAR VAR
ALexer: Lexer; lexer: Lexer;
BEGIN BEGIN
lexer_initialize(ADR(ALexer), StdIn); lexer_initialize(ADR(lexer), StdIn);
transpile(ADR(ALexer)); transpile(ADR(lexer));
lexer_destroy(ADR(ALexer)) lexer_destroy(ADR(lexer))
END Compiler. END Compiler.

757
source/Lexer.mod
View File

File diff suppressed because it is too large Load Diff

543
source/Transpiler.mod
View File

@ -13,17 +13,17 @@ TYPE
END; END;
(* Calls lexer_lex() but skips the comments. *) (* Calls lexer_lex() but skips the comments. *)
PROCEDURE transpiler_lex(ALexer: PLexer): LexerToken; PROCEDURE transpiler_lex(lexer: PLexer): LexerToken;
VAR VAR
Result: LexerToken; result: LexerToken;
BEGIN BEGIN
Result := lexer_lex(ALexer); result := lexer_lex(lexer);
WHILE Result.Kind = lexerKindComment DO WHILE result.Kind = lexerKindComment DO
Result := lexer_lex(ALexer) result := lexer_lex(lexer)
END; END;
RETURN Result RETURN result
END transpiler_lex; END transpiler_lex;
(* Write a semicolon followed by a newline. *) (* Write a semicolon followed by a newline. *)
PROCEDURE write_semicolon(); PROCEDURE write_semicolon();
@ -31,527 +31,544 @@ BEGIN
WriteString(';'); WriteString(';');
WriteLn() WriteLn()
END write_semicolon; END write_semicolon;
PROCEDURE transpile_import(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_import(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString('FROM '); WriteString('FROM ');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WriteString(' IMPORT '); WriteString(' IMPORT ');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WHILE Token.Kind <> lexerKindSemicolon DO WHILE token.Kind <> lexerKindSemicolon DO
WriteString(', '); WriteString(', ');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer) token := transpiler_lex(lexer)
END; END;
write_semicolon(); write_semicolon();
Token := transpiler_lex(ALexer) token := transpiler_lex(lexer)
END transpile_import; END transpile_import;
PROCEDURE transpile_import_part(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_import_part(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; token: LexerToken;
BEGIN BEGIN
Token := lexer_current(ALexer); token := lexer_current(lexer);
WHILE Token.Kind = lexerKindFrom DO WHILE token.Kind = lexerKindFrom DO
transpile_import(AContext, ALexer); transpile_import(context, lexer);
Token := lexer_current(ALexer) token := lexer_current(lexer)
END; END;
WriteLn() WriteLn()
END transpile_import_part; END transpile_import_part;
PROCEDURE transpile_constant(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_constant(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString(' '); WriteString(' ');
Token := lexer_current(ALexer); Token := lexer_current(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WriteString(' = '); WriteString(' = ');
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
write_semicolon() write_semicolon()
END transpile_constant; END transpile_constant;
PROCEDURE transpile_constant_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN; PROCEDURE transpile_constant_part(context: PTranspilerContext; lexer: PLexer): BOOLEAN;
VAR VAR
Token: LexerToken; Token: LexerToken;
Result: BOOLEAN; result: BOOLEAN;
BEGIN BEGIN
Token := lexer_current(ALexer); Token := lexer_current(lexer);
Result := Token.Kind = lexerKindConst; result := Token.Kind = lexerKindConst;
IF Result THEN IF result THEN
WriteString('CONST'); WriteString('CONST');
WriteLn(); WriteLn();
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WHILE Token.Kind = lexerKindIdentifier DO WHILE Token.Kind = lexerKindIdentifier DO
transpile_constant(AContext, ALexer); transpile_constant(context, lexer);
Token := transpiler_lex(ALexer) Token := transpiler_lex(lexer)
END END
END; END;
RETURN Result RETURN result
END transpile_constant_part; END transpile_constant_part;
PROCEDURE transpile_module(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_module(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
IF Token.Kind = lexerKindDefinition THEN IF Token.Kind = lexerKindDefinition THEN
WriteString('DEFINITION '); WriteString('DEFINITION ');
Token := transpiler_lex(ALexer) Token := transpiler_lex(lexer)
END; END;
IF Token.Kind = lexerKindImplementation THEN IF Token.Kind = lexerKindImplementation THEN
WriteString('IMPLEMENTATION '); WriteString('IMPLEMENTATION ');
Token := transpiler_lex(ALexer) Token := transpiler_lex(lexer)
END; END;
WriteString('MODULE '); WriteString('MODULE ');
(* Write the module name and end the line with a semicolon and newline. *) (* Write the module name and end the line with a semicolon and newline. *)
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
write_semicolon(); write_semicolon();
WriteLn(); WriteLn();
(* Write the module body. *) (* Write the module body. *)
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
transpile_import_part(AContext, ALexer); transpile_import_part(context, lexer);
IF transpile_constant_part(AContext, ALexer) THEN IF transpile_constant_part(context, lexer) THEN
WriteLn() WriteLn()
END; END;
transpile_type_part(AContext, ALexer); transpile_type_part(context, lexer);
IF transpile_variable_part(AContext, ALexer) THEN IF transpile_variable_part(context, lexer) THEN
WriteLn() WriteLn()
END; END;
transpile_procedure_part(AContext, ALexer); transpile_procedure_part(context, lexer);
transpile_statement_part(AContext, ALexer); transpile_statement_part(context, lexer);
WriteString('END '); WriteString('END ');
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
Write('.'); Write('.');
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WriteLn() WriteLn()
END transpile_module; END transpile_module;
PROCEDURE transpile_type_fields(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_type_fields(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WHILE Token.Kind <> lexerKindEnd DO WHILE Token.Kind <> lexerKindEnd DO
WriteString(' '); WriteString(' ');
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WriteString(': '); WriteString(': ');
transpile_type_expression(AContext, ALexer); transpile_type_expression(context, lexer);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
IF Token.Kind = lexerKindSemicolon THEN IF Token.Kind = lexerKindSemicolon THEN
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
Write(';') Write(';')
END; END;
WriteLn() WriteLn()
END END
END transpile_type_fields; END transpile_type_fields;
PROCEDURE transpile_record_type(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_record_type(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
BEGIN BEGIN
WriteString('RECORD'); WriteString('RECORD');
WriteLn(); WriteLn();
transpile_type_fields(AContext, ALexer); transpile_type_fields(context, lexer);
WriteString(' END') WriteString(' END')
END transpile_record_type; END transpile_record_type;
PROCEDURE transpile_pointer_type(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_pointer_type(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
Token := lexer_current(ALexer); Token := lexer_current(lexer);
WriteString('POINTER TO '); WriteString('POINTER TO ');
IF Token.Kind = lexerKindPointer THEN IF Token.Kind = lexerKindPointer THEN
Token := transpiler_lex(ALexer) Token := transpiler_lex(lexer)
END; END;
transpile_type_expression(AContext, ALexer) transpile_type_expression(context, lexer)
END transpile_pointer_type; END transpile_pointer_type;
PROCEDURE transpile_array_type(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_array_type(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString('ARRAY'); WriteString('ARRAY');
Token := transpiler_lex(ALexer); Token := lexer_current(lexer);
IF Token.Kind = lexerKindArray THEN
Token := transpiler_lex(lexer)
END;
IF Token.Kind <> lexerKindOf THEN IF Token.Kind <> lexerKindOf THEN
Write('['); WriteString('[1..');
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WriteString('..'); Write(']')
Token := transpiler_lex(ALexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
Token := transpiler_lex(ALexer);
Write(']');
Token := transpiler_lex(ALexer)
END; END;
WriteString(' OF '); WriteString(' OF ');
transpile_type_expression(AContext, ALexer) transpile_type_expression(context, lexer)
END transpile_array_type; END transpile_array_type;
PROCEDURE transpile_enumeration_type(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_enumeration_type(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString('('); WriteString('(');
WriteLn(); WriteLn();
WriteString(' '); WriteString(' ');
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WHILE Token.Kind = lexerKindComma DO WHILE Token.Kind = lexerKindComma DO
Write(','); Write(',');
WriteLn(); WriteLn();
WriteString(' '); WriteString(' ');
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer) Token := transpiler_lex(lexer)
END; END;
WriteLn(); WriteLn();
WriteString(' )') WriteString(' )')
END transpile_enumeration_type; END transpile_enumeration_type;
PROCEDURE transpile_union_type(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_union_type(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
END transpile_union_type; END transpile_union_type;
PROCEDURE transpile_procedure_type(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_procedure_type(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WriteString('PROCEDURE('); WriteString('PROCEDURE(');
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WHILE Token.Kind <> lexerKindRightParen DO WHILE Token.Kind <> lexerKindRightParen DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
IF Token.Kind = lexerKindComma THEN IF Token.Kind = lexerKindComma THEN
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WriteString(', ') WriteString(', ')
END END
END; END;
Write(')') Write(')')
END transpile_procedure_type; END transpile_procedure_type;
PROCEDURE transpile_type_expression(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_type_expression(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
IF Token.Kind = lexerKindRecord THEN IF Token.Kind = lexerKindRecord THEN
transpile_record_type(AContext, ALexer) transpile_record_type(context, lexer)
END; END;
IF Token.Kind = lexerKindLeftParen THEN IF Token.Kind = lexerKindLeftParen THEN
transpile_enumeration_type(AContext, ALexer) transpile_enumeration_type(context, lexer)
END; END;
IF Token.Kind = lexerKindArray THEN IF (Token.Kind = lexerKindArray) OR (Token.Kind = lexerKindLeftSquare) THEN
transpile_array_type(AContext, ALexer) transpile_array_type(context, lexer)
END; END;
IF (Token.Kind = lexerKindPointer) OR (Token.Kind = lexerKindHat) THEN IF Token.Kind = lexerKindHat THEN
transpile_pointer_type(AContext, ALexer) transpile_pointer_type(context, lexer)
END; END;
IF Token.Kind = lexerKindProc THEN IF Token.Kind = lexerKindProc THEN
transpile_procedure_type(AContext, ALexer) transpile_procedure_type(context, lexer)
END; END;
IF Token.Kind = lexerKindIdentifier THEN IF Token.Kind = lexerKindIdentifier THEN
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start) written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start)
END END
END transpile_type_expression; END transpile_type_expression;
PROCEDURE transpile_type_declaration(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_type_declaration(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString(' '); WriteString(' ');
Token := lexer_current(ALexer); Token := lexer_current(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WriteString(' = '); WriteString(' = ');
transpile_type_expression(AContext, ALexer); transpile_type_expression(context, lexer);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
write_semicolon(); write_semicolon();
END transpile_type_declaration; END transpile_type_declaration;
PROCEDURE transpile_type_part(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_type_part(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; token: LexerToken;
BEGIN BEGIN
Token := lexer_current(ALexer); token := lexer_current(lexer);
IF Token.Kind = lexerKindType THEN IF token.Kind = lexerKindType THEN
WriteString('TYPE'); WriteString('TYPE');
WriteLn(); WriteLn();
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WHILE Token.Kind = lexerKindIdentifier DO WHILE token.Kind = lexerKindIdentifier DO
transpile_type_declaration(AContext, ALexer); transpile_type_declaration(context, lexer);
Token := transpiler_lex(ALexer) token := transpiler_lex(lexer)
END; END;
WriteLn() WriteLn()
END END
END transpile_type_part; END transpile_type_part;
PROCEDURE transpile_variable_declaration(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_variable_declaration(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString(' '); WriteString(' ');
Token := lexer_current(ALexer); Token := lexer_current(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WriteString(': '); WriteString(': ');
transpile_type_expression(AContext, ALexer); transpile_type_expression(context, lexer);
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
write_semicolon() write_semicolon()
END transpile_variable_declaration; END transpile_variable_declaration;
PROCEDURE transpile_variable_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN; PROCEDURE transpile_variable_part(context: PTranspilerContext; lexer: PLexer): BOOLEAN;
VAR VAR
Token: LexerToken; Token: LexerToken;
Result: BOOLEAN; result: BOOLEAN;
BEGIN BEGIN
Token := lexer_current(ALexer); Token := lexer_current(lexer);
Result := Token.Kind = lexerKindVar; result := Token.Kind = lexerKindVar;
IF Result THEN IF result THEN
WriteString('VAR'); WriteString('VAR');
WriteLn(); WriteLn();
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WHILE Token.Kind = lexerKindIdentifier DO WHILE Token.Kind = lexerKindIdentifier DO
transpile_variable_declaration(AContext, ALexer); transpile_variable_declaration(context, lexer);
Token := transpiler_lex(ALexer) Token := transpiler_lex(lexer)
END END
END; END;
RETURN Result RETURN result
END transpile_variable_part; END transpile_variable_part;
PROCEDURE transpile_procedure_heading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken; PROCEDURE transpile_procedure_heading(context: PTranspilerContext; lexer: PLexer): LexerToken;
VAR VAR
Token: LexerToken; token: LexerToken;
Result: LexerToken; result: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString('PROCEDURE '); WriteString('PROCEDURE ');
Result := transpiler_lex(ALexer); result := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
Write('('); Write('(');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WHILE Token.Kind <> lexerKindRightParen DO WHILE token.Kind <> lexerKindRightParen DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WriteString(': '); WriteString(': ');
transpile_type_expression(AContext, ALexer); transpile_type_expression(context, lexer);
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
IF Token.Kind = lexerKindSemicolon THEN IF (token.Kind = lexerKindSemicolon) OR (token.Kind = lexerKindComma) THEN
WriteString('; '); WriteString('; ');
Token := transpiler_lex(ALexer) token := transpiler_lex(lexer)
END END
END; END;
WriteString(')'); WriteString(')');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
(* Check for the return type and write it. *) (* Check for the return type and write it. *)
IF Token.Kind = lexerKindColon THEN IF token.Kind = lexerKindColon THEN
WriteString(': '); WriteString(': ');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer) token := transpiler_lex(lexer)
END; END;
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
write_semicolon(); write_semicolon();
RETURN Result RETURN result
END transpile_procedure_heading; END transpile_procedure_heading;
PROCEDURE transpile_expression(AContext: PTranspilerContext; ALexer: PLexer; TrailingToken: LexerKind); PROCEDURE transpile_expression(context: PTranspilerContext; lexer: PLexer; TrailingToken: LexerKind);
VAR VAR
Token: LexerToken; token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WHILE (Token.Kind <> TrailingToken) AND (Token.Kind <> lexerKindEnd) DO WHILE (token.Kind <> TrailingToken) AND (token.Kind <> lexerKindEnd) DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := 0;
Write(' '); IF token.Kind = lexerKindNull THEN
Token := transpiler_lex(ALexer) WriteString('NIL ');
written_bytes := 1
END;
IF token.Kind = lexerKindOr THEN
WriteString('OR ');
written_bytes := 1
END;
IF token.Kind = lexerKindAnd THEN
WriteString('AND ');
written_bytes := 1
END;
IF token.Kind = lexerKindNot THEN
WriteString('NOT ');
written_bytes := 1
END;
IF written_bytes = 0 THEN
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Write(' ')
END;
token := transpiler_lex(lexer)
END END
END transpile_expression; END transpile_expression;
PROCEDURE transpile_if_statement(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_if_statement(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString(' IF '); WriteString(' IF ');
transpile_expression(AContext, ALexer, lexerKindThen); transpile_expression(context, lexer, lexerKindThen);
WriteString('THEN'); WriteString('THEN');
WriteLn(); WriteLn();
transpile_statements(AContext, ALexer); transpile_statements(context, lexer);
WriteString(' END'); WriteString(' END');
Token := transpiler_lex(ALexer) token := transpiler_lex(lexer)
END transpile_if_statement; END transpile_if_statement;
PROCEDURE transpile_while_statement(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_while_statement(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString(' WHILE '); WriteString(' WHILE ');
transpile_expression(AContext, ALexer, lexerKindDo); transpile_expression(context, lexer, lexerKindDo);
WriteString('DO'); WriteString('DO');
WriteLn(); WriteLn();
transpile_statements(AContext, ALexer); transpile_statements(context, lexer);
WriteString(' END'); WriteString(' END');
Token := transpiler_lex(ALexer) Token := transpiler_lex(lexer)
END transpile_while_statement; END transpile_while_statement;
PROCEDURE transpile_assignment_statement(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_assignment_statement(context: PTranspilerContext; lexer: PLexer);
BEGIN BEGIN
WriteString(' := '); WriteString(' := ');
transpile_expression(AContext, ALexer, lexerKindSemicolon); transpile_expression(context, lexer, lexerKindSemicolon);
END transpile_assignment_statement; END transpile_assignment_statement;
PROCEDURE transpile_call_statement(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_call_statement(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString('('); WriteString('(');
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WHILE (Token.Kind <> lexerKindSemicolon) AND (Token.Kind <> lexerKindEnd) DO WHILE (Token.Kind <> lexerKindSemicolon) AND (Token.Kind <> lexerKindEnd) DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer) Token := transpiler_lex(lexer)
END END
END transpile_call_statement; END transpile_call_statement;
PROCEDURE transpile_return_statement(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_return_statement(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
WriteString(' RETURN '); WriteString(' RETURN ');
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer) Token := transpiler_lex(lexer)
END transpile_return_statement; END transpile_return_statement;
PROCEDURE transpile_statement(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_statement(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
IF Token.Kind = lexerKindIf THEN IF token.Kind = lexerKindIf THEN
transpile_if_statement(AContext, ALexer) transpile_if_statement(context, lexer)
END; END;
IF Token.Kind = lexerKindWhile THEN IF token.Kind = lexerKindWhile THEN
transpile_while_statement(AContext, ALexer) transpile_while_statement(context, lexer)
END; END;
IF Token.Kind = lexerKindReturn THEN IF token.Kind = lexerKindReturn THEN
transpile_return_statement(AContext, ALexer) transpile_return_statement(context, lexer)
END; END;
IF Token.Kind = lexerKindIdentifier THEN IF token.Kind = lexerKindIdentifier THEN
WriteString(' '); WriteString(' ');
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WHILE Token.Kind = lexerKindLeftSquare DO WHILE token.Kind = lexerKindLeftSquare DO
Write('['); Write('[');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WHILE Token.Kind <> lexerKindRightSquare DO WHILE token.Kind <> lexerKindRightSquare DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer) token := transpiler_lex(lexer)
END; END;
Write(']'); Write(']');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
END; END;
IF Token.Kind = lexerKindHat THEN IF token.Kind = lexerKindHat THEN
Write('^'); Write('^');
Token := transpiler_lex(ALexer) token := transpiler_lex(lexer)
END; END;
IF Token.Kind = lexerKindDot THEN IF token.Kind = lexerKindDot THEN
Write('.'); Write('.');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
END; END;
IF Token.Kind = lexerKindHat THEN IF token.Kind = lexerKindHat THEN
Write('^'); Write('^');
Token := transpiler_lex(ALexer) token := transpiler_lex(lexer)
END; END;
WHILE Token.Kind = lexerKindLeftSquare DO WHILE token.Kind = lexerKindLeftSquare DO
Write('['); Write('[');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
WHILE Token.Kind <> lexerKindRightSquare DO WHILE token.Kind <> lexerKindRightSquare DO
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start); written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
Token := transpiler_lex(ALexer) token := transpiler_lex(lexer)
END; END;
Write(']'); Write(']');
Token := transpiler_lex(ALexer); token := transpiler_lex(lexer);
END; END;
IF Token.Kind = lexerKindAssignment THEN IF token.Kind = lexerKindAssignment THEN
transpile_assignment_statement(AContext, ALexer) transpile_assignment_statement(context, lexer)
END; END;
IF Token.Kind = lexerKindLeftParen THEN IF token.Kind = lexerKindLeftParen THEN
transpile_call_statement(AContext, ALexer) transpile_call_statement(context, lexer)
END END
END END
END transpile_statement; END transpile_statement;
PROCEDURE transpile_statements(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_statements(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
BEGIN BEGIN
Token := lexer_current(ALexer); Token := lexer_current(lexer);
WHILE Token.Kind <> lexerKindEnd DO WHILE Token.Kind <> lexerKindEnd DO
transpile_statement(AContext, ALexer); transpile_statement(context, lexer);
Token := lexer_current(ALexer); Token := lexer_current(lexer);
IF Token.Kind = lexerKindSemicolon THEN IF Token.Kind = lexerKindSemicolon THEN
Write(';') Write(';')
@ -559,53 +576,53 @@ BEGIN
WriteLn() WriteLn()
END END
END transpile_statements; END transpile_statements;
PROCEDURE transpile_statement_part(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_statement_part(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
BEGIN BEGIN
Token := lexer_current(ALexer); Token := lexer_current(lexer);
IF Token.Kind = lexerKindBegin THEN IF Token.Kind = lexerKindBegin THEN
WriteString('BEGIN'); WriteString('BEGIN');
WriteLn(); WriteLn();
transpile_statements(AContext, ALexer) transpile_statements(context, lexer)
END END
END transpile_statement_part; END transpile_statement_part;
PROCEDURE transpile_procedure_declaration(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_procedure_declaration(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
SeenPart: BOOLEAN; seen_part: BOOLEAN;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
BEGIN BEGIN
Token := transpile_procedure_heading(AContext, ALexer); Token := transpile_procedure_heading(context, lexer);
SeenPart := transpile_constant_part(AContext, ALexer); seen_part := transpile_constant_part(context, lexer);
SeenPart := transpile_variable_part(AContext, ALexer); seen_part := transpile_variable_part(context, lexer);
transpile_statement_part(AContext, ALexer); transpile_statement_part(context, lexer);
WriteString('END '); WriteString('END ');
WrittenBytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2])); written_bytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2]));
Token := transpiler_lex(ALexer); Token := transpiler_lex(lexer);
write_semicolon(); write_semicolon();
Token := transpiler_lex(ALexer) Token := transpiler_lex(lexer)
END transpile_procedure_declaration; END transpile_procedure_declaration;
PROCEDURE transpile_procedure_part(AContext: PTranspilerContext; ALexer: PLexer); PROCEDURE transpile_procedure_part(context: PTranspilerContext; lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
BEGIN BEGIN
Token := lexer_current(ALexer); Token := lexer_current(lexer);
WHILE Token.Kind = lexerKindProc DO WHILE Token.Kind = lexerKindProc DO
transpile_procedure_declaration(AContext, ALexer); transpile_procedure_declaration(context, lexer);
Token := lexer_current(ALexer); Token := lexer_current(lexer);
WriteLn() WriteLn()
END END
END transpile_procedure_part; END transpile_procedure_part;
PROCEDURE transpile(ALexer: PLexer); PROCEDURE transpile(lexer: PLexer);
VAR VAR
Token: LexerToken; Token: LexerToken;
WrittenBytes: CARDINAL; written_bytes: CARDINAL;
Context: TranspilerContext; Context: TranspilerContext;
BEGIN BEGIN
transpile_module(ADR(Context), ALexer) transpile_module(ADR(Context), lexer)
END transpile; END transpile;
END Transpiler. END Transpiler.