Shorten the array syntax
This commit is contained in:
parent
273e26b119
commit
15135f14d8
GPG Key ID:
A27FDC1E8EE902C0
@ -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.
|
||||
|
||||
761
source/Lexer.mod
761
source/Lexer.mod
File diff suppressed because it is too large
Load Diff
@ -13,17 +13,17 @@ TYPE
|
||||
END;
|
||||
|
||||
(* Calls lexer_lex() but skips the comments. *)
|
||||
PROCEDURE transpiler_lex(ALexer: PLexer): LexerToken;
|
||||
PROCEDURE 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 transpiler_lex;
|
||||
(* Write a semicolon followed by a newline. *)
|
||||
PROCEDURE write_semicolon();
|
||||
@ -31,527 +31,544 @@ BEGIN
|
||||
WriteString(';');
|
||||
WriteLn()
|
||||
END write_semicolon;
|
||||
PROCEDURE transpile_import(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_import;
|
||||
PROCEDURE transpile_import_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_import_part;
|
||||
PROCEDURE transpile_constant(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_constant;
|
||||
PROCEDURE transpile_constant_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
PROCEDURE 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 transpile_constant_part;
|
||||
PROCEDURE transpile_module(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_module;
|
||||
PROCEDURE transpile_type_fields(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_type_fields;
|
||||
PROCEDURE transpile_record_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_record_type;
|
||||
PROCEDURE transpile_pointer_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_pointer_type;
|
||||
PROCEDURE transpile_array_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_array_type;
|
||||
PROCEDURE transpile_enumeration_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_enumeration_type;
|
||||
PROCEDURE transpile_union_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE transpile_union_type(context: PTranspilerContext; lexer: PLexer);
|
||||
VAR
|
||||
Token: LexerToken;
|
||||
END transpile_union_type;
|
||||
PROCEDURE transpile_procedure_type(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_procedure_type;
|
||||
PROCEDURE transpile_type_expression(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_type_expression;
|
||||
PROCEDURE transpile_type_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_type_declaration;
|
||||
PROCEDURE transpile_type_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_type_part;
|
||||
PROCEDURE transpile_variable_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_variable_declaration;
|
||||
PROCEDURE transpile_variable_part(AContext: PTranspilerContext; ALexer: PLexer): BOOLEAN;
|
||||
PROCEDURE 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 transpile_variable_part;
|
||||
PROCEDURE transpile_procedure_heading(AContext: PTranspilerContext; ALexer: PLexer): LexerToken;
|
||||
PROCEDURE 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 transpile_procedure_heading;
|
||||
PROCEDURE transpile_expression(AContext: PTranspilerContext; ALexer: PLexer; TrailingToken: LexerKind);
|
||||
PROCEDURE 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) AND (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 transpile_expression;
|
||||
PROCEDURE transpile_if_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_if_statement;
|
||||
PROCEDURE transpile_while_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_while_statement;
|
||||
PROCEDURE transpile_assignment_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE transpile_assignment_statement(context: PTranspilerContext; lexer: PLexer);
|
||||
BEGIN
|
||||
WriteString(' := ');
|
||||
transpile_expression(AContext, ALexer, lexerKindSemicolon);
|
||||
transpile_expression(context, lexer, lexerKindSemicolon);
|
||||
END transpile_assignment_statement;
|
||||
PROCEDURE transpile_call_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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)
|
||||
written_bytes := WriteNBytes(StdOut, ADDRESS(lexer^.Current - lexer^.Start), lexer^.Start);
|
||||
Token := transpiler_lex(lexer)
|
||||
END
|
||||
END transpile_call_statement;
|
||||
PROCEDURE transpile_return_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_return_statement;
|
||||
PROCEDURE transpile_statement(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_statement;
|
||||
PROCEDURE transpile_statements(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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(';')
|
||||
@ -559,53 +576,53 @@ BEGIN
|
||||
WriteLn()
|
||||
END
|
||||
END transpile_statements;
|
||||
PROCEDURE transpile_statement_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_statement_part;
|
||||
PROCEDURE transpile_procedure_declaration(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_procedure_declaration;
|
||||
PROCEDURE transpile_procedure_part(AContext: PTranspilerContext; ALexer: PLexer);
|
||||
PROCEDURE 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 transpile_procedure_part;
|
||||
PROCEDURE transpile(ALexer: PLexer);
|
||||
PROCEDURE 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 transpile;
|
||||
END Transpiler.
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user