21100551564

Committed 17 Jan 2026 08:40PM UTC coverage: 60.504% (+0.01%) from 60.492%

Build # 21100551564

Build Type

Pull #857

github

Committed by

turleypol

Commit Message

fixed scope

Pull Request Pull Request #857: ClangTidy readability-else-after-return

Run Details

837 of 1874 new or added lines in 151 files covered. (44.66%)

48 existing lines in 26 files now uncovered.

44445 of 73458 relevant lines covered (60.5%)

515341.61 hits per line

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

86.43

/pol-core/bscript/compiler/astbuilder/ValueBuilder.cpp

#include "ValueBuilder.h"

#include <cstring>

#include "bscript/compiler/Report.h"
#include "bscript/compiler/ast/BooleanValue.h"
#include "bscript/compiler/ast/FloatValue.h"
#include "bscript/compiler/ast/FunctionExpression.h"
#include "bscript/compiler/ast/FunctionReference.h"
#include "bscript/compiler/ast/IntegerValue.h"
#include "bscript/compiler/ast/RegularExpressionValue.h"
#include "bscript/compiler/ast/StringValue.h"
#include "bscript/compiler/ast/UninitializedValue.h"
#include "bscript/compiler/astbuilder/BuilderWorkspace.h"
#include "bscript/compiler/file/SourceLocation.h"
#include "bscript/compiler/model/CompilerWorkspace.h"
#include "bscript/compiler/model/FunctionLink.h"
#include "clib/strutil.h"

using EscriptGrammar::EscriptParser;

