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/InstructionEmitter.cpp

128 lines
3.5 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
#include "InstructionEmitter.h"
#include "StoredToken.h"
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
#include "compiler/ast/ModuleFunctionDeclaration.h"
#include "compiler/codegen/ModuleDeclarationRegistrar.h"
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
#include "compiler/model/Variable.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 "compiler/representation/CompiledScript.h"
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
#include "escriptv.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 "modules.h"
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
#include "token.h"
#include "tokens.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
namespace Pol::Bscript::Compiler
{
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
InstructionEmitter::InstructionEmitter( CodeSection& code, DataSection& data,
ModuleDeclarationRegistrar& module_declaration_registrar )
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
: code_emitter( code ),
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
data_emitter( data ),
module_declaration_registrar( module_declaration_registrar )
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
{
initialize_data();
}
void InstructionEmitter::initialize_data()
{
std::byte nul{};
data_emitter.store( &nul, sizeof nul );
}
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 InstructionEmitter::access_variable( const Variable& v )
{
BTokenId token_id = v.scope == VariableScope::Global ? TOK_GLOBALVAR : TOK_LOCALVAR;
emit_token( token_id, TYP_OPERAND, v.index );
}
void InstructionEmitter::array_declare()
{
emit_token( INS_DECLARE_ARRAY, TYP_RESERVED );
}
void InstructionEmitter::assign()
{
emit_token( TOK_ASSIGN, TYP_OPERATOR );
}
void InstructionEmitter::call_method_id( MethodID method_id, unsigned argument_count )
{
emit_token( INS_CALL_METHOD_ID, (BTokenType)argument_count, method_id );
}
void InstructionEmitter::call_method( const std::string& name, unsigned argument_count )
{
unsigned offset = emit_data( name );
emit_token( INS_CALL_METHOD, (BTokenType)argument_count, offset );
}
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 InstructionEmitter::call_modulefunc(
const ModuleFunctionDeclaration& module_function_declaration )
{
unsigned module_id, function_index;
module_declaration_registrar.lookup_or_register_module_function( module_function_declaration,
module_id, function_index );
unsigned sympos = include_debug ? emit_data( module_function_declaration.name ) : 0;
StoredToken token(
module_id, TOK_FUNC,
static_cast<BTokenType>(
function_index ), // function index, stored in Token.lval, saved in StoredToken.type
sympos );
append_token( token );
}
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 InstructionEmitter::consume()
{
emit_token( TOK_CONSUMER, TYP_UNARY_OPERATOR );
}
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 InstructionEmitter::declare_variable( const Variable& v )
{
BTokenId token_id = v.scope == VariableScope::Global ? RSV_GLOBAL : RSV_LOCAL;
emit_token( token_id, TYP_RESERVED, v.index );
}
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
void InstructionEmitter::progend()
{
emit_token( CTRL_PROGEND, TYP_CONTROL );
}
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 InstructionEmitter::unary_operator( BTokenId token_id )
{
emit_token( token_id, TYP_UNARY_OPERATOR );
}
Add FloatValue (#233)
2020-08-19 10:43:08 -07:00
void InstructionEmitter::value( double v )
{
unsigned offset = data_emitter.append( v );
emit_token( TOK_DOUBLE, TYP_OPERAND, offset );
}
New compiler: Add IntegerValue (#243)
2020-08-25 23:27:24 -07:00
void InstructionEmitter::value( int v )
{
unsigned offset = data_emitter.append( v );
emit_token( TOK_LONG, TYP_OPERAND, offset );
}
New compiler: Add StringValue (#235) * Add StringValue
2020-08-20 01:27:35 -07:00
void InstructionEmitter::value( const std::string& v )
{
unsigned data_offset = emit_data( v );
emit_token( TOK_STRING, TYP_OPERAND, data_offset );
}
unsigned InstructionEmitter::emit_data( const std::string& s )
{
return data_emitter.store( s );
}
Add FloatValue (#233)
2020-08-19 10:43:08 -07:00
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
unsigned InstructionEmitter::emit_token( BTokenId id, BTokenType type, unsigned offset )
{
StoredToken token( Mod_Basic, id, type, offset );
return append_token( token );
}
unsigned InstructionEmitter::append_token( StoredToken& token )
{
return code_emitter.append( token );
}
} // namespace Pol::Bscript::Compiler
Reference in a new issue Copy permalink