* Go patch committed: Pass a Location to import_expression
@ 2018-11-27 19:58 Ian Lance Taylor
0 siblings, 0 replies; only message in thread
From: Ian Lance Taylor @ 2018-11-27 19:58 UTC (permalink / raw)
To: gcc-patches, gofrontend-dev
[-- Attachment #1: Type: text/plain, Size: 430 bytes --]
This patch changes the Go frontend to pass a Location to
import_expression. This separates 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. Bootstrapped and ran Go testsuite on x86_64-pc-linux-gnu.
Committed to mainline.
Ian
[-- Attachment #2: patch.txt --]
[-- Type: text/plain, Size: 13267 bytes --]
Index: gcc/go/gofrontend/MERGE
===================================================================
--- gcc/go/gofrontend/MERGE (revision 266523)
+++ gcc/go/gofrontend/MERGE (working copy)
@@ -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.
Index: gcc/go/gofrontend/expressions.cc
===================================================================
--- gcc/go/gofrontend/expressions.cc (revision 266523)
+++ gcc/go/gofrontend/expressions.cc (working copy)
@@ -1583,7 +1583,7 @@ class Boolean_expression : public Expres
{ }
static Expression*
- do_import(Import*);
+ do_import(Import*, Location);
protected:
bool
@@ -1649,17 +1649,17 @@ Boolean_expression::do_determine_type(co
// 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_func
// 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 Expres
{ 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_fun
// 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* im
{
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* im
{
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* im
{
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* im
{
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* im
{
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(Ex
// 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_funct
// 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_func
// 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* be
// 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);
}
}
Index: gcc/go/gofrontend/expressions.h
===================================================================
--- gcc/go/gofrontend/expressions.h (revision 266523)
+++ gcc/go/gofrontend/expressions.h (working copy)
@@ -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 Express
{ return this->val_; }
static Expression*
- do_import(Import*);
+ do_import(Import*, Location);
protected:
bool
@@ -1644,7 +1646,7 @@ class Type_conversion_expression : publi
// Import a type conversion expression.
static Expression*
- do_import(Import*);
+ do_import(Import*, Location);
protected:
int
@@ -1815,7 +1817,7 @@ class Unary_expression : public Expressi
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 Express
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.
Index: gcc/go/gofrontend/gogo.cc
===================================================================
--- gcc/go/gofrontend/gogo.cc (revision 266523)
+++ gcc/go/gofrontend/gogo.cc (working copy)
@@ -7631,7 +7631,7 @@ Named_constant::import_const(Import* imp
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");
}
Index: gcc/go/gofrontend/statements.h
===================================================================
--- gcc/go/gofrontend/statements.h (revision 266517)
+++ gcc/go/gofrontend/statements.h (working copy)
@@ -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);
Index: gcc/go/gofrontend/types.cc
===================================================================
--- gcc/go/gofrontend/types.cc (revision 266523)
+++ gcc/go/gofrontend/types.cc (working copy)
@@ -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);
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2018-11-27 19:58 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-11-27 19:58 Go patch committed: Pass a Location to import_expression Ian Lance Taylor
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).