16205400460

Committed 10 Jul 2025 08:32PM UTC coverage: 59.527% (+0.2%) from 59.304%

Build # 16205400460

Build Type

push

github

Committed by

web-flow

Commit Message

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

Run Details

392 of 435 new or added lines in 16 files covered. (90.11%)

6 existing lines in 2 files now uncovered.

43324 of 72780 relevant lines covered (59.53%)

448442.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.54

/pol-core/bscript/compiler/optimizer/BinaryOperatorWithIntegerOptimizer.cpp

#include "BinaryOperatorWithIntegerOptimizer.h"

#include "bscript/compiler/Report.h"
#include "bscript/compiler/ast/BinaryOperator.h"
#include "bscript/compiler/ast/BooleanValue.h"
#include "bscript/compiler/ast/FloatValue.h"
#include "bscript/compiler/ast/IntegerValue.h"
#include "bscript/compiler/ast/StringValue.h"

namespace Pol::Bscript::Compiler
{
BinaryOperatorWithIntegerOptimizer::BinaryOperatorWithIntegerOptimizer( IntegerValue& lhs,
                                                                        BinaryOperator& op,
                                                                        Report& report )
    : lhs( lhs ), op( op ), report( report )
{
}

void BinaryOperatorWithIntegerOptimizer::visit_children( Node& ) {}

void BinaryOperatorWithIntegerOptimizer::visit_integer_value( IntegerValue& rhs )
{
  int value = 0;
  switch ( op.token_id )
  {
  case TOK_ADD:
    value = lhs.value + rhs.value;
    break;
  case TOK_SUBTRACT:
    value = lhs.value - rhs.value;
    break;
  case TOK_MULT:
    value = lhs.value * rhs.value;
    break;
  case TOK_DIV:
    if ( rhs.value == 0 )
    {
      report.error( op, "Program would divide by zero" );
      return;
    }
    value = lhs.value / rhs.value;
    break;
  case TOK_MODULUS:
    if ( rhs.value == 0 )
    {
      report.error( op, "Program would divide by zero" );
      return;
    }
    value = lhs.value % rhs.value;
    break;

  case TOK_EQUAL:
    value = ( lhs.value == rhs.value );
    break;
  case TOK_NEQ:
    value = ( lhs.value != rhs.value );
    break;
  case TOK_LESSTHAN:
    value = ( lhs.value < rhs.value );
    break;
  case TOK_LESSEQ:
    value = ( lhs.value <= rhs.value );
    break;
  case TOK_GRTHAN:
    value = ( lhs.value > rhs.value );
    break;
  case TOK_GREQ:
    value = ( lhs.value >= rhs.value );
    break;

  case TOK_AND:
    value = ( lhs.value && rhs.value );
    break;
  case TOK_OR:
    value = ( lhs.value || rhs.value );
    break;

  case TOK_BSRIGHT:
    value = ( lhs.value >> rhs.value );
    break;
  case TOK_BSLEFT:
    value = ( lhs.value << rhs.value );
    break;
  case TOK_BITAND:
    value = ( lhs.value & rhs.value );
    break;
  case TOK_BITOR:
    value = ( lhs.value | rhs.value );
    break;
  case TOK_BITXOR:
    value = ( lhs.value ^ rhs.value );
    break;

  default:
    return;
  }

  optimized_result = std::make_unique<IntegerValue>( op.source_location, value );
}

void BinaryOperatorWithIntegerOptimizer::visit_float_value( FloatValue& 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 = []( int a, double 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 && rhs.value != 0.0 );
    break;
  case TOK_OR:
    setInt( lhs.value != 0 || rhs.value != 0.0 );
    break;
  default:
    break;
  }
}

void BinaryOperatorWithIntegerOptimizer::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( "{}{}", lhs.value, rhs.value ) );
    break;
  default:
    break;
  }
}

void BinaryOperatorWithIntegerOptimizer::visit_boolean_value( BooleanValue& rhs )
{
  bool bval = false;
  switch ( op.token_id )
  {
  case TOK_EQUAL:
    bval = ( lhs.value != 0 ) == rhs.value;
    break;
  case TOK_NEQ:
    bval = ( lhs.value != 0 ) != rhs.value;
    break;
  case TOK_OR:
    bval = lhs.value || rhs.value;
    break;
  case TOK_AND:
    bval = lhs.value && 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 );
}
}  // namespace Pol::Bscript::Compiler

