mmo-ref/polserver
1
0
Fork 0
mirror of https://github.com/polserver/polserver synced 2026-08-13 08:23:08 -04:00
Code Issues Projects Releases Packages Wiki Activity
polserver/pol-core/bscript/compiler/codegen/InstructionGenerator.h

91 lines
3.9 KiB
C
Raw Permalink Normal View History

Add instruction generator, emitter, emit progend (#211) * Add codegen/InstructionEmitter * Add codegen/InstructionGenerator * CodeGenerator: emit progend Checkpoint: compiler can compile an empty file * Comment reason for having both emit and emitter.
2020-08-12 01:30:06 -07:00
#ifndef POLSERVER_INSTRUCTIONGENERATOR_H
#define POLSERVER_INSTRUCTIONGENERATOR_H
Properly scope the compiler includes to the Bscript folder. (#360)
2021-02-25 16:53:22 +01:00
#include "bscript/compiler/ast/NodeVisitor.h"
Add instruction generator, emitter, emit progend (#211) * Add codegen/InstructionEmitter * Add codegen/InstructionGenerator * CodeGenerator: emit progend Checkpoint: compiler can compile an empty file * Comment reason for having both emit and emitter.
2020-08-12 01:30:06 -07:00
#include <map>
#include <string>
namespace Pol::Bscript::Compiler
{
Add limited support for user functions (#262) Adds: - ast/UserFunction AST node for user-defined functions. - astbuilder/AvailableUserFunction: reference to a parse tree for a user function. - The AST builder only generates ASTs for user functions that are actually referenced. - astbuilder/UserFunctionVisitor: visits (builds an AST for) a parse tree for a user function. - This happens after the .src or .inc file has been otherwise processed, so this class serves to hook up the correct SourceFileIdentifier to the AST.
2020-08-31 18:46:27 -07:00
class FlowControlLabel;
Add instruction generator, emitter, emit progend (#211) * Add codegen/InstructionEmitter * Add codegen/InstructionGenerator * CodeGenerator: emit progend Checkpoint: compiler can compile an empty file * Comment reason for having both emit and emitter.
2020-08-12 01:30:06 -07:00
class InstructionEmitter;
New compiler: write debug info (.dbg and .dbg.txt) (#302) Also: OG compiler debug info for foreach iterator changed to match actual variable name Adds: - ast/DebugStatementMarker: for "intrusive debug" (ecompile -i) instructions - codegen/DebugBlockGuard: pushes and pops debug block # - format/DebugStoreSerializer: writes .dbg and .dbg.txt files - representation/DebugBlock: holds parent block # and local variable names for each block - representation/DebugStore: holds all debug information
2020-09-12 14:26:58 -07:00
class SourceLocation;
Add instruction generator, emitter, emit progend (#211) * Add codegen/InstructionEmitter * Add codegen/InstructionGenerator * CodeGenerator: emit progend Checkpoint: compiler can compile an empty file * Comment reason for having both emit and emitter.
2020-08-12 01:30:06 -07:00
class InstructionGenerator : public NodeVisitor
{
public:
New compiler: write debug info (.dbg and .dbg.txt) (#302) Also: OG compiler debug info for foreach iterator changed to match actual variable name Adds: - ast/DebugStatementMarker: for "intrusive debug" (ecompile -i) instructions - codegen/DebugBlockGuard: pushes and pops debug block # - format/DebugStoreSerializer: writes .dbg and .dbg.txt files - representation/DebugBlock: holds parent block # and local variable names for each block - representation/DebugStore: holds all debug information
2020-09-12 14:26:58 -07:00
InstructionGenerator( InstructionEmitter&,
std::map<std::string, FlowControlLabel>& user_function_labels,
bool in_function);
Add FloatValue (#233)
2020-08-19 10:43:08 -07:00
Add support for if-then-else statements (#259) Adds: - ast/Block: a block scope that allows declaring local variables - ast/IfThenElseStatement: AST node for if..elseif..else..endif statements - model/FlowControlLabel: provides an anchor for jumps or calls. - Function calls, break statements, continue statements, and loops will all use these.
2020-08-30 17:03:26 -07:00
void generate( Node& );
New compiler: write debug info (.dbg and .dbg.txt) (#302) Also: OG compiler debug info for foreach iterator changed to match actual variable name Adds: - ast/DebugStatementMarker: for "intrusive debug" (ecompile -i) instructions - codegen/DebugBlockGuard: pushes and pops debug block # - format/DebugStoreSerializer: writes .dbg and .dbg.txt files - representation/DebugBlock: holds parent block # and local variable names for each block - representation/DebugStore: holds all debug information
2020-09-12 14:26:58 -07:00
void update_debug_location( const Node& );
void update_debug_location( const SourceLocation& );
New compiler: array initialization (#274) * Add array initialization Adds: - ast/ArrayInitializer: AST node for an expression that creates an array
2020-09-06 00:13:49 -07:00
void visit_array_initializer( ArrayInitializer& ) override;
Add for loops (basic and c-style) (#287) Adds: - ast/BasicForLoop - ast/CstyleForLoop
2020-09-08 01:56:30 -07:00
void visit_basic_for_loop( BasicForLoop& loop ) override;
New compiler: Add support for case statements (#272) Adds: - ast/CaseDispatchDefaultSelector: AST node for a "default:" selector - ast/CaseDispatchGroup: AST node for a collection of selectors and the code to execute - ast/CaseDispatchGroups: AST node holding all groups in a case statement - ast/CaseDispatchSelectors: AST node holding all selectors for one group - ast/CaseStatement: AST node for a whole case statement - codegen/CaseDispatchGroupVisitor: knows what to put in a case jump dispatch table - codegen/CaseJumpDataBlock: knows how to build the entries in the data block Also, detect multiple case selectors with the same value (or default). This is different from the OG compiler, which only detected duplicate `default:` selectors.
2020-09-05 20:41:58 -07:00
void visit_case_statement( CaseStatement& ) override;
Add for loops (basic and c-style) (#287) Adds: - ast/BasicForLoop - ast/CstyleForLoop
2020-09-08 01:56:30 -07:00
void visit_cstyle_for_loop( CstyleForLoop& loop ) override;
Add binary operators (#265)
2020-09-01 22:49:48 -07:00
void visit_binary_operator( BinaryOperator& ) override;
Add support for if-then-else statements (#259) Adds: - ast/Block: a block scope that allows declaring local variables - ast/IfThenElseStatement: AST node for if..elseif..else..endif statements - model/FlowControlLabel: provides an anchor for jumps or calls. - Function calls, break statements, continue statements, and loops will all use these.
2020-08-30 17:03:26 -07:00
void visit_block( Block& ) override;
Add `uninit`, `true`, `false` keywords to grammar (#596) * Update grammar * Update expression handling for uninit * update existing tests * Add new tests * Remove fullpath from escriptgrammar generation comment * fix tests * Update eScript guide * Declare escript version 0x11 * Add core-changes * Add `true` and `false` to grammar * true/false implementation * Fix existing tests * Add new tests * Update core changes * add docs * Fix BooleanValue::describe_to * bool optimizations * optimize uninit * remove unused var assignments * Update grammar for case labels for uninit, booleans * Fix case label handling for uninit, true, false * Tests * Fix compiler version display v1.1700000017881393 -> v1.17 * optimize boolean binary operations * fix unary boolean optimizer * add boolean, uninit optimizer test * Use new fmt lib apis * Fix compiler warning * really fix warning lol * Add Executor[Module]::getParam for bools, FindSubstance test
2024-01-20 12:38:25 +08:00
void visit_boolean_value( BooleanValue& ) override;
Add BranchSelector for easier branch optimization (#282) Adds: - ast/BranchSelector: AST node for a branch - can be conditional, based on a predicate - can be unconditional (always / never branch)
2020-09-07 09:53:24 -07:00
void visit_branch_selector( BranchSelector& ) override;
New compiler: write debug info (.dbg and .dbg.txt) (#302) Also: OG compiler debug info for foreach iterator changed to match actual variable name Adds: - ast/DebugStatementMarker: for "intrusive debug" (ecompile -i) instructions - codegen/DebugBlockGuard: pushes and pops debug block # - format/DebugStoreSerializer: writes .dbg and .dbg.txt files - representation/DebugBlock: holds parent block # and local variable names for each block - representation/DebugStore: holds all debug information
2020-09-12 14:26:58 -07:00
void visit_debug_statement_marker( DebugStatementMarker& ) override;
Add support for dictionary creation (#277) Adds: - ast/DictionaryEntry: AST node for a key -> value pair in a dictionary initializdr - ast/DictionaryInitializer: AST node for creating a new dictionary - ast/UninitializedValue: AST node for an uninit object
2020-09-06 04:02:37 -07:00
void visit_dictionary_entry( DictionaryEntry& ) override;
void visit_dictionary_initializer( DictionaryInitializer& ) override;
Add do-while statement (#276) Adds: - ast/DoWhileLoop
2020-09-06 02:26:41 -07:00
void visit_do_while_loop( DoWhileLoop& ) override;
Add support for set and get by index (arrays and dictionaries) (#278) Adds: - ast/ElementAccess: AST node for x[a] or x[a,b,...] (may be get or set) - ast/ElementAssignment: AST node for x[a] := b; - ast/ElementIndexes: AST node to hold all indexes for element lookup - optimizer/AssignmentOptimizer: optimizes := in different circumstances
2020-09-06 14:03:02 -07:00
void visit_element_access( ElementAccess& ) override;
void visit_element_assignment( ElementAssignment& ) override;
New compiler: add elvis operator (#293) Adds: - ast/ElvisOperator
2020-09-09 23:11:51 -07:00
void visit_elvis_operator( ElvisOperator& elvis ) override;
New compiler: add error initializers (#281) Adds: - ast/ErrorInitializer: AST node to create a new error object
2020-09-07 00:58:31 -07:00
void visit_error_initializer( ErrorInitializer& ) override;
New compiler: add return and exit statements (#261) Add: - ast/ExitStatement: AST node for the exit statement. - ast/ReturnStatement: AST node for the return statement. - only handles top-level returns and returns inside program declarations, which do the same thing: progend.
2020-08-30 22:55:30 -07:00
void visit_exit_statement( ExitStatement& ) override;
Add FloatValue (#233)
2020-08-19 10:43:08 -07:00
void visit_float_value( FloatValue& ) override;
Add foreach loops (#275) Adds: - ast/ForeachLoop: AST node
2020-09-06 01:22:47 -07:00
void visit_foreach_loop( ForeachLoop& ) override;
New compiler: Add AST nodes for function calls. Can compile hello world. (#240) Adds: - ast/Argument: AST node for an argument passed to a function. - ast/FunctionCall: AST node for a function call. - codegen/ModuleDeclarationRegistrar: The code generator registers module function declarations with this in order to determine module indexes and function indexes for instructions. - model/FunctionLink: this is a reference either: - from: a FunctionCall or a FunctionReference - to: a ModuleFunctionDeclaration or a UserFunction - optimizer/ReferencedFunctionGatherer: a visitor that determines which module functions and user functions are referenced, by looking at function calls and function references. Also: - CodeGenerator registers module functions - InstructionGenerator generates code for function calls - InstructionEmitter generates TOK_FUNC instructions - StoredTokenDecoder decodes TOK_FUNC instructions After all of this, the compiler can compile print("hello, world");
2020-08-24 01:47:38 -07:00
void visit_function_call( FunctionCall& ) override;
Add limited support for user functions (#262) Adds: - ast/UserFunction AST node for user-defined functions. - astbuilder/AvailableUserFunction: reference to a parse tree for a user function. - The AST builder only generates ASTs for user functions that are actually referenced. - astbuilder/UserFunctionVisitor: visits (builds an AST for) a parse tree for a user function. - This happens after the .src or .inc file has been otherwise processed, so this class serves to hook up the correct SourceFileIdentifier to the AST.
2020-08-31 18:46:27 -07:00
void visit_function_parameter_list( FunctionParameterList& ) override;
void visit_function_parameter_declaration( FunctionParameterDeclaration& ) override;
New compiler: add support for function references (#289) Adds: - ast/FunctionReference
2020-09-08 23:20:32 -07:00
void visit_function_reference( FunctionReference& ) override;
Compiler rewrite: add global variables (#241) Adds support for var statements at the global level. Adds: - analyzer/Variables: keeps track of the variables in scope (either local or global). - ast/Identifier: AST node for an identifier. - The optimizer will replace constant identifiers with their constant value (in a later commit). - The semantic analyzer will set the variable field for local or global variable identifiers. - ast/VarStatement: AST node for a var statement. - A single var statement will generate one VarStatement per variable declared. - model/Variable: Describes a variable, including its index within its scope.
2020-08-25 00:57:03 -07:00
void visit_identifier( Identifier& ) override;
Add support for if-then-else statements (#259) Adds: - ast/Block: a block scope that allows declaring local variables - ast/IfThenElseStatement: AST node for if..elseif..else..endif statements - model/FlowControlLabel: provides an anchor for jumps or calls. - Function calls, break statements, continue statements, and loops will all use these.
2020-08-30 17:03:26 -07:00
void visit_if_then_else_statement( IfThenElseStatement& ) override;
New compiler: Add IntegerValue (#243)
2020-08-25 23:27:24 -07:00
void visit_integer_value( IntegerValue& ) override;
Add break and continue statements. (#270) Adds: - ast/JumpStatement: AST node for break and continue statements
2020-09-04 18:21:08 -07:00
void visit_jump_statement( JumpStatement& ) override;
AST nodes are nouns. (#333) Renamed: - GetMember to MemberAccess - SetMember to MemberAssignment - SetMemberByOperator to MemberAssignmentByOperator - AssignVariableConsume to VariableAssignmentStatement
2020-09-28 08:11:10 -07:00
void visit_member_access( MemberAccess& member_access ) override;
void visit_member_assignment( MemberAssignment& ) override;
void visit_member_assignment_by_operator( MemberAssignmentByOperator& ) override;
New compiler: method calls (#286) Adds: - ast/MethodCall: AST node for an object method call - ast/MethodCallArgumentList: AST node for arguments passed to a method
2020-09-08 01:24:57 -07:00
void visit_method_call( MethodCall& member_call ) override;
var statements in program blocks (#256) Adds: - analyzer/LocalVariableScope: tracks local variables created within a given scope. - Instantiated on the stack during semantic analysis, this registers itself with LocalVariableScopes during construction and deregisters itself during destruction. - Detects unused variables during deregistration - analyzer/LocalVariableScopes: this is what LocalVariableScope registers with. - keeps track of the stack of local scopes. - can provide the current local scope, for var statements. Other notes: "Shadowed" variables: this is when a variable in one scope hides a variable in another, like so: var a := 2; if (a) var a := 3; a := 4; endif print(a); // still 2 "debug_variables": We'll use these later when writing debug files.
2020-08-30 01:32:38 -07:00
void visit_program( Program& ) override;
New compiler: add return and exit statements (#261) Add: - ast/ExitStatement: AST node for the exit statement. - ast/ReturnStatement: AST node for the return statement. - only handles top-level returns and returns inside program declarations, which do the same thing: progend.
2020-08-30 22:55:30 -07:00
void visit_program_parameter_declaration( ProgramParameterDeclaration& ) override;
Add repeat-until loop (#283) Adds: - ast/RepeatUntilLoop
2020-09-07 10:28:26 -07:00
void visit_repeat_until_loop( RepeatUntilLoop& repeat_until ) override;
New compiler: add return and exit statements (#261) Add: - ast/ExitStatement: AST node for the exit statement. - ast/ReturnStatement: AST node for the return statement. - only handles top-level returns and returns inside program declarations, which do the same thing: progend.
2020-08-30 22:55:30 -07:00
void visit_return_statement( ReturnStatement& ) override;
New compiler: Add StringValue (#235) * Add StringValue
2020-08-20 01:27:35 -07:00
void visit_string_value( StringValue& ) override;
Add struct initialization. (#279) Adds: - ast/StructInitializer: AST node for the overall struct - ast/StructMemberInitializer: AST node for initialization of a single field
2020-09-06 23:24:53 -07:00
void visit_struct_initializer( StructInitializer& ) override;
void visit_struct_member_initializer( StructMemberInitializer& ) override;
New compiler: Add optimized unary expressions (#244) Adds: - UnaryOperator: AST node for unary operators -, ++, --, and so forth - UnaryOperatorOptimizer: optimizes a unary operator with its operand - now integer and float negation, and integer inversion - later x[y]++ to a single instruction Also: - automatically include basic.em, which includes some parameter defaults like -1. This allows the compiler to generate output for a hello, world script with the exact same .ecl output as the legacy compiler.
2020-08-26 19:24:47 -07:00
void visit_unary_operator( UnaryOperator& ) override;
Add support for dictionary creation (#277) Adds: - ast/DictionaryEntry: AST node for a key -> value pair in a dictionary initializdr - ast/DictionaryInitializer: AST node for creating a new dictionary - ast/UninitializedValue: AST node for an uninit object
2020-09-06 04:02:37 -07:00
void visit_uninitialized_value( UninitializedValue& ) override;
Add limited support for user functions (#262) Adds: - ast/UserFunction AST node for user-defined functions. - astbuilder/AvailableUserFunction: reference to a parse tree for a user function. - The AST builder only generates ASTs for user functions that are actually referenced. - astbuilder/UserFunctionVisitor: visits (builds an AST for) a parse tree for a user function. - This happens after the .src or .inc file has been otherwise processed, so this class serves to hook up the correct SourceFileIdentifier to the AST.
2020-08-31 18:46:27 -07:00
void visit_user_function( UserFunction& ) override;
Add SourceFileProcessor, ValueConsumer (#232) * Add astbuilder/ SourceFileProcessor * Add ast/ ValueConsumer Co-authored-by: Fernando Rozenblit <rozenblit@gmail.com>
2020-08-18 23:32:57 -07:00
void visit_value_consumer( ValueConsumer& ) override;
Compiler rewrite: add global variables (#241) Adds support for var statements at the global level. Adds: - analyzer/Variables: keeps track of the variables in scope (either local or global). - ast/Identifier: AST node for an identifier. - The optimizer will replace constant identifiers with their constant value (in a later commit). - The semantic analyzer will set the variable field for local or global variable identifiers. - ast/VarStatement: AST node for a var statement. - A single var statement will generate one VarStatement per variable declared. - model/Variable: Describes a variable, including its index within its scope.
2020-08-25 00:57:03 -07:00
void visit_var_statement( VarStatement& ) override;
AST nodes are nouns. (#333) Renamed: - GetMember to MemberAccess - SetMember to MemberAssignment - SetMemberByOperator to MemberAssignmentByOperator - AssignVariableConsume to VariableAssignmentStatement
2020-09-28 08:11:10 -07:00
void visit_variable_assignment_statement( VariableAssignmentStatement& ) override;
Add support for while loops (#268) Adds: - analyzer/FlowControlScope: Registers a break/continue scope - analyzer/FlowControlScopes: Registry for break/continue scopes - ast/LabelableStatement: Base class for AST nodes that can be labelled (loops and case) - ast/LoopStatement: Base class for AST nodes for loops (have a break and continue label) - ast/WhileLoop: AST node for a while loop
2020-09-03 19:46:27 -07:00
void visit_while_loop( WhileLoop& ) override;
Add support for interpolated strings ("interstrings") (#369) * Update grammar to support interpolated strings * Struct initializers, case switchs are regular strings * Initial stub for interpolated string in AST This splits the previous STRING_LITERAL terminal into a production, stringLiteral, to handle REGULAR_STRING terminal and interpolatedString production. * Change interpolated strings to expressions * Fix mode handling in grammar * Grammar fixes - Fix mode handling in lexer - Interpolated strings only have one expression * Can successfully parse, stub compile interstrings $"He {there + print("hello")}"; * Add formatting string to grammar * Fix tests, and add test stubs * Rename curleys to brace; better AST generation * initial work interstring instruction * Initial work on formatted string instruction: emit * Formatted string instruction: execution * Add simple formatted string test * Add formatted string test src * Review changes #1 - Rename `FormattedString` to `FormatExpression` - Rename overloaded `try_to_format()` to `get_formatted()` * Review changes part 2 - Rename `InterpolatedString` ast node to `InterpolateString` * Review changes part 3 - Modify `ins_interpolate_string` * Review changes part 4 - Remove unused formal parameter * Add negative tests * Spruce up positive tests * Fix braces, escape chars inside interstring * Fix, add tests for escaped char and double brace * Address differences for new lines in tests * Update Escript version * Make empty expression an error * Add documentation for interpolated strings * Quick touchup on docs
2021-03-11 22:48:16 +01:00
void visit_interpolate_string( InterpolateString& ) override;
void visit_format_expression( FormatExpression& ) override;
Add support for conditional operator (#387) * Grammar update * AST generation * Emit instructions * Add initial tests * Additional tests * Rename to ConditionalOperator * Add docs
2021-03-14 23:20:20 +01:00
void visit_conditional_operator( ConditionalOperator& ) override;
Add instruction generator, emitter, emit progend (#211) * Add codegen/InstructionEmitter * Add codegen/InstructionGenerator * CodeGenerator: emit progend Checkpoint: compiler can compile an empty file * Comment reason for having both emit and emitter.
2020-08-12 01:30:06 -07:00
private:
// There are two of these because sometimes when calling a method
// on InstructionEmitter, the variable name reads better as a noun,
// and sometimes it reads better as a verb.
InstructionEmitter& emitter;
InstructionEmitter& emit;
Add limited support for user functions (#262) Adds: - ast/UserFunction AST node for user-defined functions. - astbuilder/AvailableUserFunction: reference to a parse tree for a user function. - The AST builder only generates ASTs for user functions that are actually referenced. - astbuilder/UserFunctionVisitor: visits (builds an AST for) a parse tree for a user function. - This happens after the .src or .inc file has been otherwise processed, so this class serves to hook up the correct SourceFileIdentifier to the AST.
2020-08-31 18:46:27 -07:00
std::map<std::string, FlowControlLabel>& user_function_labels;
const bool in_function;
Add instruction generator, emitter, emit progend (#211) * Add codegen/InstructionEmitter * Add codegen/InstructionGenerator * CodeGenerator: emit progend Checkpoint: compiler can compile an empty file * Comment reason for having both emit and emitter.
2020-08-12 01:30:06 -07:00
};
} // namespace Pol::Bscript::Compiler
#endif // POLSERVER_INSTRUCTIONGENERATOR_H
Reference in a new issue Copy permalink