procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

compiler: pass a Location to import_expression

Browse source 
Separate the Location that import_expression uses when creating a new
    Expression from the Location used to report an error.  This is a step
    toward importing expressions for inlined functions.  This is a pure
    refactoring that does not affect compiler behavior.
    
    Reviewed-on: https://go-review.googlesource.com/c/150064

From-SVN: r266525
This commit is contained in:
Ian Lance Taylor 2018-11-27 19:57:45 +00:00
parent 98f33efc5a
commit 593570593e
6 changed files with 57 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
gcc/go/gofrontend/MERGE
View file

@ -1,4 +1,4 @@
db5240278b3b62a919dd88f857e718a66be50346
75d48ff977a2865d12b03857362ea48016a4b885
The first line of this file holds the git revision number of the last
merge done from the gofrontend repository.

82
gcc/go/gofrontend/expressions.cc
View file

@ -1583,7 +1583,7 @@ class Boolean_expression : public Expression
{ }
static Expression*
do_import(Import*);
do_import(Import*, Location);
protected:
bool
@ -1649,17 +1649,17 @@ Boolean_expression::do_determine_type(const Type_context* context)
// Import a boolean constant.
Expression*
Boolean_expression::do_import(Import* imp)
Boolean_expression::do_import(Import* imp, Location loc)
{
if (imp->peek_char() == 't')
{
imp->require_c_string("true");
return Expression::make_boolean(true, imp->location());
return Expression::make_boolean(true, loc);
}
else
{
imp->require_c_string("false");
return Expression::make_boolean(false, imp->location());
return Expression::make_boolean(false, loc);
}
}
@ -1768,7 +1768,7 @@ String_expression::do_export(Export_function_body* efb) const
// Import a string expression.
Expression*
String_expression::do_import(Import* imp)
String_expression::do_import(Import* imp, Location loc)
{
imp->require_c_string("\"");
std::string val;
@ -1800,11 +1800,11 @@ String_expression::do_import(Import* imp)
else
{
go_error_at(imp->location(), "bad string constant");
return Expression::make_error(imp->location());
return Expression::make_error(loc);
}
}
}
return Expression::make_string(val, imp->location());
return Expression::make_string(val, loc);
}
// Ast dump for string expression.
@ -1944,7 +1944,7 @@ class Integer_expression : public Expression
{ mpz_init_set(this->val_, *val); }
static Expression*
do_import(Import*);
do_import(Import*, Location);
// Write VAL to string dump.
static void
@ -2151,7 +2151,7 @@ Integer_expression::do_export(Export_function_body* efb) const
// all these types because they all start with digits.
Expression*
Integer_expression::do_import(Import* imp)
Integer_expression::do_import(Import* imp, Location loc)
{
std::string num = imp->read_identifier();
imp->require_c_string(" ");
@ -2169,7 +2169,7 @@ Integer_expression::do_import(Import* imp)
{
go_error_at(imp->location(), "bad number in import data: %qs",
num.c_str());
return Expression::make_error(imp->location());
return Expression::make_error(loc);
}
if (pos == std::string::npos)
mpfr_set_ui(real, 0, GMP_RNDN);
@ -2180,7 +2180,7 @@ Integer_expression::do_import(Import* imp)
{
go_error_at(imp->location(), "bad number in import data: %qs",
real_str.c_str());
return Expression::make_error(imp->location());
return Expression::make_error(loc);
}
}
@ -2195,14 +2195,14 @@ Integer_expression::do_import(Import* imp)
{
go_error_at(imp->location(), "bad number in import data: %qs",
imag_str.c_str());
return Expression::make_error(imp->location());
return Expression::make_error(loc);
}
mpc_t cval;
mpc_init2(cval, mpc_precision);
mpc_set_fr_fr(cval, real, imag, MPC_RNDNN);
mpfr_clear(real);
mpfr_clear(imag);
Expression* ret = Expression::make_complex(&cval, NULL, imp->location());
Expression* ret = Expression::make_complex(&cval, NULL, loc);
mpc_clear(cval);
return ret;
}
@ -2218,13 +2218,13 @@ Integer_expression::do_import(Import* imp)
{
go_error_at(imp->location(), "bad number in import data: %qs",
num.c_str());
return Expression::make_error(imp->location());
return Expression::make_error(loc);
}
Expression* ret;
if (is_character_constant)
ret = Expression::make_character(&val, NULL, imp->location());
ret = Expression::make_character(&val, NULL, loc);
else
ret = Expression::make_integer_z(&val, NULL, imp->location());
ret = Expression::make_integer_z(&val, NULL, loc);
mpz_clear(val);
return ret;
}
@ -2235,9 +2235,9 @@ Integer_expression::do_import(Import* imp)
{
go_error_at(imp->location(), "bad number in import data: %qs",
num.c_str());
return Expression::make_error(imp->location());
return Expression::make_error(loc);
}
Expression* ret = Expression::make_float(&val, NULL, imp->location());
Expression* ret = Expression::make_float(&val, NULL, loc);
mpfr_clear(val);
return ret;
}
@ -3133,7 +3133,7 @@ class Nil_expression : public Expression
{ }
static Expression*
do_import(Import*);
do_import(Import*, Location);
protected:
bool
@ -3172,10 +3172,10 @@ class Nil_expression : public Expression
// Import a nil expression.
Expression*
Nil_expression::do_import(Import* imp)
Nil_expression::do_import(Import* imp, Location loc)
{
imp->require_c_string("nil");
return Expression::make_nil(imp->location());
return Expression::make_nil(loc);
}
// Make a nil expression.
@ -3623,14 +3623,14 @@ Type_conversion_expression::do_export(Export_function_body* efb) const
// Import a type conversion or a struct construction.
Expression*
Type_conversion_expression::do_import(Import* imp)
Type_conversion_expression::do_import(Import* imp, Location loc)
{
imp->require_c_string("convert(");
Type* type = imp->read_type();
imp->require_c_string(", ");
Expression* val = Expression::import_expression(imp);
Expression* val = Expression::import_expression(imp, loc);
imp->require_c_string(")");
return Expression::make_cast(type, val, imp->location());
return Expression::make_cast(type, val, loc);
}
// Dump ast representation for a type conversion expression.
@ -4634,7 +4634,7 @@ Unary_expression::do_export(Export_function_body* efb) const
// Import a unary expression.
Expression*
Unary_expression::do_import(Import* imp)
Unary_expression::do_import(Import* imp, Location loc)
{
Operator op;
switch (imp->get_char())
@ -4655,8 +4655,8 @@ Unary_expression::do_import(Import* imp)
go_unreachable();
}
imp->require_c_string(" ");
Expression* expr = Expression::import_expression(imp);
return Expression::make_unary(op, expr, imp->location());
Expression* expr = Expression::import_expression(imp, loc);
return Expression::make_unary(op, expr, loc);
}
// Dump ast representation of an unary expression.
@ -6403,11 +6403,11 @@ Binary_expression::do_export(Export_function_body* efb) const
// Import a binary expression.
Expression*
Binary_expression::do_import(Import* imp)
Binary_expression::do_import(Import* imp, Location loc)
{
imp->require_c_string("(");
Expression* left = Expression::import_expression(imp);
Expression* left = Expression::import_expression(imp, loc);
Operator op;
if (imp->match_c_string(" || "))
@ -6508,14 +6508,14 @@ Binary_expression::do_import(Import* imp)
else
{
go_error_at(imp->location(), "unrecognized binary operator");
return Expression::make_error(imp->location());
return Expression::make_error(loc);
}
Expression* right = Expression::import_expression(imp);
Expression* right = Expression::import_expression(imp, loc);
imp->require_c_string(")");
return Expression::make_binary(op, left, right, imp->location());
return Expression::make_binary(op, left, right, loc);
}
// Dump ast representation of a binary expression.
@ -16138,33 +16138,33 @@ Expression::make_backend(Bexpression* bexpr, Type* type, Location location)
// various class definitions.
Expression*
Expression::import_expression(Import* imp)
Expression::import_expression(Import* imp, Location loc)
{
int c = imp->peek_char();
if (imp->match_c_string("- ")
|| imp->match_c_string("! ")
|| imp->match_c_string("^ "))
return Unary_expression::do_import(imp);
return Unary_expression::do_import(imp, loc);
else if (c == '(')
return Binary_expression::do_import(imp);
return Binary_expression::do_import(imp, loc);
else if (imp->match_c_string("true")
|| imp->match_c_string("false"))
return Boolean_expression::do_import(imp);
return Boolean_expression::do_import(imp, loc);
else if (c == '"')
return String_expression::do_import(imp);
return String_expression::do_import(imp, loc);
else if (c == '-' || (c >= '0' && c <= '9'))
{
// This handles integers, floats and complex constants.
return Integer_expression::do_import(imp);
return Integer_expression::do_import(imp, loc);
}
else if (imp->match_c_string("nil"))
return Nil_expression::do_import(imp);
return Nil_expression::do_import(imp, loc);
else if (imp->match_c_string("convert"))
return Type_conversion_expression::do_import(imp);
return Type_conversion_expression::do_import(imp, loc);
else
{
go_error_at(imp->location(), "import error: expected expression");
return Expression::make_error(imp->location());
return Expression::make_error(loc);
}
}

14
gcc/go/gofrontend/expressions.h
View file

@ -1014,9 +1014,11 @@ class Expression
export_expression(Export_function_body* efb) const
{ this->do_export(efb); }
// Import an expression.
// Import an expression. The location should be used for the
// returned expression. Errors should be reported using the
// Import's location method.
static Expression*
import_expression(Import*);
import_expression(Import*, Location);
// Return an expression which checks that VAL, of arbitrary integer type,
// is non-negative and is not more than the maximum integer value.
@ -1565,7 +1567,7 @@ class String_expression : public Expression
{ return this->val_; }
static Expression*
do_import(Import*);
do_import(Import*, Location);
protected:
bool
@ -1644,7 +1646,7 @@ class Type_conversion_expression : public Expression
// Import a type conversion expression.
static Expression*
do_import(Import*);
do_import(Import*, Location);
protected:
int
@ -1815,7 +1817,7 @@ class Unary_expression : public Expression
Location, Numeric_constant* nc, bool *issued_error);
static Expression*
do_import(Import*);
do_import(Import*, Location);
// Declare that this deref does or does not require an explicit nil check.
void
@ -1964,7 +1966,7 @@ class Binary_expression : public Expression
bool* result);
static Expression*
do_import(Import*);
do_import(Import*, Location);
// Report an error if OP can not be applied to TYPE. Return whether
// it can. OTYPE is the type of the other operand.

