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/analyzer/Variables.cpp

121 lines
3.9 KiB
C++
Raw Permalink Normal View History

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 "Variables.h"
use c++20 (#799) * use c++20 * increased used clang version * compiler report and logfacility use now compile time formatting, which means that the formatstring gets checked at compile time. (which found 2 errors) adapted a few places since report only accepts formatting arguments adapted a few places with logging since char[] is compile time formatting and string or chr* is runtime formatting * use std::ranges instead of boost * disabled pragma_assume vs specific macro (I guess noone cares) * needed to fix ancient ms exception code * modernized SpinLock * removed unused code in ECompile * replaced std::filesystem::path::u8string with string. It now returns an actual u8string type * cleanup layers.h added the defines for other layers which where before only defined in the pkt * osmod::OpenConnection and HTTPRequest cleanup: early outs, dont check for pChild which is only needed for startscript and placed suspend at the very last position * fix warning * rebuild cache with new compiler version * define c++ standard for external libs where possible * added fixme
2025-08-01 21:40:10 +02:00
#include <ranges>
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
Properly scope the compiler includes to the Bscript folder. (#360)
2021-02-25 16:53:22 +01:00
#include "bscript/compiler/Report.h"
#include "bscript/compiler/file/SourceLocation.h"
#include "bscript/compiler/model/Variable.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
namespace Pol::Bscript::Compiler
{
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
Variables::Variables( VariableScope scope, Report& report )
: scope( scope ), report( report ), variable_info_stack( { VariablesInfo() } )
{
}
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
Clean up warnings: size_t/unsigned mixing, unused private variables (#352)
2020-12-01 02:23:03 -08:00
std::shared_ptr<Variable> Variables::create( const std::string& name, BlockDepth block_depth,
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
WarnOn warn_on, const SourceLocation& source_location )
{
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
auto index = current().names_by_index.size();
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
if ( index > std::numeric_limits<VariableIndex>::max() )
{
report.error( source_location, "Too many variables" );
Clean up warnings: size_t/unsigned mixing, unused private variables (#352)
2020-12-01 02:23:03 -08:00
}
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
auto variable =
std::make_shared<Variable>( scope, name, block_depth, static_cast<VariableIndex>( index ),
warn_on, nullptr, source_location );
current().variables_by_name[name] = variable;
current().names_by_index.push_back( name );
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
return variable;
}
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
std::shared_ptr<Variable> Variables::capture( std::shared_ptr<Variable>& other )
{
// The new variable "local variable" representing the capture at runtime have
// consecutive indexes.
// At compilation:
// - Keep track of the current executing function
// - When visiting an identifier:
// - If type == Capture: ValueStack offset will be current function's param count + this variable
// index
// - If type == Local: if offset > function param count, add current function's capture count
auto index = static_cast<VariableIndex>( current().names_by_index.size() );
auto captured =
std::make_shared<Variable>( VariableScope::Capture, other->name, other->block_depth, index,
other->warn_on, other, other->source_location );
current().variables_by_name[other->name] = captured;
current().names_by_index.push_back( captured->name );
return captured;
}
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
std::shared_ptr<Variable> Variables::find( const std::string& name ) const
{
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
auto itr = variable_info_stack.back().variables_by_name.find( name );
return ( itr != variable_info_stack.back().variables_by_name.end() )
? ( *itr ).second
: std::shared_ptr<Variable>();
}
std::shared_ptr<Variable> Variables::find_in_ancestors( const std::string& name ) const
{
use c++20 (#799) * use c++20 * increased used clang version * compiler report and logfacility use now compile time formatting, which means that the formatstring gets checked at compile time. (which found 2 errors) adapted a few places since report only accepts formatting arguments adapted a few places with logging since char[] is compile time formatting and string or chr* is runtime formatting * use std::ranges instead of boost * disabled pragma_assume vs specific macro (I guess noone cares) * needed to fix ancient ms exception code * modernized SpinLock * removed unused code in ECompile * replaced std::filesystem::path::u8string with string. It now returns an actual u8string type * cleanup layers.h added the defines for other layers which where before only defined in the pkt * osmod::OpenConnection and HTTPRequest cleanup: early outs, dont check for pChild which is only needed for startscript and placed suspend at the very last position * fix warning * rebuild cache with new compiler version * define c++ standard for external libs where possible * added fixme
2025-08-01 21:40:10 +02:00
for ( const auto& info : variable_info_stack | std::views::reverse | std::views::drop( 1 ) )
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
{
auto itr = info.variables_by_name.find( name );
if ( itr != info.variables_by_name.end() )
{
return ( *itr ).second;
}
}
return nullptr;
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
}
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 Variables::restore_shadowed( std::shared_ptr<Variable> variable )
{
// It's still in names_by_index
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
current().variables_by_name[variable->name] = std::move( variable );
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 Variables::remove_all_but( unsigned count )
{
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
while ( current().names_by_index.size() > count )
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
{
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
std::string last_name = current().names_by_index.back();
auto itr = current().variables_by_name.find( last_name );
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
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
if ( itr != current().variables_by_name.end() )
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
{
Fix divide-by-zero errors, and mask FormatError if it were thrown in a destructor. (#271)
2020-09-05 01:19:12 -07:00
auto& removing = ( *itr ).second;
if ( removing->warn_on == WarnOn::IfUsed && removing->was_used() )
{
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
report.warning( removing->source_location,
"local variable '{}' declared as unused but used.", last_name );
Fix divide-by-zero errors, and mask FormatError if it were thrown in a destructor. (#271)
2020-09-05 01:19:12 -07:00
}
else if ( removing->warn_on == WarnOn::IfNotUsed && !removing->was_used() )
{
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
report.warning( removing->source_location, "local variable '{}' was not used.", last_name );
Fix divide-by-zero errors, and mask FormatError if it were thrown in a destructor. (#271)
2020-09-05 01:19:12 -07:00
}
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
current().variables_by_name.erase( itr );
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
}
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
current().names_by_index.pop_back();
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
}
}
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
const std::vector<std::string>& Variables::get_names() const
{
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
return variable_info_stack.back().names_by_index;
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
}
unsigned Variables::count() const
{
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
return static_cast<unsigned>( variable_info_stack.back().names_by_index.size() );
}
Variables::VariablesInfo& Variables::current()
{
return variable_info_stack.back();
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
}
} // namespace Pol::Bscript::Compiler
Reference in a new issue Copy permalink