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

190 lines
5.1 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/BinaryOperatorWithFloatOptimizer.h"
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
Split bobject header (#892) * splitted bobject header * fixed runecl * crashfix * missing header * more missing (debug build) * runecl debug include * renamed contiter, moved formating * removed more unused headers
2026-07-08 19:58:41 +02:00
#include "bscript/bdouble.h"
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
#include "bscript/bobject.h"
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/ast/BinaryOperator.h"
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
#include "bscript/compiler/ast/BooleanValue.h"
Properly scope the compiler includes to the Bscript folder. (#360)
2021-02-25 16:53:22 +01:00
#include "bscript/compiler/ast/FloatValue.h"
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
#include "bscript/compiler/ast/IntegerValue.h"
#include "bscript/compiler/ast/StringValue.h"
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
namespace Pol::Bscript::Compiler
{
BinaryOperatorWithFloatOptimizer::BinaryOperatorWithFloatOptimizer( FloatValue& lhs,
BinaryOperator& op,
Report& report )
: lhs( lhs ), op( op ), report( report )
{
}
void BinaryOperatorWithFloatOptimizer::visit_children( Node& ) {}
void BinaryOperatorWithFloatOptimizer::visit_float_value( FloatValue& rhs )
{
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
auto setInt = [&]( int val )
{ optimized_result = std::make_unique<IntegerValue>( op.source_location, val ); };
auto setDouble = [&]( double val )
{ optimized_result = std::make_unique<FloatValue>( op.source_location, val ); };
auto eql = []( double a, double b ) { return fabs( a - b ) < 0.00000001; };
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
switch ( op.token_id )
{
case TOK_ADD:
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
setDouble( lhs.value + rhs.value );
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
break;
case TOK_SUBTRACT:
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
setDouble( lhs.value - rhs.value );
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
break;
case TOK_MULT:
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
setDouble( lhs.value * rhs.value );
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
break;
case TOK_DIV:
if ( rhs.value == 0.0 )
Fix divide-by-zero errors, and mask FormatError if it were thrown in a destructor. (#271)
2020-09-05 01:19:12 -07:00
{
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.error( op, "Expression would divide by zero." );
Fix divide-by-zero errors, and mask FormatError if it were thrown in a destructor. (#271)
2020-09-05 01:19:12 -07:00
return;
}
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
setDouble( lhs.value / rhs.value );
break;
case TOK_MODULUS:
if ( rhs.value == 0 )
{
report.error( op, "Program would divide by zero" );
return;
}
setDouble( fmod( lhs.value, rhs.value ) );
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
break;
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
case TOK_EQUAL:
setInt( eql( lhs.value, rhs.value ) );
break;
case TOK_NEQ:
setInt( !eql( lhs.value, rhs.value ) );
break;
case TOK_LESSTHAN:
setInt( lhs.value < rhs.value );
break;
case TOK_LESSEQ:
setInt( eql( lhs.value, rhs.value ) || ( lhs.value < rhs.value ) );
break;
case TOK_GRTHAN:
setInt( lhs.value > rhs.value );
break;
case TOK_GREQ:
setInt( eql( lhs.value, rhs.value ) || ( lhs.value > rhs.value ) );
break;
case TOK_AND:
setInt( lhs.value != 0.0 && rhs.value != 0.0 );
break;
case TOK_OR:
setInt( lhs.value != 0.0 || rhs.value != 0.0 );
break;
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
default:
return;
}
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
}
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
void BinaryOperatorWithFloatOptimizer::visit_integer_value( IntegerValue& rhs )
{
auto setInt = [&]( int val )
{ optimized_result = std::make_unique<IntegerValue>( op.source_location, val ); };
auto setDouble = [&]( double val )
{ optimized_result = std::make_unique<FloatValue>( op.source_location, val ); };
auto eql = []( double a, int b ) { return fabs( a - b ) < 0.00000001; };
switch ( op.token_id )
{
case TOK_ADD:
setDouble( lhs.value + rhs.value );
break;
case TOK_SUBTRACT:
setDouble( lhs.value - rhs.value );
break;
case TOK_MULT:
setDouble( lhs.value * rhs.value );
break;
case TOK_DIV:
if ( rhs.value == 0 )
{
report.error( op, "Program would divide by zero" );
return;
}
setDouble( lhs.value / rhs.value );
break;
case TOK_MODULUS:
if ( rhs.value == 0 )
{
report.error( op, "Program would divide by zero" );
return;
}
setDouble( fmod( lhs.value, rhs.value ) );
break;
case TOK_EQUAL:
setInt( eql( lhs.value, rhs.value ) );
break;
case TOK_NEQ:
setInt( !eql( lhs.value, rhs.value ) );
break;
case TOK_LESSTHAN:
setInt( lhs.value < rhs.value );
break;
case TOK_LESSEQ:
setInt( eql( lhs.value, rhs.value ) || ( lhs.value < rhs.value ) );
break;
case TOK_GRTHAN:
setInt( lhs.value > rhs.value );
break;
case TOK_GREQ:
setInt( eql( lhs.value, rhs.value ) || ( lhs.value > rhs.value ) );
break;
case TOK_AND:
setInt( lhs.value != 0.0 && rhs.value != 0 );
break;
case TOK_OR:
setInt( lhs.value != 0.0 || rhs.value != 0 );
break;
default:
break;
}
}
void BinaryOperatorWithFloatOptimizer::visit_string_value( StringValue& rhs )
{
auto setString = [&]( std::string&& val )
{ optimized_result = std::make_unique<StringValue>( op.source_location, val ); };
switch ( op.token_id )
{
case TOK_ADD:
setString( fmt::format( "{}{}", Bscript::Double::double_to_string( lhs.value ), rhs.value ) );
break;
default:
break;
}
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
}
Escript Optimizer more types and operator (#794) * compile time optimization: int with doubles and strings doubles with ints and strings strings with ints and doubles * bool with other types, more unary ops, float branch optimizer * more tests fixed bool to dbl compare * output cleanup more tests * optimize string values in if statements, optimize ternary operator * optimize elvis, addes missing files, code cleanup * use array to keep unoptimized if branch in funcexpr tests * missing include * better readable testdata * removed file * optimize while and dowhile loops if predicate is a compile time known value * cleaner variant of loop optimization? * added ConstantPredicateLoop Node used by the optimizer for constant loop predicates optimize repeat until loop change tests to run the loops more then once to be sure they work correctly * test break/continue with label for constant-loop * docs
2025-07-10 22:32:29 +02:00
void BinaryOperatorWithFloatOptimizer::visit_boolean_value( BooleanValue& rhs )
{
bool bval = false;
switch ( op.token_id )
{
case TOK_EQUAL:
bval = ( lhs.value != 0.0 ) == rhs.value;
break;
case TOK_NEQ:
bval = ( lhs.value != 0.0 ) != rhs.value;
break;
case TOK_OR:
bval = ( lhs.value != 0.0 ) || rhs.value;
break;
case TOK_AND:
bval = ( lhs.value != 0.0 ) && rhs.value;
break;
default:
return;
}
// Boolean logic operators return 1/0 as BLong, ie. `true || false` == `1`
optimized_result = std::make_unique<IntegerValue>( op.source_location, bval );
}
Optimizations: binary operators (#266) Adds: - optimizer/BinaryOperatorOptimizer: optimizes expressions with a binary operator - assignments will be handled by optimizer/AssignmentOptimizer - optimizer/BinaryOperatorWithFloatOptimizer: optimizes binary operator expressions with a FloatValue left-hand side - optimizer/BinaryOperatorWithIntegerOptimizer: optimizes binary operator expressions with an IntegerValue left-hand side - optimizer/BinaryOperatorWithStringOptimizer: optimizes binary operator expressions with a StringValue left-hand side
2020-09-02 00:27:09 -07:00
} // namespace Pol::Bscript::Compiler
Reference in a new issue Copy permalink