1	#include "BinaryOperatorWithIntegerOptimizer.h"
2
3	#include "bscript/compiler/Report.h"
4	#include "bscript/compiler/ast/BinaryOperator.h"
5	#include "bscript/compiler/ast/BooleanValue.h"
6	#include "bscript/compiler/ast/FloatValue.h"
7	#include "bscript/compiler/ast/IntegerValue.h"
8	#include "bscript/compiler/ast/StringValue.h"
9
10	namespace Pol::Bscript::Compiler
11	{
12	BinaryOperatorWithIntegerOptimizer::BinaryOperatorWithIntegerOptimizer( IntegerValue& lhs,	566✔
13	BinaryOperator& op,
14	Report& report )	566✔
15	: lhs( lhs ), op( op ), report( report )	566✔
16	{
17	}	566✔
18
19	void BinaryOperatorWithIntegerOptimizer::visit_children( Node& ) {}	24✔
20
21	void BinaryOperatorWithIntegerOptimizer::visit_integer_value( IntegerValue& rhs )	454✔
22	{
23	int value = 0;	454✔
24	switch ( op.token_id )	454✔
25	{
26	case TOK_ADD:	290✔
27	value = lhs.value + rhs.value;	290✔
28	break;	290✔
29	case TOK_SUBTRACT:	12✔
30	value = lhs.value - rhs.value;	12✔
31	break;	12✔
32	case TOK_MULT:	12✔
33	value = lhs.value * rhs.value;	12✔
34	break;	12✔
35	case TOK_DIV:	20✔
36	if ( rhs.value == 0 )	20✔
37	{
38	report.error( op, "Program would divide by zero" );	×
UNCOV 39	return;	×
40	}
41	value = lhs.value / rhs.value;	20✔
42	break;	20✔
43	case TOK_MODULUS:	10✔
44	if ( rhs.value == 0 )	10✔
45	{
NEW 46	report.error( op, "Program would divide by zero" );	×
NEW 47	return;	×
48	}
49	value = lhs.value % rhs.value;	10✔
50	break;	10✔
51
52	case TOK_EQUAL:	10✔
53	value = ( lhs.value == rhs.value );	10✔
54	break;	10✔
55	case TOK_NEQ:	4✔
56	value = ( lhs.value != rhs.value );	4✔
57	break;	4✔
58	case TOK_LESSTHAN:	42✔
59	value = ( lhs.value < rhs.value );	42✔
60	break;	42✔
61	case TOK_LESSEQ:	2✔
62	value = ( lhs.value <= rhs.value );	2✔
63	break;	2✔
64	case TOK_GRTHAN:	8✔
65	value = ( lhs.value > rhs.value );	8✔
66	break;	8✔
67	case TOK_GREQ:	2✔
68	value = ( lhs.value >= rhs.value );	2✔
69	break;	2✔
70
71	case TOK_AND:	2✔
72	value = ( lhs.value && rhs.value );	2✔
73	break;	2✔
74	case TOK_OR:	2✔
75	value = ( lhs.value \|\| rhs.value );	2✔
76	break;	2✔
77
78	case TOK_BSRIGHT:	2✔
79	value = ( lhs.value >> rhs.value );	2✔
80	break;	2✔
81	case TOK_BSLEFT:	2✔
82	value = ( lhs.value << rhs.value );	2✔
83	break;	2✔
84	case TOK_BITAND:	6✔
85	value = ( lhs.value & rhs.value );	6✔
86	break;	6✔
87	case TOK_BITOR:	24✔
88	value = ( lhs.value \| rhs.value );	24✔
89	break;	24✔
90	case TOK_BITXOR:	4✔
91	value = ( lhs.value ^ rhs.value );	4✔
92	break;	4✔
93
UNCOV 94	default:	×
UNCOV 95	return;	×
96	}
97
98	optimized_result = std::make_unique<IntegerValue>( op.source_location, value );	454✔
99	}
100
101	void BinaryOperatorWithIntegerOptimizer::visit_float_value( FloatValue& rhs )	44✔
102	{
103	auto setInt = [&]( int val )	32✔
104	{ optimized_result = std::make_unique<IntegerValue>( op.source_location, val ); };	32✔
105	auto setDouble = [&]( double val )	12✔
106	{ optimized_result = std::make_unique<FloatValue>( op.source_location, val ); };	12✔
107	auto eql = []( int a, double b ) { return fabs( a - b ) < 0.00000001; };	16✔
108	switch ( op.token_id )	44✔
109	{
110	case TOK_ADD:	2✔
111	setDouble( lhs.value + rhs.value );	2✔
112	break;	2✔
113	case TOK_SUBTRACT:	2✔
114	setDouble( lhs.value - rhs.value );	2✔
115	break;	2✔
116	case TOK_MULT:	4✔
117	setDouble( lhs.value * rhs.value );	4✔
118	break;	4✔
119	case TOK_DIV:	2✔
120	if ( rhs.value == 0 )	2✔
121	{
NEW 122	report.error( op, "Program would divide by zero" );	×
NEW 123	return;	×
124	}
125	setDouble( lhs.value / rhs.value );	2✔
126	break;	2✔
127	case TOK_MODULUS:	2✔
128	if ( rhs.value == 0 )	2✔
129	{
NEW 130	report.error( op, "Program would divide by zero" );	×
NEW 131	return;	×
132	}
133	setDouble( fmod( lhs.value, rhs.value ) );	2✔
134	break;	2✔
135	case TOK_EQUAL:	4✔
136	setInt( eql( lhs.value, rhs.value ) );	4✔
137	break;	4✔
138	case TOK_NEQ:	4✔
139	setInt( !eql( lhs.value, rhs.value ) );	4✔
140	break;	4✔
141	case TOK_LESSTHAN:	4✔
142	setInt( lhs.value < rhs.value );	4✔
143	break;	4✔
144	case TOK_LESSEQ:	4✔
145	setInt( eql( lhs.value, rhs.value ) \|\| ( lhs.value < rhs.value ) );	4✔
146	break;	4✔
147	case TOK_GRTHAN:	4✔
148	setInt( lhs.value > rhs.value );	4✔
149	break;	4✔
150	case TOK_GREQ:	4✔
151	setInt( eql( lhs.value, rhs.value ) \|\| ( lhs.value > rhs.value ) );	4✔
152	break;	4✔
153	case TOK_AND:	4✔
154	setInt( lhs.value != 0 && rhs.value != 0.0 );	4✔
155	break;	4✔
156	case TOK_OR:	4✔
157	setInt( lhs.value != 0 \|\| rhs.value != 0.0 );	4✔
158	break;	4✔
NEW 159	default:	×
NEW 160	break;	×
161	}
162	}
163
164	void BinaryOperatorWithIntegerOptimizer::visit_string_value( StringValue& rhs )	6✔
165	{
166	auto setString = [&]( std::string&& val )	6✔
167	{ optimized_result = std::make_unique<StringValue>( op.source_location, val ); };	6✔
168	switch ( op.token_id )	6✔
169	{
170	case TOK_ADD:	6✔
171	setString( fmt::format( "{}{}", lhs.value, rhs.value ) );	12✔
172	break;	6✔
NEW 173	default:	×
NEW 174	break;	×
175	}
176	}	6✔
177
178	void BinaryOperatorWithIntegerOptimizer::visit_boolean_value( BooleanValue& rhs )	8✔
179	{
180	bool bval = false;	8✔
181	switch ( op.token_id )	8✔
182	{
183	case TOK_EQUAL:	2✔
184	bval = ( lhs.value != 0 ) == rhs.value;	2✔
185	break;	2✔
186	case TOK_NEQ:	2✔
187	bval = ( lhs.value != 0 ) != rhs.value;	2✔
188	break;	2✔
189	case TOK_OR:	2✔
190	bval = lhs.value \|\| rhs.value;	2✔
191	break;	2✔
192	case TOK_AND:	2✔
193	bval = lhs.value && rhs.value;	2✔
194	break;	2✔
NEW 195	default:	×
NEW 196	return;	×
197	}
198
199	// Boolean logic operators return 1/0 as BLong, ie. `true \|\| false` == `1`
200	optimized_result = std::make_unique<IntegerValue>( op.source_location, bval );	8✔
201	}
202	} // namespace Pol::Bscript::Compiler

polserver / polserver / 16205400460

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous