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/ast/FunctionCall.cpp

82 lines
2.7 KiB
C++
Raw Permalink Normal View History

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 "FunctionCall.h"
POLLOG* macros use the new formatting (#598) * POLLOG* macros use the new formatting removed all old logging functions * removed old fmt lib from everything except StreamWriter removed unneeded functions * fixed review comments
2024-01-16 17:55:42 +01:00
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 <map>
#include <utility>
Properly scope the compiler includes to the Bscript folder. (#360)
2021-02-25 16:53:22 +01:00
#include "bscript/compiler/ast/Argument.h"
#include "bscript/compiler/ast/FunctionParameterDeclaration.h"
Add compiler support for expressions as function callee (#670) * initial support for function calls with expression callee * Add support for identifier-named callees * add compilation failure test; better code docs * Add core-changes * Address compiler warnings - conversion from 'size_t' to 'unsigned int', possible loss of data * Update grammar * implementation * tests * update core-changes * Address CI warnings - declaration of 'method' hides previous local declaration
2024-07-28 20:21:23 +02:00
#include "bscript/compiler/ast/Identifier.h"
Properly scope the compiler includes to the Bscript folder. (#360)
2021-02-25 16:53:22 +01:00
#include "bscript/compiler/ast/ModuleFunctionDeclaration.h"
#include "bscript/compiler/ast/NodeVisitor.h"
#include "bscript/compiler/file/SourceLocation.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
{
Add scope handling for functions and variables (#690) * Add Report.debug * Implement function call scoping * Implement variable scoping - Rename `Identifier::scope` to `calling_scope`, and concatenate the identifier scope into `name` if necessary. - Track current scope in SemanticAnalyzer, similar to UserFunctionVisitor. - Use current scope in SemanticAnalyzer when visiting identifiers. * Update grammar for `::identifier` global scoping * Introduce ScopableName for function resolution * Address review comments - Check for display_debugs missing * Add ScopableName for identifier resolution * Some cleanup - Remove `Identifier::calling_scope`, as it is tracked in the semantic analyzer - Refactor `ScopeName::exists` to `global` for better clarification of its use - Removed `X::maybe_scoped_string/name` * Address self-review comments * Rename `Function::module_name` to `scope`
2024-08-11 23:01:38 +02:00
FunctionCall::FunctionCall( const SourceLocation& source_location, std::string calling_scope,
ScopableName scoped_name,
Add compiler support for expressions as function callee (#670) * initial support for function calls with expression callee * Add support for identifier-named callees * add compilation failure test; better code docs * Add core-changes * Address compiler warnings - conversion from 'size_t' to 'unsigned int', possible loss of data * Update grammar * implementation * tests * update core-changes * Address CI warnings - declaration of 'method' hides previous local declaration
2024-07-28 20:21:23 +02:00
std::vector<std::unique_ptr<Argument>> arguments )
: Expression( source_location, std::move( arguments ) ),
Add scope handling for functions and variables (#690) * Add Report.debug * Implement function call scoping * Implement variable scoping - Rename `Identifier::scope` to `calling_scope`, and concatenate the identifier scope into `name` if necessary. - Track current scope in SemanticAnalyzer, similar to UserFunctionVisitor. - Use current scope in SemanticAnalyzer when visiting identifiers. * Update grammar for `::identifier` global scoping * Introduce ScopableName for function resolution * Address review comments - Check for display_debugs missing * Add ScopableName for identifier resolution * Some cleanup - Remove `Identifier::calling_scope`, as it is tracked in the semantic analyzer - Refactor `ScopeName::exists` to `global` for better clarification of its use - Removed `X::maybe_scoped_string/name` * Address self-review comments * Rename `Function::module_name` to `scope`
2024-08-11 23:01:38 +02:00
function_link( std::make_shared<FunctionLink>( source_location, calling_scope ) ),
calling_scope( std::move( calling_scope ) ),
scoped_name( std::make_unique<ScopableName>( std::move( scoped_name ) ) )
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
{
Add scope handling for functions and variables (#690) * Add Report.debug * Implement function call scoping * Implement variable scoping - Rename `Identifier::scope` to `calling_scope`, and concatenate the identifier scope into `name` if necessary. - Track current scope in SemanticAnalyzer, similar to UserFunctionVisitor. - Use current scope in SemanticAnalyzer when visiting identifiers. * Update grammar for `::identifier` global scoping * Introduce ScopableName for function resolution * Address review comments - Check for display_debugs missing * Add ScopableName for identifier resolution * Some cleanup - Remove `Identifier::calling_scope`, as it is tracked in the semantic analyzer - Refactor `ScopeName::exists` to `global` for better clarification of its use - Removed `X::maybe_scoped_string/name` * Address self-review comments * Rename `Function::module_name` to `scope`
2024-08-11 23:01:38 +02:00
}
FunctionCall::FunctionCall( const SourceLocation& source_location, std::string calling_scope,
std::unique_ptr<Node> callee,
std::vector<std::unique_ptr<Argument>> arguments )
: Expression( source_location, std::move( arguments ) ),
function_link( std::make_shared<FunctionLink>( source_location, calling_scope ) ),
calling_scope( std::move( calling_scope ) ),
scoped_name( nullptr ) // FunctionCalls with expression-as-callees do not have a scoped name
{
children.insert( children.begin(), std::move( callee ) );
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 FunctionCall::accept( NodeVisitor& visitor )
{
visitor.visit_function_call( *this );
}
use new formatter for ERROR_PRINT, added ERROR_PRINTLN (#595) * use new formatter for ERROR_PRINT, added ERROR_PRINTLN * remove old log define * fix comments
2024-01-12 06:51:44 +01:00
void FunctionCall::describe_to( std::string& w ) const
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
{
Generate constructors for child classes (#703) * Make constructor_link nullable; WIP generated function builder changes * saving work * saving work, need to resolve double call * hopefully finish up super inherited constructors * Error if no base class has ctor * Fix AddressSanitizer error...? * Revert unnecessary edit * Remove duplicate code * Update pol-core/bscript/compiler/astbuilder/GeneratedFunctionBuilder.cpp
2024-08-28 20:48:07 +02:00
if ( scoped_name )
{
fmt::format_to( std::back_inserter( w ), "function-call({})", scoped_name->string() );
}
else
{
fmt::format_to( std::back_inserter( w ), "expression-as-callee function-call" );
}
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<std::unique_ptr<Argument>> FunctionCall::take_arguments()
{
std::vector<std::unique_ptr<Argument>> args;
args.reserve( children.size() );
for ( auto& child : children )
{
args.emplace_back( static_unique_pointer_cast<Argument, Node>( std::move( child ) ) );
}
return args;
}
std::vector<std::reference_wrapper<FunctionParameterDeclaration>> FunctionCall::parameters() const
{
if ( auto fn = function_link->function() )
return fn->parameters();
ClangTidy readability-else-after-return (#857) * trigger tidy * Automated clang-tidy change: readability-else-after-return * compile test * rerun * Automated clang-tidy change: readability-else-after-return * trigger.. * Automated clang-tidy change: readability-else-after-return * manually removed a few * Automated clang-tidy change: readability-else-after-return * removed duplicate code * fix remaining warnings * fixed scope --------- Co-authored-by: Clang Tidy <clang-tidy@users.noreply.github.com>
2026-01-18 09:35:52 +01:00
internal_error( "function has not been resolved" );
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
}
Add scope handling for functions and variables (#690) * Add Report.debug * Implement function call scoping * Implement variable scoping - Rename `Identifier::scope` to `calling_scope`, and concatenate the identifier scope into `name` if necessary. - Track current scope in SemanticAnalyzer, similar to UserFunctionVisitor. - Use current scope in SemanticAnalyzer when visiting identifiers. * Update grammar for `::identifier` global scoping * Introduce ScopableName for function resolution * Address review comments - Check for display_debugs missing * Add ScopableName for identifier resolution * Some cleanup - Remove `Identifier::calling_scope`, as it is tracked in the semantic analyzer - Refactor `ScopeName::exists` to `global` for better clarification of its use - Removed `X::maybe_scoped_string/name` * Address self-review comments * Rename `Function::module_name` to `scope`
2024-08-11 23:01:38 +02:00
std::string FunctionCall::string() const
{
// Should only be used on compile-time function calls (ie. not an
// expression-as-callee function call) that actually have a ScopedName.
if ( scoped_name )
return scoped_name->string();
return "";
}
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
Reference in a new issue Copy permalink