namespace Pol::Bscript::Compiler
{
ValueBuilder::ValueBuilder( const SourceFileIdentifier& source_file_identifier,
                            BuilderWorkspace& workspace )
    : TreeBuilder( source_file_identifier, workspace ), current_scope_name( ScopeName::Global )
{
  in_constructor_function.push( false );
}

std::unique_ptr<BooleanValue> ValueBuilder::bool_value(
    EscriptGrammar::EscriptParser::BoolLiteralContext* ctx )
{
  bool value;
  auto loc = location_for( *ctx );

  if ( ctx->BOOL_TRUE() )
  {
    value = true;
  }
  else if ( ctx->BOOL_FALSE() )
  {
    value = false;
  }
  else
  {
    location_for( *ctx ).internal_error( "unhandled boolean literal" );
  }

  return std::make_unique<BooleanValue>( loc, value );
}

std::unique_ptr<FloatValue> ValueBuilder::float_value(
    EscriptGrammar::EscriptParser::FloatLiteralContext* ctx )
{
  auto loc = location_for( *ctx );
  auto terminal = ctx->FLOAT_LITERAL();
  if ( !terminal )
  {
    terminal = ctx->HEX_FLOAT_LITERAL();
    if ( !terminal )
    {
      location_for( *ctx ).internal_error( "unhandled float literal" );
    }
  }
  double value = std::stod( text( terminal ) );
  return std::make_unique<FloatValue>( loc, value );
}

std::unique_ptr<FunctionReference> ValueBuilder::function_reference(
    EscriptParser::FunctionReferenceContext* ctx )
{
  auto source_location = location_for( *ctx );

  auto name = text( ctx->function );
  auto scope = ctx->scope          ? ScopeName( text( ctx->scope ) )  // scope exists
               : ctx->COLONCOLON() ? ScopeName::Global                // colon exists
                                   : ScopeName::None;                 // has no scope specified

  auto function_link =
      std::make_shared<FunctionLink>( source_location, current_scope_name.string() );
  auto function_reference =
      std::make_unique<FunctionReference>( source_location, name, function_link );

  workspace.function_resolver.register_function_link( ScopableName( scope, name ), function_link );

  return function_reference;
}

std::unique_ptr<FunctionExpression> ValueBuilder::function_expression(
    EscriptGrammar::EscriptParser::FunctionExpressionContext* ctx )
{
  auto loc = location_for( *ctx );
  auto name = workspace.function_resolver.register_function_expression( loc, ctx );

  workspace.compiler_workspace.all_function_locations.emplace( name, loc );
  workspace.function_resolver.force_reference( ScopableName( ScopeName::Global, name ), loc );

  auto function_link =
      std::make_shared<FunctionLink>( loc, current_scope_name.string() /* calling scope */ );

  // A unique name, as it is based on source location, so registering the link
  // in global scope is okay.
  workspace.function_resolver.register_function_link( ScopableName( ScopeName::Global, name ),
                                                      function_link );

  return std::make_unique<FunctionExpression>( loc, function_link );
}

std::unique_ptr<IntegerValue> ValueBuilder::integer_value(
    EscriptParser::IntegerLiteralContext* ctx )
{
  auto loc = location_for( *ctx );
  return std::make_unique<IntegerValue>( loc, to_int( ctx ) );
}

std::unique_ptr<StringValue> ValueBuilder::string_value( antlr4::tree::TerminalNode* string_literal,
                                                         bool expect_quotes )
{
  auto loc = location_for( *string_literal );
  return std::make_unique<StringValue>( loc, unquote( string_literal, expect_quotes ) );
}

std::unique_ptr<RegularExpressionValue> ValueBuilder::regular_expression_value(
    antlr4::tree::TerminalNode* regular_expression_literal )
{
  std::string input = regular_expression_literal->getSymbol()->getText();

  std::string pattern;
  std::string flags;

  std::size_t pos = input.rfind( '/' );

  if ( input.size() < 2 || input[0] != '/' || pos == std::string::npos )
  {
    location_for( *regular_expression_literal )
        .internal_error( "regular expression does not begin with a slash?" );
  }

  pattern = input.substr( 1, pos - 1 );
  flags = input.substr( pos + 1 );

  auto loc = location_for( *regular_expression_literal );
  return std::make_unique<RegularExpressionValue>( loc, std::move( pattern ), std::move( flags ) );
}

std::string ValueBuilder::unquote( antlr4::tree::TerminalNode* string_literal, bool expect_quotes )
{
  std::string input = string_literal->getSymbol()->getText();
  const char* s = input.c_str();
  if ( *s != '\"' && expect_quotes )
    location_for( *string_literal ).internal_error( "string does not begin with a quote?" );

  const char* end = s + ( expect_quotes ? 1 : 0 );
  std::string lit;
  lit.reserve( input.length() );
  bool escnext = false;  // true when waiting for 2nd char in an escape sequence
  u8 hexnext = 0;        // tells how many more chars in a \xNN escape sequence
  char hexstr[3];        // will contain the \x escape chars to be processed
  memset( hexstr, 0, 3 );

  for ( ;; )
  {
    if ( !*end )
    {
      if ( !expect_quotes )
        break;
      // parser should catch this.
      location_for( *string_literal ).internal_error( "unterminated string" );
    }

    if ( escnext && hexnext )
      location_for( *string_literal )
          .internal_error( "Bug in the compiler. Please report this on the forums." );

    if ( escnext )
    {
      // waiting for 2nd character after a backslash
      escnext = false;
      if ( *end == 'n' )
        lit += '\n';
      else if ( *end == 't' )
        lit += '\t';
      else if ( *end == 'x' )
        hexnext = 2;
      else
        lit += *end;
    }
    else if ( hexnext )
    {
      // waiting for next (two) chars in hex escape sequence (eg. \xFF)
      hexstr[2 - hexnext] = *end;
      if ( !--hexnext )
      {
        char* endptr;
        char ord = static_cast<char>( strtol( hexstr, &endptr, 16 ) );
        if ( *endptr != '\0' )
        {
          report.error( location_for( *string_literal ), "Invalid hex escape sequence '{}'.",
                        hexstr );
          return lit;
        }
        lit += ord;
      }
    }
    else
    {
      if ( *end == '\\' )
        escnext = true;
      else if ( *end == '\"' )
        break;
      else
        lit += *end;
    }
    ++end;
  }
  if ( !Clib::isValidUnicode( lit ) )
  {
    report.warning( location_for( *string_literal ),
                    "Warning: invalid unicode character detected. Assuming ISO8859." );

    Clib::sanitizeUnicodeWithIso( &lit );
  }
  return lit;
}

std::unique_ptr<Value> ValueBuilder::value( EscriptParser::LiteralContext* ctx )
{
  if ( auto string_literal = ctx->STRING_LITERAL() )
  {
    return string_value( string_literal );
  }
  if ( auto integer_literal = ctx->integerLiteral() )
  {
    return integer_value( integer_literal );
  }
  if ( auto float_literal = ctx->floatLiteral() )
  {
    return float_value( float_literal );
  }
  if ( auto bool_literal = ctx->boolLiteral() )
  {
    return bool_value( bool_literal );
  }
  if ( ctx->UNINIT() )
  {
    return std::make_unique<UninitializedValue>( location_for( *ctx ) );
  }
  if ( auto regex = ctx->REGEXP_LITERAL() )
  {
    return regular_expression_value( regex );
  }
  location_for( *ctx ).internal_error( "unhandled literal" );
}

int ValueBuilder::to_int( EscriptParser::IntegerLiteralContext* ctx )
{
  try
  {
    if ( auto decimal_literal = ctx->DECIMAL_LITERAL() )
    {
      return std::stoi( decimal_literal->getSymbol()->getText() );
    }
    if ( auto hex_literal = ctx->HEX_LITERAL() )
    {
      return static_cast<int>( std::stoul( hex_literal->getSymbol()->getText(), nullptr, 16 ) );
    }
    if ( auto oct_literal = ctx->OCT_LITERAL() )
    {
      return std::stoi( oct_literal->getSymbol()->getText(), nullptr, 8 );
    }
    if ( auto binary_literal = ctx->BINARY_LITERAL() )
    {
      return std::stoi( binary_literal->getSymbol()->getText(), nullptr, 2 );
    }
  }
  catch ( std::invalid_argument& )
  {
    report.error( location_for( *ctx ), "unable to convert integer value '{}'.", ctx->getText() );
    throw;
  }
  catch ( std::out_of_range& )
  {
    report.error( location_for( *ctx ), "integer value '{}' out of range.", ctx->getText() );
    throw;
  }

  location_for( *ctx ).internal_error( "unhandled integer literal" );
}

}  // namespace Pol::Bscript::Compiler

