Shorten the array syntax
This commit is contained in:
parent
bd41736697
commit
4eccc147ba
GPG Key ID:
A27FDC1E8EE902C0
12
Rakefile
12
Rakefile
@ -104,16 +104,20 @@ task :backport do
|
||||
source
|
||||
.gsub(/^(var|type|const|begin)/) { |match| match.upcase }
|
||||
.gsub(/^[[:alnum:]]* ?module/) { |match| match.upcase }
|
||||
.gsub(/\brecord\b/) { |match| match.upcase }
|
||||
.gsub(/proc(\(| )/, 'PROCEDURE\1')
|
||||
.gsub(/\b(record|nil|or)\b/) { |match| match.upcase }
|
||||
.gsub(/proc\(/, 'PROCEDURE(')
|
||||
.gsub(/ & /, ' AND ')
|
||||
.gsub(/([[:space:]]*)end(;?)$/, '\1END\2')
|
||||
.gsub(/^([[:space:]]*)(while|return|if)\b/) { |match| match.upcase }
|
||||
.gsub(/^from ([[:alnum:]]+) import/, 'FROM \1 IMPORT')
|
||||
.gsub(/ \^([[:alnum:]])/, ' POINTER TO \1')
|
||||
.gsub(/(then|do)$/) { |match| match.upcase }
|
||||
.gsub(/(:|=) \[([[:digit:]]+)\]/, '\1 ARRAY[1..\2] OF ')
|
||||
.each_line do |line|
|
||||
if line.start_with? 'PROCEDURE'
|
||||
current_procedure = line[10...line.index('(')]
|
||||
if line.start_with? 'proc'
|
||||
current_procedure = line[5...line.index('(')]
|
||||
|
||||
line = 'PROCEDURE ' + line[5..].gsub(',', ';')
|
||||
elsif line.start_with?('END;') && !current_procedure.nil?
|
||||
line = "END #{current_procedure};"
|
||||
current_proceure = nil
|
||||
|
||||
@ -7,12 +7,12 @@ from Lexer import Lexer, lexer_destroy, lexer_initialize;
|
||||
from Transpiler import transpile;
|
||||
|
||||
var
|
||||
ALexer: Lexer;
|
||||
lexer: Lexer;
|
||||
|
||||
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.
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -13,17 +13,17 @@ type
|
||||
end;
|
||||
|
||||
(* Calls lexer_lex() but skips the comments. *)
|
||||
proc transpiler_lex(ALexer: PLexer): LexerToken;
|
||||
proc transpiler_lex(lexer: PLexer): LexerToken;
|
||||
var
|
||||
Result: LexerToken;
|
||||
result: LexerToken;
|
||||
begin
|
||||
Result := lexer_lex(ALexer);
|
||||
result := lexer_lex(lexer);
|
||||
|
||||
while Result.Kind = lexerKindComment do
|
||||
Result := lexer_lex(ALexer)
|
||||
while result.Kind = lexerKindComment do
|
||||
result := lexer_lex(lexer)
|
||||
end;
|
||||
|
||||
return Result
|
||||
return result
|
||||
end;
|
||||
|
||||
(* Write a semicolon followed by a newline. *)
|
||||
@ -33,552 +33,569 @@ begin
|
||||
WriteLn()
|
||||
end;
|
||||
|
||||
proc transpile_import(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_import(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
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 ');
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
while Token.Kind <> lexerKindSemicolon do
|
||||
token := transpiler_lex(lexer);
|
||||
while token.Kind <> lexerKindSemicolon do
|
||||
WriteString(', ');
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer)
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
write_semicolon();
|
||||
Token := transpiler_lex(ALexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
|
||||
proc transpile_import_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_import_part(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
begin
|
||||
Token := lexer_current(ALexer);
|
||||
token := lexer_current(lexer);
|
||||
|
||||
while Token.Kind = lexerKindFrom do
|
||||
transpile_import(AContext, ALexer);
|
||||
Token := lexer_current(ALexer)
|
||||
while token.Kind = lexerKindFrom do
|
||||
transpile_import(context, lexer);
|
||||
token := lexer_current(lexer)
|
||||
end;
|
||||
WriteLn()
|
||||
end;
|
||||
|
||||
proc transpile_constant(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_constant(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := lexer_current(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := lexer_current(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
WriteString(' = ');
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
write_semicolon()
|
||||
end;
|
||||
|
||||
proc transpile_constant_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
proc transpile_constant_part(context: PTranspilerContext, lexer: PLexer): BOOLEAN;
|
||||
var
|
||||
Token: LexerToken;
|
||||
Result: BOOLEAN;
|
||||
result: BOOLEAN;
|
||||
begin
|
||||
Token := lexer_current(ALexer);
|
||||
Result := Token.Kind = lexerKindConst;
|
||||
Token := lexer_current(lexer);
|
||||
result := Token.Kind = lexerKindConst;
|
||||
|
||||
if Result then
|
||||
if result then
|
||||
WriteString('CONST');
|
||||
WriteLn();
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
transpile_constant(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer)
|
||||
transpile_constant(context, lexer);
|
||||
Token := transpiler_lex(lexer)
|
||||
end
|
||||
end;
|
||||
return Result
|
||||
return result
|
||||
end;
|
||||
|
||||
proc transpile_module(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_module(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
|
||||
if Token.Kind = lexerKindDefinition then
|
||||
WriteString('DEFINITION ');
|
||||
Token := transpiler_lex(ALexer)
|
||||
Token := transpiler_lex(lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindImplementation then
|
||||
WriteString('IMPLEMENTATION ');
|
||||
Token := transpiler_lex(ALexer)
|
||||
Token := transpiler_lex(lexer)
|
||||
end;
|
||||
WriteString('MODULE ');
|
||||
|
||||
(* Write the module name and end the line with a semicolon and newline. *)
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
write_semicolon();
|
||||
WriteLn();
|
||||
|
||||
(* Write the module body. *)
|
||||
Token := transpiler_lex(ALexer);
|
||||
transpile_import_part(AContext, ALexer);
|
||||
if transpile_constant_part(AContext, ALexer) then
|
||||
Token := transpiler_lex(lexer);
|
||||
transpile_import_part(context, lexer);
|
||||
if transpile_constant_part(context, lexer) then
|
||||
WriteLn()
|
||||
end;
|
||||
transpile_type_part(AContext, ALexer);
|
||||
if transpile_variable_part(AContext, ALexer) then
|
||||
transpile_type_part(context, lexer);
|
||||
if transpile_variable_part(context, lexer) then
|
||||
WriteLn()
|
||||
end;
|
||||
transpile_procedure_part(AContext, ALexer);
|
||||
transpile_statement_part(AContext, ALexer);
|
||||
transpile_procedure_part(context, lexer);
|
||||
transpile_statement_part(context, lexer);
|
||||
|
||||
WriteString('END ');
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
Write('.');
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
WriteLn()
|
||||
end;
|
||||
|
||||
proc transpile_type_fields(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_type_fields(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
|
||||
while Token.Kind <> lexerKindEnd do
|
||||
WriteString(' ');
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
Token := transpiler_lex(lexer);
|
||||
WriteString(': ');
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
transpile_type_expression(context, lexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
Write(';')
|
||||
end;
|
||||
WriteLn()
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile_record_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_record_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
WriteString('RECORD');
|
||||
WriteLn();
|
||||
transpile_type_fields(AContext, ALexer);
|
||||
transpile_type_fields(context, lexer);
|
||||
WriteString(' END')
|
||||
end;
|
||||
|
||||
proc transpile_pointer_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_pointer_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := lexer_current(ALexer);
|
||||
Token := lexer_current(lexer);
|
||||
WriteString('POINTER TO ');
|
||||
if Token.Kind = lexerKindPointer then
|
||||
Token := transpiler_lex(ALexer)
|
||||
Token := transpiler_lex(lexer)
|
||||
end;
|
||||
transpile_type_expression(AContext, ALexer)
|
||||
transpile_type_expression(context, lexer)
|
||||
end;
|
||||
|
||||
proc transpile_array_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_array_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
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
|
||||
Write('[');
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString('..');
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer);
|
||||
Write(']');
|
||||
Token := transpiler_lex(ALexer)
|
||||
WriteString('[1..');
|
||||
Token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
Token := transpiler_lex(lexer);
|
||||
Write(']')
|
||||
end;
|
||||
WriteString(' OF ');
|
||||
transpile_type_expression(AContext, ALexer)
|
||||
transpile_type_expression(context, lexer)
|
||||
end;
|
||||
|
||||
proc transpile_enumeration_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_enumeration_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString('(');
|
||||
WriteLn();
|
||||
WriteString(' ');
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
|
||||
while Token.Kind = lexerKindComma do
|
||||
Write(',');
|
||||
WriteLn();
|
||||
WriteString(' ');
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer)
|
||||
Token := transpiler_lex(lexer)
|
||||
end;
|
||||
WriteLn();
|
||||
WriteString(' )')
|
||||
end;
|
||||
|
||||
proc transpile_union_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_union_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
end;
|
||||
|
||||
proc transpile_procedure_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_procedure_type(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
WriteString('PROCEDURE(');
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
|
||||
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
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
WriteString(', ')
|
||||
end
|
||||
end;
|
||||
Write(')')
|
||||
end;
|
||||
|
||||
proc transpile_type_expression(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_type_expression(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
if Token.Kind = lexerKindRecord then
|
||||
transpile_record_type(AContext, ALexer)
|
||||
transpile_record_type(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindLeftParen then
|
||||
transpile_enumeration_type(AContext, ALexer)
|
||||
transpile_enumeration_type(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindArray then
|
||||
transpile_array_type(AContext, ALexer)
|
||||
if (Token.Kind = lexerKindArray) or (Token.Kind = lexerKindLeftSquare) then
|
||||
transpile_array_type(context, lexer)
|
||||
end;
|
||||
if (Token.Kind = lexerKindPointer) OR (Token.Kind = lexerKindHat) then
|
||||
transpile_pointer_type(AContext, ALexer)
|
||||
if Token.Kind = lexerKindHat then
|
||||
transpile_pointer_type(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindProc then
|
||||
transpile_procedure_type(AContext, ALexer)
|
||||
transpile_procedure_type(context, lexer)
|
||||
end;
|
||||
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;
|
||||
|
||||
proc transpile_type_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_type_declaration(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := lexer_current(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := lexer_current(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
WriteString(' = ');
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
transpile_type_expression(context, lexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
write_semicolon();
|
||||
end;
|
||||
|
||||
proc transpile_type_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_type_part(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
token: LexerToken;
|
||||
begin
|
||||
Token := lexer_current(ALexer);
|
||||
token := lexer_current(lexer);
|
||||
|
||||
if Token.Kind = lexerKindType then
|
||||
if token.Kind = lexerKindType then
|
||||
WriteString('TYPE');
|
||||
WriteLn();
|
||||
Token := transpiler_lex(ALexer);
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
transpile_type_declaration(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer)
|
||||
while token.Kind = lexerKindIdentifier do
|
||||
transpile_type_declaration(context, lexer);
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
WriteLn()
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile_variable_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_variable_declaration(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := lexer_current(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := lexer_current(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
WriteString(': ');
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
transpile_type_expression(context, lexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
write_semicolon()
|
||||
end;
|
||||
|
||||
proc transpile_variable_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
proc transpile_variable_part(context: PTranspilerContext, lexer: PLexer): BOOLEAN;
|
||||
var
|
||||
Token: LexerToken;
|
||||
Result: BOOLEAN;
|
||||
result: BOOLEAN;
|
||||
begin
|
||||
Token := lexer_current(ALexer);
|
||||
Result := Token.Kind = lexerKindVar;
|
||||
Token := lexer_current(lexer);
|
||||
result := Token.Kind = lexerKindVar;
|
||||
|
||||
if Result then
|
||||
if result then
|
||||
WriteString('VAR');
|
||||
WriteLn();
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
transpile_variable_declaration(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer)
|
||||
transpile_variable_declaration(context, lexer);
|
||||
Token := transpiler_lex(lexer)
|
||||
end
|
||||
end;
|
||||
return Result
|
||||
return result
|
||||
end;
|
||||
|
||||
proc transpile_procedure_heading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken;
|
||||
proc transpile_procedure_heading(context: PTranspilerContext, lexer: PLexer): LexerToken;
|
||||
var
|
||||
Token: LexerToken;
|
||||
Result: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
token: LexerToken;
|
||||
result: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString('PROCEDURE ');
|
||||
|
||||
Result := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
result := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
token := transpiler_lex(lexer);
|
||||
Write('(');
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
while Token.Kind <> lexerKindRightParen do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
token := transpiler_lex(lexer);
|
||||
while token.Kind <> lexerKindRightParen do
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
token := transpiler_lex(lexer);
|
||||
WriteString(': ');
|
||||
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
transpile_type_expression(context, lexer);
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
token := transpiler_lex(lexer);
|
||||
if (token.Kind = lexerKindSemicolon) or (token.Kind = lexerKindComma) then
|
||||
WriteString('; ');
|
||||
Token := transpiler_lex(ALexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end
|
||||
end;
|
||||
WriteString(')');
|
||||
Token := transpiler_lex(ALexer);
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
(* Check for the return type and write it. *)
|
||||
if Token.Kind = lexerKindColon then
|
||||
if token.Kind = lexerKindColon then
|
||||
WriteString(': ');
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer)
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
Token := transpiler_lex(ALexer);
|
||||
token := transpiler_lex(lexer);
|
||||
write_semicolon();
|
||||
|
||||
return Result
|
||||
return result
|
||||
end;
|
||||
|
||||
proc transpile_expression(AContext: PTranspilerContext; ALexer: PLexer; TrailingToken: LexerKind);
|
||||
proc transpile_expression(context: PTranspilerContext, lexer: PLexer, TrailingToken: LexerKind);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(ALexer);
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
while (Token.Kind <> TrailingToken) AND (Token.Kind <> lexerKindEnd) do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Write(' ');
|
||||
Token := transpiler_lex(ALexer)
|
||||
while (token.Kind <> TrailingToken) & (token.Kind <> lexerKindEnd) do
|
||||
written_bytes := 0;
|
||||
if token.Kind = lexerKindNull then
|
||||
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;
|
||||
|
||||
proc transpile_if_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_if_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' IF ');
|
||||
transpile_expression(AContext, ALexer, lexerKindThen);
|
||||
transpile_expression(context, lexer, lexerKindThen);
|
||||
|
||||
WriteString('THEN');
|
||||
WriteLn();
|
||||
transpile_statements(AContext, ALexer);
|
||||
transpile_statements(context, lexer);
|
||||
WriteString(' END');
|
||||
Token := transpiler_lex(ALexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
|
||||
proc transpile_while_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_while_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' WHILE ');
|
||||
transpile_expression(AContext, ALexer, lexerKindDo);
|
||||
transpile_expression(context, lexer, lexerKindDo);
|
||||
|
||||
WriteString('DO');
|
||||
WriteLn();
|
||||
transpile_statements(AContext, ALexer);
|
||||
transpile_statements(context, lexer);
|
||||
WriteString(' END');
|
||||
Token := transpiler_lex(ALexer)
|
||||
Token := transpiler_lex(lexer)
|
||||
end;
|
||||
|
||||
proc transpile_assignment_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_assignment_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
begin
|
||||
WriteString(' := ');
|
||||
transpile_expression(AContext, ALexer, lexerKindSemicolon);
|
||||
transpile_expression(context, lexer, lexerKindSemicolon);
|
||||
end;
|
||||
|
||||
proc transpile_call_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_call_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString('(');
|
||||
Token := transpiler_lex(ALexer);
|
||||
Token := transpiler_lex(lexer);
|
||||
|
||||
while (Token.Kind <> lexerKindSemicolon) AND (Token.Kind <> lexerKindEnd) do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer)
|
||||
while (Token.Kind <> lexerKindSemicolon) & (Token.Kind <> lexerKindEnd) do
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
Token := transpiler_lex(lexer)
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile_return_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_return_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' RETURN ');
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer)
|
||||
Token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
Token := transpiler_lex(lexer)
|
||||
end;
|
||||
|
||||
proc transpile_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_statement(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
token: LexerToken;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(ALexer);
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
if Token.Kind = lexerKindIf then
|
||||
transpile_if_statement(AContext, ALexer)
|
||||
if token.Kind = lexerKindIf then
|
||||
transpile_if_statement(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindWhile then
|
||||
transpile_while_statement(AContext, ALexer)
|
||||
if token.Kind = lexerKindWhile then
|
||||
transpile_while_statement(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindReturn then
|
||||
transpile_return_statement(AContext, ALexer)
|
||||
if token.Kind = lexerKindReturn then
|
||||
transpile_return_statement(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindIdentifier then
|
||||
if token.Kind = lexerKindIdentifier then
|
||||
WriteString(' ');
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
token := transpiler_lex(lexer);
|
||||
|
||||
while Token.Kind = lexerKindLeftSquare do
|
||||
while token.Kind = lexerKindLeftSquare do
|
||||
Write('[');
|
||||
Token := transpiler_lex(ALexer);
|
||||
while Token.Kind <> lexerKindRightSquare do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer)
|
||||
token := transpiler_lex(lexer);
|
||||
while token.Kind <> lexerKindRightSquare do
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
Write(']');
|
||||
Token := transpiler_lex(ALexer);
|
||||
token := transpiler_lex(lexer);
|
||||
end;
|
||||
if Token.Kind = lexerKindHat then
|
||||
if token.Kind = lexerKindHat then
|
||||
Write('^');
|
||||
Token := transpiler_lex(ALexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindDot then
|
||||
if token.Kind = lexerKindDot then
|
||||
Write('.');
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer);
|
||||
token := transpiler_lex(lexer);
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
token := transpiler_lex(lexer);
|
||||
end;
|
||||
if Token.Kind = lexerKindHat then
|
||||
if token.Kind = lexerKindHat then
|
||||
Write('^');
|
||||
Token := transpiler_lex(ALexer)
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
while Token.Kind = lexerKindLeftSquare do
|
||||
while token.Kind = lexerKindLeftSquare do
|
||||
Write('[');
|
||||
Token := transpiler_lex(ALexer);
|
||||
while Token.Kind <> lexerKindRightSquare do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := transpiler_lex(ALexer)
|
||||
token := transpiler_lex(lexer);
|
||||
while token.Kind <> lexerKindRightSquare do
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
token := transpiler_lex(lexer)
|
||||
end;
|
||||
Write(']');
|
||||
Token := transpiler_lex(ALexer);
|
||||
token := transpiler_lex(lexer);
|
||||
end;
|
||||
|
||||
if Token.Kind = lexerKindAssignment then
|
||||
transpile_assignment_statement(AContext, ALexer)
|
||||
if token.Kind = lexerKindAssignment then
|
||||
transpile_assignment_statement(context, lexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindLeftParen then
|
||||
transpile_call_statement(AContext, ALexer)
|
||||
if token.Kind = lexerKindLeftParen then
|
||||
transpile_call_statement(context, lexer)
|
||||
end
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile_statements(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_statements(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := lexer_current(ALexer);
|
||||
Token := lexer_current(lexer);
|
||||
|
||||
while Token.Kind <> lexerKindEnd do
|
||||
transpile_statement(AContext, ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
transpile_statement(context, lexer);
|
||||
Token := lexer_current(lexer);
|
||||
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
Write(';')
|
||||
@ -587,57 +604,57 @@ begin
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile_statement_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_statement_part(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := lexer_current(ALexer);
|
||||
Token := lexer_current(lexer);
|
||||
if Token.Kind = lexerKindBegin then
|
||||
WriteString('BEGIN');
|
||||
WriteLn();
|
||||
transpile_statements(AContext, ALexer)
|
||||
transpile_statements(context, lexer)
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile_procedure_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_procedure_declaration(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
SeenPart: BOOLEAN;
|
||||
WrittenBytes: CARDINAL;
|
||||
seen_part: BOOLEAN;
|
||||
written_bytes: CARDINAL;
|
||||
begin
|
||||
Token := transpile_procedure_heading(AContext, ALexer);
|
||||
SeenPart := transpile_constant_part(AContext, ALexer);
|
||||
SeenPart := transpile_variable_part(AContext, ALexer);
|
||||
transpile_statement_part(AContext, ALexer);
|
||||
Token := transpile_procedure_heading(context, lexer);
|
||||
seen_part := transpile_constant_part(context, lexer);
|
||||
seen_part := transpile_variable_part(context, lexer);
|
||||
transpile_statement_part(context, lexer);
|
||||
|
||||
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();
|
||||
Token := transpiler_lex(ALexer)
|
||||
Token := transpiler_lex(lexer)
|
||||
end;
|
||||
|
||||
proc transpile_procedure_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_procedure_part(context: PTranspilerContext, lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := lexer_current(ALexer);
|
||||
Token := lexer_current(lexer);
|
||||
|
||||
while Token.Kind = lexerKindProc do
|
||||
transpile_procedure_declaration(AContext, ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
transpile_procedure_declaration(context, lexer);
|
||||
Token := lexer_current(lexer);
|
||||
WriteLn()
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile(ALexer: PLexer);
|
||||
proc transpile(lexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
written_bytes: CARDINAL;
|
||||
Context: TranspilerContext;
|
||||
begin
|
||||
transpile_module(ADR(Context), ALexer)
|
||||
transpile_module(ADR(Context), lexer)
|
||||
end;
|
||||
|
||||
end Transpiler.
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user