Make procedure name after the end
This commit is contained in:
@ -4,7 +4,7 @@ from FIO import WriteNBytes, StdOut;
|
||||
from SYSTEM import ADR, ADDRESS;
|
||||
|
||||
from Terminal import Write, WriteLn, WriteString;
|
||||
from Lexer import Lexer, LexerToken, LexerCurrent, LexerLex, LexerKind;
|
||||
from Lexer import Lexer, LexerToken, lexer_current, lexer_lex, LexerKind;
|
||||
|
||||
type
|
||||
PTranspilerContext = ^TranspilerContext;
|
||||
@ -12,224 +12,228 @@ type
|
||||
Indentation: CARDINAL
|
||||
end;
|
||||
|
||||
(* Calls LexerLex() but skips the comments. *)
|
||||
proc TranspilerLex(ALexer: PLexer): LexerToken;
|
||||
(* Calls lexer_lex() but skips the comments. *)
|
||||
proc transpiler_lex(ALexer: PLexer): LexerToken;
|
||||
var
|
||||
Result: LexerToken;
|
||||
begin
|
||||
Result := LexerLex(ALexer);
|
||||
Result := lexer_lex(ALexer);
|
||||
|
||||
while Result.Kind = lexerKindComment do
|
||||
Result := LexerLex(ALexer)
|
||||
Result := lexer_lex(ALexer)
|
||||
end;
|
||||
|
||||
return Result
|
||||
END TranspilerLex;
|
||||
end;
|
||||
|
||||
(* Write a semicolon followed by a newline. *)
|
||||
proc WriteSemicolon();
|
||||
proc write_semicolon();
|
||||
begin
|
||||
WriteString(';');
|
||||
WriteLn()
|
||||
END WriteSemicolon;
|
||||
end;
|
||||
|
||||
proc TranspileImport(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_import(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString('FROM ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(' IMPORT ');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
while Token.Kind <> lexerKindSemicolon do
|
||||
WriteString(', ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
WriteSemicolon();
|
||||
Token := TranspilerLex(ALexer)
|
||||
END TranspileImport;
|
||||
write_semicolon();
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileImportPart(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_import_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindFrom do
|
||||
TranspileImport(AContext, ALexer);
|
||||
Token := LexerCurrent(ALexer)
|
||||
transpile_import(AContext, ALexer);
|
||||
Token := lexer_current(ALexer)
|
||||
end;
|
||||
WriteLn()
|
||||
END TranspileImportPart;
|
||||
end;
|
||||
|
||||
proc TranspileConstant(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_constant(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(' = ');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon()
|
||||
END TranspileConstant;
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon()
|
||||
end;
|
||||
|
||||
proc TranspileConstantPart(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
proc transpile_constant_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
var
|
||||
Token: LexerToken;
|
||||
Result: BOOLEAN;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
Result := Token.Kind = lexerKindConst;
|
||||
|
||||
if Result then
|
||||
WriteString('CONST');
|
||||
WriteLn();
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
TranspileConstant(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer)
|
||||
transpile_constant(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer)
|
||||
end
|
||||
end;
|
||||
return Result
|
||||
END TranspileConstantPart;
|
||||
end;
|
||||
|
||||
proc TranspileModule(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_module(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
if Token.Kind = lexerKindDefinition then
|
||||
WriteString('DEFINITION ');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindImplementation then
|
||||
WriteString('IMPLEMENTATION ');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
WriteString('MODULE ');
|
||||
|
||||
(* Write the module name and end the line with a semicolon and newline. *)
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon();
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon();
|
||||
WriteLn();
|
||||
|
||||
(* Write the module body. *)
|
||||
Token := TranspilerLex(ALexer);
|
||||
TranspileImportPart(AContext, ALexer);
|
||||
if TranspileConstantPart(AContext, ALexer) then
|
||||
Token := transpiler_lex(ALexer);
|
||||
transpile_import_part(AContext, ALexer);
|
||||
if transpile_constant_part(AContext, ALexer) then
|
||||
WriteLn()
|
||||
end;
|
||||
TranspileTypePart(AContext, ALexer);
|
||||
if TranspileVariablePart(AContext, ALexer) then
|
||||
transpile_type_part(AContext, ALexer);
|
||||
if transpile_variable_part(AContext, ALexer) then
|
||||
WriteLn()
|
||||
end;
|
||||
TranspileProcedurePart(AContext, ALexer);
|
||||
transpile_procedure_part(AContext, ALexer);
|
||||
transpile_statement_part(AContext, ALexer);
|
||||
|
||||
Token := LexerCurrent(ALexer);
|
||||
while Token.Kind <> lexerKindEof do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
WriteLn();
|
||||
WriteString('END ');
|
||||
|
||||
Token := TranspilerLex(ALexer)
|
||||
end
|
||||
END TranspileModule;
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
proc TranspileTypeFields(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
Write('.');
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteLn()
|
||||
end;
|
||||
|
||||
proc transpile_type_fields(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind <> lexerKindEnd do
|
||||
WriteString(' ');
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(': ');
|
||||
TranspileTypeExpression(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer);
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
Write(';')
|
||||
end;
|
||||
WriteLn()
|
||||
end
|
||||
END TranspileTypeFields;
|
||||
end;
|
||||
|
||||
proc TranspileRecordType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_record_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
WriteString('RECORD');
|
||||
WriteLn();
|
||||
TranspileTypeFields(AContext, ALexer);
|
||||
transpile_type_fields(AContext, ALexer);
|
||||
WriteString(' END')
|
||||
END TranspileRecordType;
|
||||
end;
|
||||
|
||||
proc TranspilePointerType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_pointer_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
WriteString('POINTER TO ');
|
||||
if Token.Kind = lexerKindPointer then
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
TranspileTypeExpression(AContext, ALexer)
|
||||
END TranspilePointerType;
|
||||
transpile_type_expression(AContext, ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileArrayType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_array_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString('ARRAY');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
if Token.Kind <> lexerKindOf then
|
||||
Write('[');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString('..');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
Write(']');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
WriteString(' OF ');
|
||||
TranspileTypeExpression(AContext, ALexer)
|
||||
END TranspileArrayType;
|
||||
transpile_type_expression(AContext, ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileEnumerationType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_enumeration_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
@ -238,393 +242,402 @@ begin
|
||||
WriteLn();
|
||||
WriteString(' ');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindComma do
|
||||
Write(',');
|
||||
WriteLn();
|
||||
WriteString(' ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
WriteLn();
|
||||
WriteString(' )')
|
||||
END TranspileEnumerationType;
|
||||
end;
|
||||
|
||||
proc TranspileUnionType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_union_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
END TranspileUnionType;
|
||||
end;
|
||||
|
||||
proc TranspileProcedureType(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_procedure_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString('PROCEDURE(');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind <> lexerKindRightParen do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
if Token.Kind = lexerKindComma then
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(', ')
|
||||
end
|
||||
end;
|
||||
Write(')')
|
||||
END TranspileProcedureType;
|
||||
end;
|
||||
|
||||
proc TranspileTypeExpression(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_type_expression(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
if Token.Kind = lexerKindRecord then
|
||||
TranspileRecordType(AContext, ALexer)
|
||||
transpile_record_type(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindLeftParen then
|
||||
TranspileEnumerationType(AContext, ALexer)
|
||||
transpile_enumeration_type(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindArray then
|
||||
TranspileArrayType(AContext, ALexer)
|
||||
transpile_array_type(AContext, ALexer)
|
||||
end;
|
||||
if (Token.Kind = lexerKindPointer) OR (Token.Kind = lexerKindHat) then
|
||||
TranspilePointerType(AContext, ALexer)
|
||||
transpile_pointer_type(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindProc then
|
||||
TranspileProcedureType(AContext, ALexer)
|
||||
transpile_procedure_type(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindIdentifier then
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start)
|
||||
end
|
||||
END TranspileTypeExpression;
|
||||
end;
|
||||
|
||||
proc TranspileTypeDeclaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_type_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(' = ');
|
||||
TranspileTypeExpression(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon();
|
||||
END TranspileTypeDeclaration;
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon();
|
||||
end;
|
||||
|
||||
proc TranspileTypePart(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_type_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
|
||||
if Token.Kind = lexerKindType then
|
||||
WriteString('TYPE');
|
||||
WriteLn();
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
TranspileTypeDeclaration(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer)
|
||||
transpile_type_declaration(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
WriteLn()
|
||||
end
|
||||
END TranspileTypePart;
|
||||
end;
|
||||
|
||||
proc TranspileVariableDeclaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_variable_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' ');
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(': ');
|
||||
TranspileTypeExpression(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon()
|
||||
END TranspileVariableDeclaration;
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon()
|
||||
end;
|
||||
|
||||
proc TranspileVariablePart(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
proc transpile_variable_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
var
|
||||
Token: LexerToken;
|
||||
Result: BOOLEAN;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
Result := Token.Kind = lexerKindVar;
|
||||
|
||||
if Result then
|
||||
WriteString('VAR');
|
||||
WriteLn();
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindIdentifier do
|
||||
TranspileVariableDeclaration(AContext, ALexer);
|
||||
Token := TranspilerLex(ALexer)
|
||||
transpile_variable_declaration(AContext, ALexer);
|
||||
Token := transpiler_lex(ALexer)
|
||||
end
|
||||
end;
|
||||
return Result
|
||||
END TranspileVariablePart;
|
||||
end;
|
||||
|
||||
proc TranspileProcedureHeading(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_procedure_heading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken;
|
||||
var
|
||||
Token: LexerToken;
|
||||
Result: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString('PROCEDURE ');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Result := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
Write('(');
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
while Token.Kind <> lexerKindRightParen do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WriteString(': ');
|
||||
|
||||
TranspileTypeExpression(AContext, ALexer);
|
||||
transpile_type_expression(AContext, ALexer);
|
||||
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
WriteString('; ');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end
|
||||
end;
|
||||
WriteString(')');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
(* Check for the return type and write it. *)
|
||||
if Token.Kind = lexerKindColon then
|
||||
WriteString(': ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon()
|
||||
END TranspileProcedureHeading;
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon();
|
||||
|
||||
proc TranspileIfStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
return Result
|
||||
end;
|
||||
|
||||
proc transpile_expression(AContext: PTranspilerContext; ALexer: PLexer; TrailingToken: LexerKind);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while (Token.Kind <> TrailingToken) AND (Token.Kind <> lexerKindEnd) do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Write(' ');
|
||||
Token := transpiler_lex(ALexer)
|
||||
end
|
||||
end;
|
||||
|
||||
proc transpile_if_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' IF ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
transpile_expression(AContext, ALexer, lexerKindThen);
|
||||
|
||||
while Token.Kind <> lexerKindThen do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Write(' ');
|
||||
Token := TranspilerLex(ALexer)
|
||||
end;
|
||||
WriteString('THEN');
|
||||
WriteLn();
|
||||
TranspileStatements(AContext, ALexer);
|
||||
transpile_statements(AContext, ALexer);
|
||||
WriteString(' END');
|
||||
Token := TranspilerLex(ALexer)
|
||||
END TranspileIfStatement;
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileWhileStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_while_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' WHILE ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
transpile_expression(AContext, ALexer, lexerKindDo);
|
||||
|
||||
while Token.Kind <> lexerKindDo do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Write(' ');
|
||||
Token := TranspilerLex(ALexer)
|
||||
end;
|
||||
WriteString('DO');
|
||||
WriteLn();
|
||||
TranspileStatements(AContext, ALexer);
|
||||
transpile_statements(AContext, ALexer);
|
||||
WriteString(' END');
|
||||
Token := TranspilerLex(ALexer)
|
||||
END TranspileWhileStatement;
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileAssignmentStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
proc transpile_assignment_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
begin
|
||||
WriteString(' := ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
transpile_expression(AContext, ALexer, lexerKindSemicolon);
|
||||
end;
|
||||
|
||||
while (Token.Kind <> lexerKindSemicolon) AND (Token.Kind <> lexerKindEnd) do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Write(' ');
|
||||
Token := TranspilerLex(ALexer)
|
||||
end
|
||||
END TranspileAssignmentStatement;
|
||||
|
||||
proc TranspileCallStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_call_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString('(');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while (Token.Kind <> lexerKindSemicolon) AND (Token.Kind <> lexerKindEnd) do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end
|
||||
END TranspileCallStatement;
|
||||
end;
|
||||
|
||||
proc TranspileReturnStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_return_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
WriteString(' RETURN ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer)
|
||||
END TranspileReturnStatement;
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
|
||||
proc TranspileStatement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
if Token.Kind = lexerKindIf then
|
||||
TranspileIfStatement(AContext, ALexer)
|
||||
transpile_if_statement(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindWhile then
|
||||
TranspileWhileStatement(AContext, ALexer)
|
||||
transpile_while_statement(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindReturn then
|
||||
TranspileReturnStatement(AContext, ALexer)
|
||||
transpile_return_statement(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindIdentifier then
|
||||
WriteString(' ');
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindLeftSquare do
|
||||
Write('[');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
while Token.Kind <> lexerKindRightSquare do
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
Write(']');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
end;
|
||||
if Token.Kind = lexerKindHat then
|
||||
Write('^');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindDot then
|
||||
Write('.');
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
Token := transpiler_lex(ALexer);
|
||||
end;
|
||||
if Token.Kind = lexerKindHat then
|
||||
Write('^');
|
||||
Token := TranspilerLex(ALexer)
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
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)
|
||||
end;
|
||||
Write(']');
|
||||
Token := transpiler_lex(ALexer);
|
||||
end;
|
||||
|
||||
if Token.Kind = lexerKindAssignment then
|
||||
TranspileAssignmentStatement(AContext, ALexer)
|
||||
transpile_assignment_statement(AContext, ALexer)
|
||||
end;
|
||||
if Token.Kind = lexerKindLeftParen then
|
||||
TranspileCallStatement(AContext, ALexer)
|
||||
transpile_call_statement(AContext, ALexer)
|
||||
end
|
||||
end
|
||||
END TranspileStatement;
|
||||
end;
|
||||
|
||||
proc TranspileStatements(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_statements(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
|
||||
while Token.Kind <> lexerKindEnd do
|
||||
TranspileStatement(AContext, ALexer);
|
||||
Token := LexerCurrent(ALexer);
|
||||
transpile_statement(AContext, ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
|
||||
if Token.Kind = lexerKindSemicolon then
|
||||
Write(';')
|
||||
end;
|
||||
WriteLn()
|
||||
end
|
||||
END TranspileStatements;
|
||||
end;
|
||||
|
||||
proc TranspileStatementPart(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_statement_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
if Token.Kind = lexerKindBegin then
|
||||
WriteString('BEGIN');
|
||||
WriteLn();
|
||||
TranspileStatements(AContext, ALexer)
|
||||
transpile_statements(AContext, ALexer)
|
||||
end
|
||||
END TranspileStatementPart;
|
||||
end;
|
||||
|
||||
proc TranspileProcedureDeclaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
proc transpile_procedure_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
SeenPart: BOOLEAN;
|
||||
WrittenBytes: CARDINAL;
|
||||
begin
|
||||
TranspileProcedureHeading(AContext, ALexer);
|
||||
SeenPart := TranspileConstantPart(AContext, ALexer);
|
||||
SeenPart := TranspileVariablePart(AContext, ALexer);
|
||||
TranspileStatementPart(AContext, ALexer);
|
||||
WriteString('END ');
|
||||
Token := TranspilerLex(ALexer);
|
||||
WrittenBytes := WriteNBytes(StdOut, ADDRESS(ALexer^.Current - ALexer^.Start), ALexer^.Start);
|
||||
Token := TranspilerLex(ALexer);
|
||||
WriteSemicolon();
|
||||
Token := TranspilerLex(ALexer)
|
||||
END TranspileProcedureDeclaration;
|
||||
Token := transpile_procedure_heading(AContext, ALexer);
|
||||
SeenPart := transpile_constant_part(AContext, ALexer);
|
||||
SeenPart := transpile_variable_part(AContext, ALexer);
|
||||
transpile_statement_part(AContext, ALexer);
|
||||
|
||||
proc TranspileProcedurePart(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
WriteString('END ');
|
||||
WrittenBytes := WriteNBytes(StdOut, ORD(Token.identifierKind[1]), ADR(Token.identifierKind[2]));
|
||||
|
||||
Token := transpiler_lex(ALexer);
|
||||
write_semicolon();
|
||||
Token := transpiler_lex(ALexer)
|
||||
end;
|
||||
|
||||
proc transpile_procedure_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
begin
|
||||
Token := LexerCurrent(ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
|
||||
while Token.Kind = lexerKindProc do
|
||||
TranspileProcedureDeclaration(AContext, ALexer);
|
||||
Token := LexerCurrent(ALexer);
|
||||
transpile_procedure_declaration(AContext, ALexer);
|
||||
Token := lexer_current(ALexer);
|
||||
WriteLn()
|
||||
end
|
||||
END TranspileProcedurePart;
|
||||
end;
|
||||
|
||||
proc Transpile(ALexer: PLexer);
|
||||
proc transpile(ALexer: PLexer);
|
||||
var
|
||||
Token: LexerToken;
|
||||
WrittenBytes: CARDINAL;
|
||||
Context: TranspilerContext;
|
||||
begin
|
||||
TranspileModule(ADR(Context), ALexer)
|
||||
END Transpile;
|
||||
transpile_module(ADR(Context), ALexer)
|
||||
end;
|
||||
|
||||
END Transpiler.
|
||||
end Transpiler.
|
||||
|
||||
Reference in New Issue
Block a user