1	#include "ValueBuilder.h"
2
3	#include <cstring>
4
5	#include "bscript/compiler/Report.h"
6	#include "bscript/compiler/ast/BooleanValue.h"
7	#include "bscript/compiler/ast/FloatValue.h"
8	#include "bscript/compiler/ast/FunctionExpression.h"
9	#include "bscript/compiler/ast/FunctionReference.h"
10	#include "bscript/compiler/ast/IntegerValue.h"
11	#include "bscript/compiler/ast/RegularExpressionValue.h"
12	#include "bscript/compiler/ast/StringValue.h"
13	#include "bscript/compiler/ast/UninitializedValue.h"
14	#include "bscript/compiler/astbuilder/BuilderWorkspace.h"
15	#include "bscript/compiler/file/SourceLocation.h"
16	#include "bscript/compiler/model/CompilerWorkspace.h"
17	#include "bscript/compiler/model/FunctionLink.h"
18	#include "clib/strutil.h"
19
20	using EscriptGrammar::EscriptParser;
21
22	namespace Pol::Bscript::Compiler
23	{
24	ValueBuilder::ValueBuilder( const SourceFileIdentifier& source_file_identifier,	13,355✔
25	BuilderWorkspace& workspace )	13,355✔
26	: TreeBuilder( source_file_identifier, workspace ), current_scope_name( ScopeName::Global )	13,355✔
27	{
28	in_constructor_function.push( false );	13,355✔
29	}	13,355✔
30
31	std::unique_ptr<BooleanValue> ValueBuilder::bool_value(	467✔
32	EscriptGrammar::EscriptParser::BoolLiteralContext* ctx )
33	{
34	bool value;
35	auto loc = location_for( *ctx );	467✔
36
37	if ( ctx->BOOL_TRUE() )	467✔
38	{
39	value = true;	270✔
40	}
41	else if ( ctx->BOOL_FALSE() )	197✔
42	{
43	value = false;	197✔
44	}
45	else
46	{
47	location_for( *ctx ).internal_error( "unhandled boolean literal" );	×
48	}
49
50	return std::make_unique<BooleanValue>( loc, value );	934✔
51	}
52
53	std::unique_ptr<FloatValue> ValueBuilder::float_value(	723✔
54	EscriptGrammar::EscriptParser::FloatLiteralContext* ctx )
55	{
56	auto loc = location_for( *ctx );	723✔
57	auto terminal = ctx->FLOAT_LITERAL();	723✔
58	if ( !terminal )	723✔
59	{
60	terminal = ctx->HEX_FLOAT_LITERAL();	9✔
61	if ( !terminal )	9✔
62	{
63	location_for( *ctx ).internal_error( "unhandled float literal" );	×
64	}
65	}
66	double value = std::stod( text( terminal ) );	723✔
67	return std::make_unique<FloatValue>( loc, value );	1,446✔
68	}
69
70	std::unique_ptr<FunctionReference> ValueBuilder::function_reference(	765✔
71	EscriptParser::FunctionReferenceContext* ctx )
72	{
73	auto source_location = location_for( *ctx );	765✔
74
75	auto name = text( ctx->function );	765✔
76	auto scope = ctx->scope ? ScopeName( text( ctx->scope ) ) // scope exists	809✔
77	: ctx->COLONCOLON() ? ScopeName::Global // colon exists	721✔
78	: ScopeName::None; // has no scope specified	1,530✔
79
80	auto function_link =
81	std::make_shared<FunctionLink>( source_location, current_scope_name.string() );	765✔
82	auto function_reference =
83	std::make_unique<FunctionReference>( source_location, name, function_link );	765✔
84
85	workspace.function_resolver.register_function_link( ScopableName( scope, name ), function_link );	765✔
86
87	return function_reference;	1,530✔
88	}	765✔
89
90	std::unique_ptr<FunctionExpression> ValueBuilder::function_expression(	675✔
91	EscriptGrammar::EscriptParser::FunctionExpressionContext* ctx )
92	{
93	auto loc = location_for( *ctx );	675✔
94	auto name = workspace.function_resolver.register_function_expression( loc, ctx );	675✔
95
96	workspace.compiler_workspace.all_function_locations.emplace( name, loc );	675✔
97	workspace.function_resolver.force_reference( ScopableName( ScopeName::Global, name ), loc );	675✔
98
99	auto function_link =
100	std::make_shared<FunctionLink>( loc, current_scope_name.string() /* calling scope */ );	675✔
101
102	// A unique name, as it is based on source location, so registering the link
103	// in global scope is okay.
104	workspace.function_resolver.register_function_link( ScopableName( ScopeName::Global, name ),	675✔
105	function_link );
106
107	return std::make_unique<FunctionExpression>( loc, function_link );	1,350✔
108	}	675✔
109
110	std::unique_ptr<IntegerValue> ValueBuilder::integer_value(	221,359✔
111	EscriptParser::IntegerLiteralContext* ctx )
112	{
113	auto loc = location_for( *ctx );	221,359✔
114	return std::make_unique<IntegerValue>( loc, to_int( ctx ) );	442,716✔
115	}
116
117	std::unique_ptr<StringValue> ValueBuilder::string_value( antlr4::tree::TerminalNode* string_literal,	48,310✔
118	bool expect_quotes )
119	{
120	auto loc = location_for( *string_literal );	48,310✔
121	return std::make_unique<StringValue>( loc, unquote( string_literal, expect_quotes ) );	96,620✔
122	}
123
124	std::unique_ptr<RegularExpressionValue> ValueBuilder::regular_expression_value(	150✔
125	antlr4::tree::TerminalNode* regular_expression_literal )
126	{
127	std::string input = regular_expression_literal->getSymbol()->getText();	150✔
128
129	std::string pattern;	150✔
130	std::string flags;	150✔
131
132	std::size_t pos = input.rfind( '/' );	150✔
133
134	if ( input.size() < 2 \|\| input[0] != '/' \|\| pos == std::string::npos )	150✔
135	{
136	location_for( *regular_expression_literal )	×
137	.internal_error( "regular expression does not begin with a slash?" );	×
138	}
139
140	pattern = input.substr( 1, pos - 1 );	150✔
141	flags = input.substr( pos + 1 );	150✔
142
143	auto loc = location_for( *regular_expression_literal );	150✔
144	return std::make_unique<RegularExpressionValue>( loc, std::move( pattern ), std::move( flags ) );	300✔
145	}	150✔
146
147	std::string ValueBuilder::unquote( antlr4::tree::TerminalNode* string_literal, bool expect_quotes )	48,924✔
148	{
149	std::string input = string_literal->getSymbol()->getText();	48,924✔
150	const char* s = input.c_str();	48,924✔
151	if ( *s != '\"' && expect_quotes )	48,924✔
152	location_for( *string_literal ).internal_error( "string does not begin with a quote?" );	×
153
154	const char* end = s + ( expect_quotes ? 1 : 0 );	48,924✔
155	std::string lit;	48,924✔
156	lit.reserve( input.length() );	48,924✔
157	bool escnext = false; // true when waiting for 2nd char in an escape sequence	48,924✔
158	u8 hexnext = 0; // tells how many more chars in a \xNN escape sequence	48,924✔
159	char hexstr[3]; // will contain the \x escape chars to be processed
160	memset( hexstr, 0, 3 );	48,924✔
161
162	for ( ;; )
163	{
164	if ( !*end )	388,328✔
165	{
166	if ( !expect_quotes )	3,961✔
167	break;	3,961✔
168	// parser should catch this.
169	location_for( *string_literal ).internal_error( "unterminated string" );	×
170	}
171
172	if ( escnext && hexnext )	384,367✔
173	location_for( *string_literal )	×
174	.internal_error( "Bug in the compiler. Please report this on the forums." );	×
175
176	if ( escnext )	384,367✔
177	{
178	// waiting for 2nd character after a backslash
179	escnext = false;	15,687✔
180	if ( *end == 'n' )	15,687✔
181	lit += '\n';	180✔
182	else if ( *end == 't' )	15,507✔
183	lit += '\t';	19✔
184	else if ( *end == 'x' )	15,488✔
185	hexnext = 2;	15,324✔
186	else
187	lit += *end;	164✔
188	}
189	else if ( hexnext )	368,680✔
190	{
191	// waiting for next (two) chars in hex escape sequence (eg. \xFF)
192	hexstr[2 - hexnext] = *end;	30,648✔
193	if ( !--hexnext )	30,648✔
194	{
195	char* endptr;
196	char ord = static_cast<char>( strtol( hexstr, &endptr, 16 ) );	15,324✔
197	if ( *endptr != '\0' )	15,324✔
198	{
199	report.error( location_for( *string_literal ), "Invalid hex escape sequence '{}'.",	×
200	hexstr );
201	return lit;	×
202	}
203	lit += ord;	15,324✔
204	}
205	}
206	else
207	{
208	if ( *end == '\\' )	338,032✔
209	escnext = true;	15,687✔
210	else if ( *end == '\"' )	322,345✔
211	break;	44,963✔
212	else
213	lit += *end;	277,382✔
214	}
215	++end;	339,404✔
216	}	339,404✔
217	if ( !Clib::isValidUnicode( lit ) )	48,924✔
218	{
219	report.warning( location_for( *string_literal ),	×
220	"Warning: invalid unicode character detected. Assuming ISO8859." );
221
222	Clib::sanitizeUnicodeWithIso( &lit );	×
223	}
224	return lit;	48,924✔
225	}	48,924✔
226
227	std::unique_ptr<Value> ValueBuilder::value( EscriptParser::LiteralContext* ctx )	266,964✔
228	{
229	if ( auto string_literal = ctx->STRING_LITERAL() )	266,964✔
230	{
231	return string_value( string_literal );	44,248✔
232	}
233	if ( auto integer_literal = ctx->integerLiteral() )	222,716✔
234	{
235	return integer_value( integer_literal );	221,265✔
236	}
237	if ( auto float_literal = ctx->floatLiteral() )	1,451✔
238	{
239	return float_value( float_literal );	723✔
240	}
241	if ( auto bool_literal = ctx->boolLiteral() )	728✔
242	{
243	return bool_value( bool_literal );	455✔
244	}
245	if ( ctx->UNINIT() )	273✔
246	{
247	return std::make_unique<UninitializedValue>( location_for( *ctx ) );	123✔
248	}
249	if ( auto regex = ctx->REGEXP_LITERAL() )	150✔
250	{
251	return regular_expression_value( regex );	150✔
252	}
NEW 253	location_for( *ctx ).internal_error( "unhandled literal" );	×
254	}
255
256	int ValueBuilder::to_int( EscriptParser::IntegerLiteralContext* ctx )	221,359✔
257	{
258	try
259	{
260	if ( auto decimal_literal = ctx->DECIMAL_LITERAL() )	221,359✔
261	{
262	return std::stoi( decimal_literal->getSymbol()->getText() );	188,852✔
263	}
264	if ( auto hex_literal = ctx->HEX_LITERAL() )	32,509✔
265	{
266	return static_cast<int>( std::stoul( hex_literal->getSymbol()->getText(), nullptr, 16 ) );	32,500✔
267	}
268	if ( auto oct_literal = ctx->OCT_LITERAL() )	9✔
269	{
270	return std::stoi( oct_literal->getSymbol()->getText(), nullptr, 8 );	9✔
271	}
NEW 272	if ( auto binary_literal = ctx->BINARY_LITERAL() )	×
273	{
274	return std::stoi( binary_literal->getSymbol()->getText(), nullptr, 2 );	×
275	}
276	}
277	catch ( std::invalid_argument& )	2✔
278	{
279	report.error( location_for( *ctx ), "unable to convert integer value '{}'.", ctx->getText() );	×
280	throw;	×
281	}	×
282	catch ( std::out_of_range& )	2✔
283	{
284	report.error( location_for( *ctx ), "integer value '{}' out of range.", ctx->getText() );	2✔
285	throw;	2✔
286	}	2✔
287
288	location_for( *ctx ).internal_error( "unhandled integer literal" );	×
289	}
290
291	} // namespace Pol::Bscript::Compiler

polserver / polserver / 21100551564

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