2
gcc/go/gofrontend/gogo.cc
View file

@ -7631,7 +7631,7 @@ Named_constant::import_const(Import* imp, std::string* pname, Type** ptype,
imp->require_c_string(" ");
}
imp->require_c_string("= ");
*pexpr = Expression::import_expression(imp);
*pexpr = Expression::import_expression(imp, imp->location());
imp->require_semicolon_if_old_version();
imp->require_c_string("\n");
}

4
gcc/go/gofrontend/statements.h
View file

@ -338,7 +338,9 @@ class Statement
export_statement(Export_function_body* efb)
{ this->do_export_statement(efb); }
// Read a statement from export data.
// Read a statement from export data. The location should be used
// for the returned statement. Errors should be reported using the
// Import_function_body's location method.
static Statement*
import_statement(Import_function_body*, Location);

5
gcc/go/gofrontend/types.cc
View file

@ -6606,7 +6606,8 @@ Struct_type::do_import(Import* imp)
if (imp->peek_char() == ' ')
{
imp->advance(1);
Expression* expr = Expression::import_expression(imp);
Expression* expr = Expression::import_expression(imp,
imp->location());
String_expression* sexpr = expr->string_expression();
go_assert(sexpr != NULL);
sf.set_tag(sexpr->val());
@ -7568,7 +7569,7 @@ Array_type::do_import(Import* imp)
if (imp->peek_char() == ']')
length = NULL;
else
length = Expression::import_expression(imp);
length = Expression::import_expression(imp, imp->location());
imp->require_c_string("] ");
Type* element_type = imp->read_type();
return Type::make_array_type(element_type, length);