25918451630

Committed 15 May 2026 12:43PM UTC coverage: 60.929% (+2.1%) from 58.859%

Build # 25918451630

Build Type

push

github

Committed by

turleypol

Commit Message

added dynamic property which returns a pointer of the object instead of
a copy like the current imp.
needed to be able to eg store a vector

Coverage Stats

43 of 61 new or added lines in 2 files covered. (70.49%)

14455 existing lines in 345 files now uncovered.

44695 of 73356 relevant lines covered (60.93%)

449621.59 hits per line

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

88.65

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

#include "BinaryOperatorWithFloatOptimizer.h"

#include "bscript/bobject.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
{
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 )
{
  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; };

  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.0 )
    {
      report.error( op, "Expression 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.0 );
    break;
  case TOK_OR:
    setInt( lhs.value != 0.0 || rhs.value != 0.0 );
    break;
  default:
    return;
  }
}

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;
  }
}

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 );
}
}  // namespace Pol::Bscript::Compiler

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

polserver / polserver / 25918451630

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