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/optimizer/ReferencedFunctionGatherer.cpp

91 lines
2.6 KiB
C++
Raw Permalink Normal View History

Includes are now all relative to pol-core basefolder (#906) * all except pol * pol and includes under defines * something weird has happened * remove own folder from include searchpath * fixed remaining, adapted include style for external headers * missing include
2026-07-25 23:01:18 +02:00
#include "bscript/compiler/optimizer/ReferencedFunctionGatherer.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
Changes to default construction and base-class semantic analysis (#693) * Remove DefaultConstructorFunction * Modify class parameters; update semantic analysis - Use ClassDeclarationParameter for class decls vs Identifiers - Update ScopableName to have equality for constructors and unscoped function calls - Update SemanticAnalyzer (self referencing base class, no ctor) - Update, add tests * Semantic updates; debug messaging updates - Ensure base class is constructable - Various fmt implementations for debugging * Address self-review comments
2024-08-14 12:56:36 +02:00
#include "bscript/compiler/ast/ClassParameterDeclaration.h"
Properly scope the compiler includes to the Bscript folder. (#360)
2021-02-25 16:53:22 +01:00
#include "bscript/compiler/ast/FunctionCall.h"
Add compiler support for function expressions (#671) * initial poc of function expressions - update grammar - mock AST builder to return BBoolean(true) for a func expr - update prettifier for skeleton implementation * more skeleton work create AST class FunctionExpression mimicking boolean value * create ast UserFunction, add to workspace from functexpr * can generate instructions * reorg tests; add test for instructions * can track FunctionDepth in Variable * can get captures for funcexprs inside funcs.. tbd if this way of nesting works * Implement create-functor instruction - Move function depth from Variable to Variables - Introduce stacking of `Variables` for function expresions via `FunctionVariableScope` - Add `TOK_FUNCTOR` instruction for 'create-functor' - Handle emitting a `FunctionExpression` AST node - Update `emit.declare_variable` and `emit.access_variable` to account for function captures - Remove `in_function` from instruction generator, as it is tracked via `UserFunction` stack - Update tests * Address Discord comments - Swap pop param order * Bubble up captured variables through nested functions * Improve testing infrastructure; add some test cases * Fix compilation error * prepend captures to function parameters in funcref mth_call * update tests * move from function{} to @{} * implementation fix * some more tests * update docs * Some cleanup * fix CI annotation warning - 'argument': conversion from 'size_t' to 'VariableIndex', possible loss of data * Address review comments - Add `passert_always` - Use better example in docs * Some cleanup - Remove unused functions
2024-07-29 22:30:52 +02:00
#include "bscript/compiler/ast/FunctionExpression.h"
Properly scope the compiler includes to the Bscript folder. (#360)
2021-02-25 16:53:22 +01:00
#include "bscript/compiler/ast/FunctionReference.h"
#include "bscript/compiler/ast/UserFunction.h"
#include "bscript/compiler/model/FunctionLink.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
namespace Pol::Bscript::Compiler
{
ReferencedFunctionGatherer::ReferencedFunctionGatherer(
Add support for exported functions (#284)
2020-09-07 12:35:17 -07:00
std::vector<std::unique_ptr<ModuleFunctionDeclaration>>& all_module_function_declarations,
std::vector<std::unique_ptr<UserFunction>> all_user_functions )
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
{
for ( auto& mfd : all_module_function_declarations )
{
unreferenced_module_function_declarations.insert( mfd.get() );
}
Add support for exported functions (#284)
2020-09-07 12:35:17 -07:00
for ( auto& uf : all_user_functions )
{
UserFunction* p = uf.get();
unreferenced_user_functions[p] = std::move( uf );
}
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 ReferencedFunctionGatherer::visit_function_call( FunctionCall& fc )
{
visit_children( fc );
reference( *fc.function_link );
}
New compiler: add support for function references (#289) Adds: - ast/FunctionReference
2020-09-08 23:20:32 -07:00
void ReferencedFunctionGatherer::visit_function_reference( FunctionReference& fr )
{
reference( *fr.function_link );
}
Add compiler support for function expressions (#671) * initial poc of function expressions - update grammar - mock AST builder to return BBoolean(true) for a func expr - update prettifier for skeleton implementation * more skeleton work create AST class FunctionExpression mimicking boolean value * create ast UserFunction, add to workspace from functexpr * can generate instructions * reorg tests; add test for instructions * can track FunctionDepth in Variable * can get captures for funcexprs inside funcs.. tbd if this way of nesting works * Implement create-functor instruction - Move function depth from Variable to Variables - Introduce stacking of `Variables` for function expresions via `FunctionVariableScope` - Add `TOK_FUNCTOR` instruction for 'create-functor' - Handle emitting a `FunctionExpression` AST node - Update `emit.declare_variable` and `emit.access_variable` to account for function captures - Remove `in_function` from instruction generator, as it is tracked via `UserFunction` stack - Update tests * Address Discord comments - Swap pop param order * Bubble up captured variables through nested functions * Improve testing infrastructure; add some test cases * Fix compilation error * prepend captures to function parameters in funcref mth_call * update tests * move from function{} to @{} * implementation fix * some more tests * update docs * Some cleanup * fix CI annotation warning - 'argument': conversion from 'size_t' to 'VariableIndex', possible loss of data * Address review comments - Add `passert_always` - Use better example in docs * Some cleanup - Remove unused functions
2024-07-29 22:30:52 +02:00
void ReferencedFunctionGatherer::visit_function_expression( FunctionExpression& fr )
{
reference( *fr.function_link );
}
Changes to default construction and base-class semantic analysis (#693) * Remove DefaultConstructorFunction * Modify class parameters; update semantic analysis - Use ClassDeclarationParameter for class decls vs Identifiers - Update ScopableName to have equality for constructors and unscoped function calls - Update SemanticAnalyzer (self referencing base class, no ctor) - Update, add tests * Semantic updates; debug messaging updates - Ensure base class is constructable - Various fmt implementations for debugging * Address self-review comments
2024-08-14 12:56:36 +02:00
void ReferencedFunctionGatherer::visit_class_parameter_declaration( ClassParameterDeclaration& cpd )
{
reference( *cpd.constructor_link );
}
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 ReferencedFunctionGatherer::reference( FunctionLink& link )
{
if ( auto mfd = link.module_function_declaration() )
reference( mfd );
Add support for exported functions (#284)
2020-09-07 12:35:17 -07:00
else if ( auto uf = link.user_function() )
reference( uf );
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 ReferencedFunctionGatherer::reference( ModuleFunctionDeclaration* mfd )
{
auto itr = unreferenced_module_function_declarations.find( mfd );
if ( itr != unreferenced_module_function_declarations.end() )
{
referenced_module_function_declarations.push_back( mfd );
unreferenced_module_function_declarations.erase( itr );
}
}
Add support for exported functions (#284)
2020-09-07 12:35:17 -07:00
void ReferencedFunctionGatherer::reference( UserFunction* uf )
{
auto itr = unreferenced_user_functions.find( uf );
if ( itr != unreferenced_user_functions.end() )
{
referenced_user_functions.push_back( std::move( ( *itr ).second ) );
unreferenced_user_functions.erase( itr );
uf->accept( *this );
}
}
std::vector<std::unique_ptr<UserFunction>>
ReferencedFunctionGatherer::take_referenced_user_functions()
{
return std::move( referenced_user_functions );
}
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
std::vector<ModuleFunctionDeclaration*>
ReferencedFunctionGatherer::take_referenced_module_function_declarations()
{
return std::move( referenced_module_function_declarations );
}
} // namespace Pol::Bscript::Compiler
Reference in a new issue Copy permalink