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:57:04 +02:00
parent bd41736697
commit 4eccc147ba
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
4 changed files with 677 additions and 655 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Rakefile
View File

@ -104,16 +104,20 @@ task :backport do
source source
.gsub(/^(var|type|const|begin)/) { |match| match.upcase } .gsub(/^(var|type|const|begin)/) { |match| match.upcase }
.gsub(/^[[:alnum:]]* ?module/) { |match| match.upcase } .gsub(/^[[:alnum:]]* ?module/) { |match| match.upcase }
.gsub(/\brecord\b/) { |match| match.upcase } .gsub(/\b(record|nil|or)\b/) { |match| match.upcase }
.gsub(/proc(\(| )/, 'PROCEDURE\1') .gsub(/proc\(/, 'PROCEDURE(')
.gsub(/ & /, ' AND ')
.gsub(/([[:space:]]*)end(;?)$/, '\1END\2') .gsub(/([[:space:]]*)end(;?)$/, '\1END\2')
.gsub(/^([[:space:]]*)(while|return|if)\b/) { |match| match.upcase } .gsub(/^([[:space:]]*)(while|return|if)\b/) { |match| match.upcase }
.gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT') .gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT')
.gsub(/ \^([[:alnum:]])/, ' POINTER TO \1') .gsub(/ \^([[:alnum:]])/, ' POINTER TO \1')
.gsub(/(then|do)$/) { |match| match.upcase } .gsub(/(then|do)$/) { |match| match.upcase }
.gsub(/(:|=) \[([[:digit:]]+)\]/, '\1 ARRAY[1..\2] OF ')
.each_line do |line| .each_line do |line|
if line.start_with? 'PROCEDURE' if line.start_with? 'proc'
current_procedure = line[10...line.index('(')] current_procedure = line[5...line.index('(')]
line = 'PROCEDURE ' + line[5..].gsub(',', ';')
elsif line.start_with?('END;') && !current_procedure.nil? elsif line.start_with?('END;') && !current_procedure.nil?
line = "END #{current_procedure};" line = "END #{current_procedure};"
current_proceure = nil current_proceure = nil

8
source/Compiler.elna
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.

767
source/Lexer.elna
View File

File diff suppressed because it is too large Load Diff

545
source/Transpiler.elna
View File

@ -13,17 +13,17 @@ type
end; end;
(* Calls lexer_lex() but skips the comments. *) (* Calls lexer_lex() but skips the comments. *)
proc transpiler_lex(ALexer: PLexer): LexerToken; proc 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; end;
(* Write a semicolon followed by a newline. *) (* Write a semicolon followed by a newline. *)
@ -33,552 +33,569 @@ begin
WriteLn() WriteLn()
end; end;
proc transpile_import(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_import_part(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_constant(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_constant_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN; proc 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; end;
proc transpile_module(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_type_fields(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_record_type(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_pointer_type(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_array_type(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_enumeration_type(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_union_type(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_union_type(context: PTranspilerContext, lexer: PLexer);
var var
Token: LexerToken; Token: LexerToken;
end; end;
proc transpile_procedure_type(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_type_expression(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_type_declaration(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_type_part(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_variable_declaration(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_variable_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN; proc 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; end;
proc transpile_procedure_heading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken; proc 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; end;
proc transpile_expression(AContext: PTranspilerContext; ALexer: PLexer; TrailingToken: LexerKind); proc 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) & (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; end;
proc transpile_if_statement(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_while_statement(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_assignment_statement(AContext: PTranspilerContext; ALexer: PLexer); proc transpile_assignment_statement(context: PTranspilerContext, lexer: PLexer);
begin begin
WriteString(' := '); WriteString(' := ');
transpile_expression(AContext, ALexer, lexerKindSemicolon); transpile_expression(context, lexer, lexerKindSemicolon);
end; end;
proc transpile_call_statement(AContext: PTranspilerContext; ALexer: PLexer); proc 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) & (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; end;
proc transpile_return_statement(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_statement(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_statements(AContext: PTranspilerContext; ALexer: PLexer); proc 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(';')
@ -587,57 +604,57 @@ begin
end end
end; end;
proc transpile_statement_part(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_procedure_declaration(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile_procedure_part(AContext: PTranspilerContext; ALexer: PLexer); proc 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; end;
proc transpile(ALexer: PLexer); proc 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; end;
end Transpiler. end Transpiler.