1 // parse.cc -- Go frontend parser.
3 // Copyright 2009 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
12 #include "statements.h"
13 #include "expressions.h"
16 // Struct Parse::Enclosing_var_comparison.
18 // Return true if v1 should be considered to be less than v2.
21 Parse::Enclosing_var_comparison::operator()(const Enclosing_var& v1,
22 const Enclosing_var& v2)
24 if (v1.var() == v2.var())
27 const std::string& n1(v1.var()->name());
28 const std::string& n2(v2.var()->name());
29 int i = n1.compare(n2);
35 // If we get here it means that a single nested function refers to
36 // two different variables defined in enclosing functions, and both
37 // variables have the same name. I think this is impossible.
43 Parse::Parse(Lex* lex, Gogo* gogo)
45 token_(Token::make_invalid_token(0)),
46 unget_token_(Token::make_invalid_token(0)),
47 unget_token_valid_(false),
50 continue_stack_(NULL),
56 // Return the current token.
61 if (this->unget_token_valid_)
62 return &this->unget_token_;
63 if (this->token_.is_invalid())
64 this->token_ = this->lex_->next_token();
68 // Advance to the next token and return it.
71 Parse::advance_token()
73 if (this->unget_token_valid_)
75 this->unget_token_valid_ = false;
76 if (!this->token_.is_invalid())
79 this->token_ = this->lex_->next_token();
83 // Push a token back on the input stream.
86 Parse::unget_token(const Token& token)
88 gcc_assert(!this->unget_token_valid_);
89 this->unget_token_ = token;
90 this->unget_token_valid_ = true;
93 // The location of the current token.
98 return this->peek_token()->location();
101 // IdentifierList = identifier { "," identifier } .
104 Parse::identifier_list(Typed_identifier_list* til)
106 const Token* token = this->peek_token();
109 if (!token->is_identifier())
111 error_at(this->location(), "expected identifier");
115 this->gogo_->pack_hidden_name(token->identifier(),
116 token->is_identifier_exported());
117 til->push_back(Typed_identifier(name, NULL, token->location()));
118 token = this->advance_token();
119 if (!token->is_op(OPERATOR_COMMA))
121 token = this->advance_token();
125 // ExpressionList = Expression { "," Expression } .
127 // If MAY_BE_SINK is true, the expressions in the list may be "_".
130 Parse::expression_list(Expression* first, bool may_be_sink)
132 Expression_list* ret = new Expression_list();
134 ret->push_back(first);
137 ret->push_back(this->expression(PRECEDENCE_NORMAL, may_be_sink, true,
140 const Token* token = this->peek_token();
141 if (!token->is_op(OPERATOR_COMMA))
144 // Most expression lists permit a trailing comma.
145 source_location location = token->location();
146 this->advance_token();
147 if (!this->expression_may_start_here())
149 this->unget_token(Token::make_operator_token(OPERATOR_COMMA,
156 // QualifiedIdent = [ PackageName "." ] identifier .
157 // PackageName = identifier .
159 // This sets *PNAME to the identifier and sets *PPACKAGE to the
160 // package or NULL if there isn't one. This returns true on success,
161 // false on failure in which case it will have emitted an error
165 Parse::qualified_ident(std::string* pname, Named_object** ppackage)
167 const Token* token = this->peek_token();
168 if (!token->is_identifier())
170 error_at(this->location(), "expected identifier");
174 std::string name = token->identifier();
175 bool is_exported = token->is_identifier_exported();
176 name = this->gogo_->pack_hidden_name(name, is_exported);
178 token = this->advance_token();
179 if (!token->is_op(OPERATOR_DOT))
186 Named_object* package = this->gogo_->lookup(name, NULL);
187 if (package == NULL || !package->is_package())
189 error_at(this->location(), "expected package");
190 // We expect . IDENTIFIER; skip both.
191 if (this->advance_token()->is_identifier())
192 this->advance_token();
196 package->package_value()->set_used();
198 token = this->advance_token();
199 if (!token->is_identifier())
201 error_at(this->location(), "expected identifier");
205 name = token->identifier();
209 error_at(this->location(), "invalid use of %<_%>");
213 if (package->name() == this->gogo_->package_name())
214 name = this->gogo_->pack_hidden_name(name,
215 token->is_identifier_exported());
220 this->advance_token();
225 // Type = TypeName | TypeLit | "(" Type ")" .
227 // ArrayType | StructType | PointerType | FunctionType | InterfaceType |
228 // SliceType | MapType | ChannelType .
233 const Token* token = this->peek_token();
234 if (token->is_identifier())
235 return this->type_name(true);
236 else if (token->is_op(OPERATOR_LSQUARE))
237 return this->array_type(false);
238 else if (token->is_keyword(KEYWORD_CHAN)
239 || token->is_op(OPERATOR_CHANOP))
240 return this->channel_type();
241 else if (token->is_keyword(KEYWORD_INTERFACE))
242 return this->interface_type();
243 else if (token->is_keyword(KEYWORD_FUNC))
245 source_location location = token->location();
246 this->advance_token();
247 Type* type = this->signature(NULL, location);
249 return Type::make_error_type();
252 else if (token->is_keyword(KEYWORD_MAP))
253 return this->map_type();
254 else if (token->is_keyword(KEYWORD_STRUCT))
255 return this->struct_type();
256 else if (token->is_op(OPERATOR_MULT))
257 return this->pointer_type();
258 else if (token->is_op(OPERATOR_LPAREN))
260 this->advance_token();
261 Type* ret = this->type();
262 if (this->peek_token()->is_op(OPERATOR_RPAREN))
263 this->advance_token();
266 if (!ret->is_error_type())
267 error_at(this->location(), "expected %<)%>");
273 error_at(token->location(), "expected type");
274 return Type::make_error_type();
279 Parse::type_may_start_here()
281 const Token* token = this->peek_token();
282 return (token->is_identifier()
283 || token->is_op(OPERATOR_LSQUARE)
284 || token->is_op(OPERATOR_CHANOP)
285 || token->is_keyword(KEYWORD_CHAN)
286 || token->is_keyword(KEYWORD_INTERFACE)
287 || token->is_keyword(KEYWORD_FUNC)
288 || token->is_keyword(KEYWORD_MAP)
289 || token->is_keyword(KEYWORD_STRUCT)
290 || token->is_op(OPERATOR_MULT)
291 || token->is_op(OPERATOR_LPAREN));
294 // TypeName = QualifiedIdent .
296 // If MAY_BE_NIL is true, then an identifier with the value of the
297 // predefined constant nil is accepted, returning the nil type.
300 Parse::type_name(bool issue_error)
302 source_location location = this->location();
305 Named_object* package;
306 if (!this->qualified_ident(&name, &package))
307 return Type::make_error_type();
309 Named_object* named_object;
311 named_object = this->gogo_->lookup(name, NULL);
314 named_object = package->package_value()->lookup(name);
315 if (named_object == NULL
317 && package->name() != this->gogo_->package_name())
319 // Check whether the name is there but hidden.
320 std::string s = ('.' + package->package_value()->unique_prefix()
321 + '.' + package->package_value()->name()
323 named_object = package->package_value()->lookup(s);
324 if (named_object != NULL)
326 const std::string& packname(package->package_value()->name());
327 error_at(location, "invalid reference to hidden type %<%s.%s%>",
328 Gogo::message_name(packname).c_str(),
329 Gogo::message_name(name).c_str());
336 if (named_object == NULL)
341 named_object = this->gogo_->add_unknown_name(name, location);
343 else if (named_object->is_type())
345 if (!named_object->type_value()->is_visible())
348 else if (named_object->is_unknown() || named_object->is_type_declaration())
356 error_at(location, "expected type");
357 return Type::make_error_type();
360 if (named_object->is_type())
361 return named_object->type_value();
362 else if (named_object->is_unknown() || named_object->is_type_declaration())
363 return Type::make_forward_declaration(named_object);
368 // ArrayType = "[" [ ArrayLength ] "]" ElementType .
369 // ArrayLength = Expression .
370 // ElementType = CompleteType .
373 Parse::array_type(bool may_use_ellipsis)
375 gcc_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
376 const Token* token = this->advance_token();
378 Expression* length = NULL;
379 if (token->is_op(OPERATOR_RSQUARE))
380 this->advance_token();
383 if (!token->is_op(OPERATOR_ELLIPSIS))
384 length = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
385 else if (may_use_ellipsis)
387 // An ellipsis is used in composite literals to represent a
388 // fixed array of the size of the number of elements. We
389 // use a length of nil to represent this, and change the
390 // length when parsing the composite literal.
391 length = Expression::make_nil(this->location());
392 this->advance_token();
396 error_at(this->location(),
397 "use of %<[...]%> outside of array literal");
398 length = Expression::make_error(this->location());
399 this->advance_token();
401 if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
403 error_at(this->location(), "expected %<]%>");
404 return Type::make_error_type();
406 this->advance_token();
409 Type* element_type = this->type();
411 return Type::make_array_type(element_type, length);
414 // MapType = "map" "[" KeyType "]" ValueType .
415 // KeyType = CompleteType .
416 // ValueType = CompleteType .
421 source_location location = this->location();
422 gcc_assert(this->peek_token()->is_keyword(KEYWORD_MAP));
423 if (!this->advance_token()->is_op(OPERATOR_LSQUARE))
425 error_at(this->location(), "expected %<[%>");
426 return Type::make_error_type();
428 this->advance_token();
430 Type* key_type = this->type();
432 if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
434 error_at(this->location(), "expected %<]%>");
435 return Type::make_error_type();
437 this->advance_token();
439 Type* value_type = this->type();
441 if (key_type->is_error_type() || value_type->is_error_type())
442 return Type::make_error_type();
444 return Type::make_map_type(key_type, value_type, location);
447 // StructType = "struct" "{" { FieldDecl ";" } "}" .
452 gcc_assert(this->peek_token()->is_keyword(KEYWORD_STRUCT));
453 source_location location = this->location();
454 if (!this->advance_token()->is_op(OPERATOR_LCURLY))
456 source_location token_loc = this->location();
457 if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
458 && this->advance_token()->is_op(OPERATOR_LCURLY))
459 error_at(token_loc, "unexpected semicolon or newline before %<{%>");
462 error_at(this->location(), "expected %<{%>");
463 return Type::make_error_type();
466 this->advance_token();
468 Struct_field_list* sfl = new Struct_field_list;
469 while (!this->peek_token()->is_op(OPERATOR_RCURLY))
471 this->field_decl(sfl);
472 if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
473 this->advance_token();
474 else if (!this->peek_token()->is_op(OPERATOR_RCURLY))
476 error_at(this->location(), "expected %<;%> or %<}%> or newline");
477 if (!this->skip_past_error(OPERATOR_RCURLY))
478 return Type::make_error_type();
481 this->advance_token();
483 for (Struct_field_list::const_iterator pi = sfl->begin();
487 if (pi->type()->is_error_type())
489 for (Struct_field_list::const_iterator pj = pi + 1;
493 if (pi->field_name() == pj->field_name()
494 && !Gogo::is_sink_name(pi->field_name()))
495 error_at(pi->location(), "duplicate field name %<%s%>",
496 Gogo::message_name(pi->field_name()).c_str());
500 return Type::make_struct_type(sfl, location);
503 // FieldDecl = (IdentifierList CompleteType | TypeName) [ Tag ] .
504 // Tag = string_lit .
507 Parse::field_decl(Struct_field_list* sfl)
509 const Token* token = this->peek_token();
510 source_location location = token->location();
512 bool is_anonymous_pointer;
513 if (token->is_op(OPERATOR_MULT))
516 is_anonymous_pointer = true;
518 else if (token->is_identifier())
520 std::string id = token->identifier();
521 bool is_id_exported = token->is_identifier_exported();
522 source_location id_location = token->location();
523 token = this->advance_token();
524 is_anonymous = (token->is_op(OPERATOR_SEMICOLON)
525 || token->is_op(OPERATOR_RCURLY)
526 || token->is_op(OPERATOR_DOT)
527 || token->is_string());
528 is_anonymous_pointer = false;
529 this->unget_token(Token::make_identifier_token(id, is_id_exported,
534 error_at(this->location(), "expected field name");
535 while (!token->is_op(OPERATOR_SEMICOLON)
536 && !token->is_op(OPERATOR_RCURLY)
538 token = this->advance_token();
544 if (is_anonymous_pointer)
546 this->advance_token();
547 if (!this->peek_token()->is_identifier())
549 error_at(this->location(), "expected field name");
550 while (!token->is_op(OPERATOR_SEMICOLON)
551 && !token->is_op(OPERATOR_RCURLY)
553 token = this->advance_token();
557 Type* type = this->type_name(true);
560 if (this->peek_token()->is_string())
562 tag = this->peek_token()->string_value();
563 this->advance_token();
566 if (!type->is_error_type())
568 if (is_anonymous_pointer)
569 type = Type::make_pointer_type(type);
570 sfl->push_back(Struct_field(Typed_identifier("", type, location)));
572 sfl->back().set_tag(tag);
577 Typed_identifier_list til;
580 token = this->peek_token();
581 if (!token->is_identifier())
583 error_at(this->location(), "expected identifier");
587 this->gogo_->pack_hidden_name(token->identifier(),
588 token->is_identifier_exported());
589 til.push_back(Typed_identifier(name, NULL, token->location()));
590 if (!this->advance_token()->is_op(OPERATOR_COMMA))
592 this->advance_token();
595 Type* type = this->type();
598 if (this->peek_token()->is_string())
600 tag = this->peek_token()->string_value();
601 this->advance_token();
604 for (Typed_identifier_list::iterator p = til.begin();
609 sfl->push_back(Struct_field(*p));
611 sfl->back().set_tag(tag);
616 // PointerType = "*" Type .
619 Parse::pointer_type()
621 gcc_assert(this->peek_token()->is_op(OPERATOR_MULT));
622 this->advance_token();
623 Type* type = this->type();
624 if (type->is_error_type())
626 return Type::make_pointer_type(type);
629 // ChannelType = Channel | SendChannel | RecvChannel .
630 // Channel = "chan" ElementType .
631 // SendChannel = "chan" "<-" ElementType .
632 // RecvChannel = "<-" "chan" ElementType .
635 Parse::channel_type()
637 const Token* token = this->peek_token();
640 if (token->is_op(OPERATOR_CHANOP))
642 if (!this->advance_token()->is_keyword(KEYWORD_CHAN))
644 error_at(this->location(), "expected %<chan%>");
645 return Type::make_error_type();
648 this->advance_token();
652 gcc_assert(token->is_keyword(KEYWORD_CHAN));
653 if (this->advance_token()->is_op(OPERATOR_CHANOP))
656 this->advance_token();
659 Type* element_type = this->type();
660 return Type::make_channel_type(send, receive, element_type);
663 // Signature = Parameters [ Result ] .
665 // RECEIVER is the receiver if there is one, or NULL. LOCATION is the
666 // location of the start of the type.
668 // This returns NULL on a parse error.
671 Parse::signature(Typed_identifier* receiver, source_location location)
673 bool is_varargs = false;
674 Typed_identifier_list* params;
675 bool params_ok = this->parameters(¶ms, &is_varargs);
677 Typed_identifier_list* result = NULL;
678 if (this->peek_token()->is_op(OPERATOR_LPAREN)
679 || this->type_may_start_here())
681 if (!this->result(&result))
688 Function_type* ret = Type::make_function_type(receiver, params, result,
691 ret->set_is_varargs();
695 // Parameters = "(" [ ParameterList [ "," ] ] ")" .
697 // This returns false on a parse error.
700 Parse::parameters(Typed_identifier_list** pparams, bool* is_varargs)
704 if (!this->peek_token()->is_op(OPERATOR_LPAREN))
706 error_at(this->location(), "expected %<(%>");
710 Typed_identifier_list* params = NULL;
711 bool saw_error = false;
713 const Token* token = this->advance_token();
714 if (!token->is_op(OPERATOR_RPAREN))
716 params = this->parameter_list(is_varargs);
719 token = this->peek_token();
722 // The optional trailing comma is picked up in parameter_list.
724 if (!token->is_op(OPERATOR_RPAREN))
725 error_at(this->location(), "expected %<)%>");
727 this->advance_token();
736 // ParameterList = ParameterDecl { "," ParameterDecl } .
738 // This sets *IS_VARARGS if the list ends with an ellipsis.
739 // IS_VARARGS will be NULL if varargs are not permitted.
741 // We pick up an optional trailing comma.
743 // This returns NULL if some error is seen.
745 Typed_identifier_list*
746 Parse::parameter_list(bool* is_varargs)
748 source_location location = this->location();
749 Typed_identifier_list* ret = new Typed_identifier_list();
751 bool saw_error = false;
753 // If we see an identifier and then a comma, then we don't know
754 // whether we are looking at a list of identifiers followed by a
755 // type, or a list of types given by name. We have to do an
756 // arbitrary lookahead to figure it out.
758 bool parameters_have_names;
759 const Token* token = this->peek_token();
760 if (!token->is_identifier())
762 // This must be a type which starts with something like '*'.
763 parameters_have_names = false;
767 std::string name = token->identifier();
768 bool is_exported = token->is_identifier_exported();
769 source_location location = token->location();
770 token = this->advance_token();
771 if (!token->is_op(OPERATOR_COMMA))
773 if (token->is_op(OPERATOR_DOT))
775 // This is a qualified identifier, which must turn out
777 parameters_have_names = false;
779 else if (token->is_op(OPERATOR_RPAREN))
781 // A single identifier followed by a parenthesis must be
783 parameters_have_names = false;
787 // An identifier followed by something other than a
788 // comma or a dot or a right parenthesis must be a
789 // parameter name followed by a type.
790 parameters_have_names = true;
793 this->unget_token(Token::make_identifier_token(name, is_exported,
798 // An identifier followed by a comma may be the first in a
799 // list of parameter names followed by a type, or it may be
800 // the first in a list of types without parameter names. To
801 // find out we gather as many identifiers separated by
803 std::string id_name = this->gogo_->pack_hidden_name(name,
805 ret->push_back(Typed_identifier(id_name, NULL, location));
806 bool just_saw_comma = true;
807 while (this->advance_token()->is_identifier())
809 name = this->peek_token()->identifier();
810 is_exported = this->peek_token()->is_identifier_exported();
811 location = this->peek_token()->location();
812 id_name = this->gogo_->pack_hidden_name(name, is_exported);
813 ret->push_back(Typed_identifier(id_name, NULL, location));
814 if (!this->advance_token()->is_op(OPERATOR_COMMA))
816 just_saw_comma = false;
823 // We saw ID1 "," ID2 "," followed by something which
824 // was not an identifier. We must be seeing the start
825 // of a type, and ID1 and ID2 must be types, and the
826 // parameters don't have names.
827 parameters_have_names = false;
829 else if (this->peek_token()->is_op(OPERATOR_RPAREN))
831 // We saw ID1 "," ID2 ")". ID1 and ID2 must be types,
832 // and the parameters don't have names.
833 parameters_have_names = false;
835 else if (this->peek_token()->is_op(OPERATOR_DOT))
837 // We saw ID1 "," ID2 ".". ID2 must be a package name,
838 // ID1 must be a type, and the parameters don't have
840 parameters_have_names = false;
841 this->unget_token(Token::make_identifier_token(name, is_exported,
844 just_saw_comma = true;
848 // We saw ID1 "," ID2 followed by something other than
849 // ",", ".", or ")". We must be looking at the start of
850 // a type, and ID1 and ID2 must be parameter names.
851 parameters_have_names = true;
854 if (parameters_have_names)
856 gcc_assert(!just_saw_comma);
857 // We have just seen ID1, ID2 xxx.
859 if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
863 error_at(this->location(), "%<...%> only permits one name");
865 this->advance_token();
868 for (size_t i = 0; i < ret->size(); ++i)
869 ret->set_type(i, type);
870 if (!this->peek_token()->is_op(OPERATOR_COMMA))
871 return saw_error ? NULL : ret;
872 if (this->advance_token()->is_op(OPERATOR_RPAREN))
873 return saw_error ? NULL : ret;
877 Typed_identifier_list* tret = new Typed_identifier_list();
878 for (Typed_identifier_list::const_iterator p = ret->begin();
882 Named_object* no = this->gogo_->lookup(p->name(), NULL);
885 no = this->gogo_->add_unknown_name(p->name(),
889 type = no->type_value();
890 else if (no->is_unknown() || no->is_type_declaration())
891 type = Type::make_forward_declaration(no);
894 error_at(p->location(), "expected %<%s%> to be a type",
895 Gogo::message_name(p->name()).c_str());
897 type = Type::make_error_type();
899 tret->push_back(Typed_identifier("", type, p->location()));
904 || this->peek_token()->is_op(OPERATOR_RPAREN))
905 return saw_error ? NULL : ret;
910 bool mix_error = false;
911 this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
912 while (this->peek_token()->is_op(OPERATOR_COMMA))
914 if (is_varargs != NULL && *is_varargs)
916 error_at(this->location(), "%<...%> must be last parameter");
919 if (this->advance_token()->is_op(OPERATOR_RPAREN))
921 this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
925 error_at(location, "invalid named/anonymous mix");
936 // ParameterDecl = [ IdentifierList ] [ "..." ] Type .
939 Parse::parameter_decl(bool parameters_have_names,
940 Typed_identifier_list* til,
944 if (!parameters_have_names)
947 source_location location = this->location();
948 if (!this->peek_token()->is_identifier())
950 if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
954 if (is_varargs == NULL)
955 error_at(this->location(), "invalid use of %<...%>");
958 this->advance_token();
959 if (is_varargs == NULL
960 && this->peek_token()->is_op(OPERATOR_RPAREN))
961 type = Type::make_error_type();
964 Type* element_type = this->type();
965 type = Type::make_array_type(element_type, NULL);
971 type = this->type_name(false);
972 if (type->is_error_type()
973 || (!this->peek_token()->is_op(OPERATOR_COMMA)
974 && !this->peek_token()->is_op(OPERATOR_RPAREN)))
977 while (!this->peek_token()->is_op(OPERATOR_COMMA)
978 && !this->peek_token()->is_op(OPERATOR_RPAREN))
979 this->advance_token();
982 if (!type->is_error_type())
983 til->push_back(Typed_identifier("", type, location));
987 size_t orig_count = til->size();
988 if (this->peek_token()->is_identifier())
989 this->identifier_list(til);
992 size_t new_count = til->size();
995 if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
999 if (is_varargs == NULL)
1000 error_at(this->location(), "invalid use of %<...%>");
1001 else if (new_count > orig_count + 1)
1002 error_at(this->location(), "%<...%> only permits one name");
1005 this->advance_token();
1006 Type* element_type = this->type();
1007 type = Type::make_array_type(element_type, NULL);
1009 for (size_t i = orig_count; i < new_count; ++i)
1010 til->set_type(i, type);
1014 // Result = Parameters | Type .
1016 // This returns false on a parse error.
1019 Parse::result(Typed_identifier_list** presults)
1021 if (this->peek_token()->is_op(OPERATOR_LPAREN))
1022 return this->parameters(presults, NULL);
1025 source_location location = this->location();
1026 Type* type = this->type();
1027 if (type->is_error_type())
1032 Typed_identifier_list* til = new Typed_identifier_list();
1033 til->push_back(Typed_identifier("", type, location));
1039 // Block = "{" [ StatementList ] "}" .
1041 // Returns the location of the closing brace.
1046 if (!this->peek_token()->is_op(OPERATOR_LCURLY))
1048 source_location loc = this->location();
1049 if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
1050 && this->advance_token()->is_op(OPERATOR_LCURLY))
1051 error_at(loc, "unexpected semicolon or newline before %<{%>");
1054 error_at(this->location(), "expected %<{%>");
1055 return UNKNOWN_LOCATION;
1059 const Token* token = this->advance_token();
1061 if (!token->is_op(OPERATOR_RCURLY))
1063 this->statement_list();
1064 token = this->peek_token();
1065 if (!token->is_op(OPERATOR_RCURLY))
1067 if (!token->is_eof() || !saw_errors())
1068 error_at(this->location(), "expected %<}%>");
1070 // Skip ahead to the end of the block, in hopes of avoiding
1071 // lots of meaningless errors.
1072 source_location ret = token->location();
1074 while (!token->is_eof())
1076 if (token->is_op(OPERATOR_LCURLY))
1078 else if (token->is_op(OPERATOR_RCURLY))
1083 this->advance_token();
1087 token = this->advance_token();
1088 ret = token->location();
1094 source_location ret = token->location();
1095 this->advance_token();
1099 // InterfaceType = "interface" "{" [ MethodSpecList ] "}" .
1100 // MethodSpecList = MethodSpec { ";" MethodSpec } [ ";" ] .
1103 Parse::interface_type()
1105 gcc_assert(this->peek_token()->is_keyword(KEYWORD_INTERFACE));
1106 source_location location = this->location();
1108 if (!this->advance_token()->is_op(OPERATOR_LCURLY))
1110 source_location token_loc = this->location();
1111 if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
1112 && this->advance_token()->is_op(OPERATOR_LCURLY))
1113 error_at(token_loc, "unexpected semicolon or newline before %<{%>");
1116 error_at(this->location(), "expected %<{%>");
1117 return Type::make_error_type();
1120 this->advance_token();
1122 Typed_identifier_list* methods = new Typed_identifier_list();
1123 if (!this->peek_token()->is_op(OPERATOR_RCURLY))
1125 this->method_spec(methods);
1126 while (this->peek_token()->is_op(OPERATOR_SEMICOLON))
1128 if (this->advance_token()->is_op(OPERATOR_RCURLY))
1130 this->method_spec(methods);
1132 if (!this->peek_token()->is_op(OPERATOR_RCURLY))
1134 error_at(this->location(), "expected %<}%>");
1135 while (!this->advance_token()->is_op(OPERATOR_RCURLY))
1137 if (this->peek_token()->is_eof())
1138 return Type::make_error_type();
1142 this->advance_token();
1144 if (methods->empty())
1150 Interface_type* ret = Type::make_interface_type(methods, location);
1151 this->gogo_->record_interface_type(ret);
1155 // MethodSpec = MethodName Signature | InterfaceTypeName .
1156 // MethodName = identifier .
1157 // InterfaceTypeName = TypeName .
1160 Parse::method_spec(Typed_identifier_list* methods)
1162 const Token* token = this->peek_token();
1163 if (!token->is_identifier())
1165 error_at(this->location(), "expected identifier");
1169 std::string name = token->identifier();
1170 bool is_exported = token->is_identifier_exported();
1171 source_location location = token->location();
1173 if (this->advance_token()->is_op(OPERATOR_LPAREN))
1175 // This is a MethodName.
1176 name = this->gogo_->pack_hidden_name(name, is_exported);
1177 Type* type = this->signature(NULL, location);
1180 methods->push_back(Typed_identifier(name, type, location));
1184 this->unget_token(Token::make_identifier_token(name, is_exported,
1186 Type* type = this->type_name(false);
1187 if (type->is_error_type()
1188 || (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
1189 && !this->peek_token()->is_op(OPERATOR_RCURLY)))
1191 if (this->peek_token()->is_op(OPERATOR_COMMA))
1192 error_at(this->location(),
1193 "name list not allowed in interface type");
1195 error_at(location, "expected signature or type name");
1196 token = this->peek_token();
1197 while (!token->is_eof()
1198 && !token->is_op(OPERATOR_SEMICOLON)
1199 && !token->is_op(OPERATOR_RCURLY))
1200 token = this->advance_token();
1203 // This must be an interface type, but we can't check that now.
1204 // We check it and pull out the methods in
1205 // Interface_type::do_verify.
1206 methods->push_back(Typed_identifier("", type, location));
1210 // Declaration = ConstDecl | TypeDecl | VarDecl | FunctionDecl | MethodDecl .
1213 Parse::declaration()
1215 const Token* token = this->peek_token();
1216 if (token->is_keyword(KEYWORD_CONST))
1218 else if (token->is_keyword(KEYWORD_TYPE))
1220 else if (token->is_keyword(KEYWORD_VAR))
1222 else if (token->is_keyword(KEYWORD_FUNC))
1223 this->function_decl();
1226 error_at(this->location(), "expected declaration");
1227 this->advance_token();
1232 Parse::declaration_may_start_here()
1234 const Token* token = this->peek_token();
1235 return (token->is_keyword(KEYWORD_CONST)
1236 || token->is_keyword(KEYWORD_TYPE)
1237 || token->is_keyword(KEYWORD_VAR)
1238 || token->is_keyword(KEYWORD_FUNC));
1241 // Decl<P> = P | "(" [ List<P> ] ")" .
1244 Parse::decl(void (Parse::*pfn)(void*), void* varg)
1246 if (!this->peek_token()->is_op(OPERATOR_LPAREN))
1250 if (!this->advance_token()->is_op(OPERATOR_RPAREN))
1252 this->list(pfn, varg, true);
1253 if (!this->peek_token()->is_op(OPERATOR_RPAREN))
1255 error_at(this->location(), "missing %<)%>");
1256 while (!this->advance_token()->is_op(OPERATOR_RPAREN))
1258 if (this->peek_token()->is_eof())
1263 this->advance_token();
1267 // List<P> = P { ";" P } [ ";" ] .
1269 // In order to pick up the trailing semicolon we need to know what
1270 // might follow. This is either a '}' or a ')'.
1273 Parse::list(void (Parse::*pfn)(void*), void* varg, bool follow_is_paren)
1276 Operator follow = follow_is_paren ? OPERATOR_RPAREN : OPERATOR_RCURLY;
1277 while (this->peek_token()->is_op(OPERATOR_SEMICOLON)
1278 || this->peek_token()->is_op(OPERATOR_COMMA))
1280 if (this->peek_token()->is_op(OPERATOR_COMMA))
1281 error_at(this->location(), "unexpected comma");
1282 if (this->advance_token()->is_op(follow))
1288 // ConstDecl = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
1293 gcc_assert(this->peek_token()->is_keyword(KEYWORD_CONST));
1294 this->advance_token();
1297 Type* last_type = NULL;
1298 Expression_list* last_expr_list = NULL;
1300 if (!this->peek_token()->is_op(OPERATOR_LPAREN))
1301 this->const_spec(&last_type, &last_expr_list);
1304 this->advance_token();
1305 while (!this->peek_token()->is_op(OPERATOR_RPAREN))
1307 this->const_spec(&last_type, &last_expr_list);
1308 if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
1309 this->advance_token();
1310 else if (!this->peek_token()->is_op(OPERATOR_RPAREN))
1312 error_at(this->location(), "expected %<;%> or %<)%> or newline");
1313 if (!this->skip_past_error(OPERATOR_RPAREN))
1317 this->advance_token();
1320 if (last_expr_list != NULL)
1321 delete last_expr_list;
1324 // ConstSpec = IdentifierList [ [ CompleteType ] "=" ExpressionList ] .
1327 Parse::const_spec(Type** last_type, Expression_list** last_expr_list)
1329 Typed_identifier_list til;
1330 this->identifier_list(&til);
1333 if (this->type_may_start_here())
1335 type = this->type();
1337 *last_expr_list = NULL;
1340 Expression_list *expr_list;
1341 if (!this->peek_token()->is_op(OPERATOR_EQ))
1343 if (*last_expr_list == NULL)
1345 error_at(this->location(), "expected %<=%>");
1349 expr_list = new Expression_list;
1350 for (Expression_list::const_iterator p = (*last_expr_list)->begin();
1351 p != (*last_expr_list)->end();
1353 expr_list->push_back((*p)->copy());
1357 this->advance_token();
1358 expr_list = this->expression_list(NULL, false);
1360 if (*last_expr_list != NULL)
1361 delete *last_expr_list;
1362 *last_expr_list = expr_list;
1365 Expression_list::const_iterator pe = expr_list->begin();
1366 for (Typed_identifier_list::iterator pi = til.begin();
1370 if (pe == expr_list->end())
1372 error_at(this->location(), "not enough initializers");
1378 if (!Gogo::is_sink_name(pi->name()))
1379 this->gogo_->add_constant(*pi, *pe, this->iota_value());
1381 if (pe != expr_list->end())
1382 error_at(this->location(), "too many initializers");
1384 this->increment_iota();
1389 // TypeDecl = "type" Decl<TypeSpec> .
1394 gcc_assert(this->peek_token()->is_keyword(KEYWORD_TYPE));
1395 this->advance_token();
1396 this->decl(&Parse::type_spec, NULL);
1399 // TypeSpec = identifier Type .
1402 Parse::type_spec(void*)
1404 const Token* token = this->peek_token();
1405 if (!token->is_identifier())
1407 error_at(this->location(), "expected identifier");
1410 std::string name = token->identifier();
1411 bool is_exported = token->is_identifier_exported();
1412 source_location location = token->location();
1413 token = this->advance_token();
1415 // The scope of the type name starts at the point where the
1416 // identifier appears in the source code. We implement this by
1417 // declaring the type before we read the type definition.
1418 Named_object* named_type = NULL;
1421 name = this->gogo_->pack_hidden_name(name, is_exported);
1422 named_type = this->gogo_->declare_type(name, location);
1426 if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
1427 type = this->type();
1430 error_at(this->location(),
1431 "unexpected semicolon or newline in type declaration");
1432 type = Type::make_error_type();
1433 this->advance_token();
1436 if (type->is_error_type())
1438 while (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
1439 && !this->peek_token()->is_eof())
1440 this->advance_token();
1445 if (named_type->is_type_declaration())
1447 Type* ftype = type->forwarded();
1448 if (ftype->forward_declaration_type() != NULL
1449 && (ftype->forward_declaration_type()->named_object()
1452 error_at(location, "invalid recursive type");
1453 type = Type::make_error_type();
1456 this->gogo_->define_type(named_type,
1457 Type::make_named_type(named_type, type,
1459 gcc_assert(named_type->package() == NULL);
1463 // This will probably give a redefinition error.
1464 this->gogo_->add_type(name, type, location);
1469 // VarDecl = "var" Decl<VarSpec> .
1474 gcc_assert(this->peek_token()->is_keyword(KEYWORD_VAR));
1475 this->advance_token();
1476 this->decl(&Parse::var_spec, NULL);
1479 // VarSpec = IdentifierList
1480 // ( CompleteType [ "=" ExpressionList ] | "=" ExpressionList ) .
1483 Parse::var_spec(void*)
1485 // Get the variable names.
1486 Typed_identifier_list til;
1487 this->identifier_list(&til);
1489 source_location location = this->location();
1492 Expression_list* init = NULL;
1493 if (!this->peek_token()->is_op(OPERATOR_EQ))
1495 type = this->type();
1496 if (type->is_error_type())
1498 while (!this->peek_token()->is_op(OPERATOR_EQ)
1499 && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
1500 && !this->peek_token()->is_eof())
1501 this->advance_token();
1503 if (this->peek_token()->is_op(OPERATOR_EQ))
1505 this->advance_token();
1506 init = this->expression_list(NULL, false);
1511 this->advance_token();
1512 init = this->expression_list(NULL, false);
1515 this->init_vars(&til, type, init, false, location);
1521 // Create variables. TIL is a list of variable names. If TYPE is not
1522 // NULL, it is the type of all the variables. If INIT is not NULL, it
1523 // is an initializer list for the variables.
1526 Parse::init_vars(const Typed_identifier_list* til, Type* type,
1527 Expression_list* init, bool is_coloneq,
1528 source_location location)
1530 // Check for an initialization which can yield multiple values.
1531 if (init != NULL && init->size() == 1 && til->size() > 1)
1533 if (this->init_vars_from_call(til, type, *init->begin(), is_coloneq,
1536 if (this->init_vars_from_map(til, type, *init->begin(), is_coloneq,
1539 if (this->init_vars_from_receive(til, type, *init->begin(), is_coloneq,
1542 if (this->init_vars_from_type_guard(til, type, *init->begin(),
1543 is_coloneq, location))
1547 if (init != NULL && init->size() != til->size())
1549 if (init->empty() || !init->front()->is_error_expression())
1550 error_at(location, "wrong number of initializations");
1553 type = Type::make_error_type();
1556 // Note that INIT was already parsed with the old name bindings, so
1557 // we don't have to worry that it will accidentally refer to the
1558 // newly declared variables.
1560 Expression_list::const_iterator pexpr;
1562 pexpr = init->begin();
1563 bool any_new = false;
1564 for (Typed_identifier_list::const_iterator p = til->begin();
1569 gcc_assert(pexpr != init->end());
1570 this->init_var(*p, type, init == NULL ? NULL : *pexpr, is_coloneq,
1576 gcc_assert(pexpr == init->end());
1577 if (is_coloneq && !any_new)
1578 error_at(location, "variables redeclared but no variable is new");
1581 // See if we need to initialize a list of variables from a function
1582 // call. This returns true if we have set up the variables and the
1586 Parse::init_vars_from_call(const Typed_identifier_list* vars, Type* type,
1587 Expression* expr, bool is_coloneq,
1588 source_location location)
1590 Call_expression* call = expr->call_expression();
1594 // This is a function call. We can't check here whether it returns
1595 // the right number of values, but it might. Declare the variables,
1596 // and then assign the results of the call to them.
1598 unsigned int index = 0;
1599 bool any_new = false;
1600 for (Typed_identifier_list::const_iterator pv = vars->begin();
1604 Expression* init = Expression::make_call_result(call, index);
1605 this->init_var(*pv, type, init, is_coloneq, false, &any_new);
1608 if (is_coloneq && !any_new)
1609 error_at(location, "variables redeclared but no variable is new");
1614 // See if we need to initialize a pair of values from a map index
1615 // expression. This returns true if we have set up the variables and
1616 // the initialization.
1619 Parse::init_vars_from_map(const Typed_identifier_list* vars, Type* type,
1620 Expression* expr, bool is_coloneq,
1621 source_location location)
1623 Index_expression* index = expr->index_expression();
1626 if (vars->size() != 2)
1629 // This is an index which is being assigned to two variables. It
1630 // must be a map index. Declare the variables, and then assign the
1631 // results of the map index.
1632 bool any_new = false;
1633 Typed_identifier_list::const_iterator p = vars->begin();
1634 Expression* init = type == NULL ? index : NULL;
1635 Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
1636 type == NULL, &any_new);
1637 if (type == NULL && any_new && val_no->is_variable())
1638 val_no->var_value()->set_type_from_init_tuple();
1639 Expression* val_var = Expression::make_var_reference(val_no, location);
1642 Type* var_type = type;
1643 if (var_type == NULL)
1644 var_type = Type::lookup_bool_type();
1645 Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1647 Expression* present_var = Expression::make_var_reference(no, location);
1649 if (is_coloneq && !any_new)
1650 error_at(location, "variables redeclared but no variable is new");
1652 Statement* s = Statement::make_tuple_map_assignment(val_var, present_var,
1655 if (!this->gogo_->in_global_scope())
1656 this->gogo_->add_statement(s);
1657 else if (!val_no->is_sink())
1659 if (val_no->is_variable())
1660 val_no->var_value()->add_preinit_statement(this->gogo_, s);
1662 else if (!no->is_sink())
1664 if (no->is_variable())
1665 no->var_value()->add_preinit_statement(this->gogo_, s);
1669 // Execute the map index expression just so that we can fail if
1671 Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
1673 dummy->var_value()->add_preinit_statement(this->gogo_, s);
1679 // See if we need to initialize a pair of values from a receive
1680 // expression. This returns true if we have set up the variables and
1681 // the initialization.
1684 Parse::init_vars_from_receive(const Typed_identifier_list* vars, Type* type,
1685 Expression* expr, bool is_coloneq,
1686 source_location location)
1688 Receive_expression* receive = expr->receive_expression();
1689 if (receive == NULL)
1691 if (vars->size() != 2)
1694 // This is a receive expression which is being assigned to two
1695 // variables. Declare the variables, and then assign the results of
1697 bool any_new = false;
1698 Typed_identifier_list::const_iterator p = vars->begin();
1699 Expression* init = type == NULL ? receive : NULL;
1700 Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
1701 type == NULL, &any_new);
1702 if (type == NULL && any_new && val_no->is_variable())
1703 val_no->var_value()->set_type_from_init_tuple();
1704 Expression* val_var = Expression::make_var_reference(val_no, location);
1707 Type* var_type = type;
1708 if (var_type == NULL)
1709 var_type = Type::lookup_bool_type();
1710 Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1712 Expression* received_var = Expression::make_var_reference(no, location);
1714 if (is_coloneq && !any_new)
1715 error_at(location, "variables redeclared but no variable is new");
1717 Statement* s = Statement::make_tuple_receive_assignment(val_var,
1723 if (!this->gogo_->in_global_scope())
1724 this->gogo_->add_statement(s);
1725 else if (!val_no->is_sink())
1727 if (val_no->is_variable())
1728 val_no->var_value()->add_preinit_statement(this->gogo_, s);
1730 else if (!no->is_sink())
1732 if (no->is_variable())
1733 no->var_value()->add_preinit_statement(this->gogo_, s);
1737 Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
1739 dummy->var_value()->add_preinit_statement(this->gogo_, s);
1745 // See if we need to initialize a pair of values from a type guard
1746 // expression. This returns true if we have set up the variables and
1747 // the initialization.
1750 Parse::init_vars_from_type_guard(const Typed_identifier_list* vars,
1751 Type* type, Expression* expr,
1752 bool is_coloneq, source_location location)
1754 Type_guard_expression* type_guard = expr->type_guard_expression();
1755 if (type_guard == NULL)
1757 if (vars->size() != 2)
1760 // This is a type guard expression which is being assigned to two
1761 // variables. Declare the variables, and then assign the results of
1763 bool any_new = false;
1764 Typed_identifier_list::const_iterator p = vars->begin();
1765 Type* var_type = type;
1766 if (var_type == NULL)
1767 var_type = type_guard->type();
1768 Named_object* val_no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1770 Expression* val_var = Expression::make_var_reference(val_no, location);
1774 if (var_type == NULL)
1775 var_type = Type::lookup_bool_type();
1776 Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
1778 Expression* ok_var = Expression::make_var_reference(no, location);
1780 Expression* texpr = type_guard->expr();
1781 Type* t = type_guard->type();
1782 Statement* s = Statement::make_tuple_type_guard_assignment(val_var, ok_var,
1786 if (is_coloneq && !any_new)
1787 error_at(location, "variables redeclared but no variable is new");
1789 if (!this->gogo_->in_global_scope())
1790 this->gogo_->add_statement(s);
1791 else if (!val_no->is_sink())
1793 if (val_no->is_variable())
1794 val_no->var_value()->add_preinit_statement(this->gogo_, s);
1796 else if (!no->is_sink())
1798 if (no->is_variable())
1799 no->var_value()->add_preinit_statement(this->gogo_, s);
1803 Named_object* dummy = this->create_dummy_global(type, NULL, location);
1804 dummy->var_value()->add_preinit_statement(this->gogo_, s);
1810 // Create a single variable. If IS_COLONEQ is true, we permit
1811 // redeclarations in the same block, and we set *IS_NEW when we find a
1812 // new variable which is not a redeclaration.
1815 Parse::init_var(const Typed_identifier& tid, Type* type, Expression* init,
1816 bool is_coloneq, bool type_from_init, bool* is_new)
1818 source_location location = tid.location();
1820 if (Gogo::is_sink_name(tid.name()))
1822 if (!type_from_init && init != NULL)
1824 if (!this->gogo_->in_global_scope())
1825 this->gogo_->add_statement(Statement::make_statement(init));
1827 return this->create_dummy_global(type, init, location);
1829 return this->gogo_->add_sink();
1834 Named_object* no = this->gogo_->lookup_in_block(tid.name());
1836 && (no->is_variable() || no->is_result_variable()))
1838 // INIT may be NULL even when IS_COLONEQ is true for cases
1839 // like v, ok := x.(int).
1840 if (!type_from_init && init != NULL)
1842 Expression *v = Expression::make_var_reference(no, location);
1843 Statement *s = Statement::make_assignment(v, init, location);
1844 this->gogo_->add_statement(s);
1850 Variable* var = new Variable(type, init, this->gogo_->in_global_scope(),
1851 false, false, location);
1852 Named_object* no = this->gogo_->add_variable(tid.name(), var);
1853 if (!no->is_variable())
1855 // The name is already defined, so we just gave an error.
1856 return this->gogo_->add_sink();
1861 // Create a dummy global variable to force an initializer to be run in
1862 // the right place. This is used when a sink variable is initialized
1866 Parse::create_dummy_global(Type* type, Expression* init,
1867 source_location location)
1869 if (type == NULL && init == NULL)
1870 type = Type::lookup_bool_type();
1871 Variable* var = new Variable(type, init, true, false, false, location);
1874 snprintf(buf, sizeof buf, "_.%d", count);
1876 return this->gogo_->add_variable(buf, var);
1879 // SimpleVarDecl = identifier ":=" Expression .
1881 // We've already seen the identifier.
1883 // FIXME: We also have to implement
1884 // IdentifierList ":=" ExpressionList
1885 // In order to support both "a, b := 1, 0" and "a, b = 1, 0" we accept
1886 // tuple assignments here as well.
1888 // If P_RANGE_CLAUSE is not NULL, then this will recognize a
1891 // If P_TYPE_SWITCH is not NULL, this will recognize a type switch
1892 // guard (var := expr.("type") using the literal keyword "type").
1895 Parse::simple_var_decl_or_assignment(const std::string& name,
1896 source_location location,
1897 Range_clause* p_range_clause,
1898 Type_switch* p_type_switch)
1900 Typed_identifier_list til;
1901 til.push_back(Typed_identifier(name, NULL, location));
1903 // We've seen one identifier. If we see a comma now, this could be
1905 if (this->peek_token()->is_op(OPERATOR_COMMA))
1907 gcc_assert(p_type_switch == NULL);
1910 const Token* token = this->advance_token();
1911 if (!token->is_identifier())
1914 std::string id = token->identifier();
1915 bool is_id_exported = token->is_identifier_exported();
1916 source_location id_location = token->location();
1918 token = this->advance_token();
1919 if (!token->is_op(OPERATOR_COMMA))
1921 if (token->is_op(OPERATOR_COLONEQ))
1923 id = this->gogo_->pack_hidden_name(id, is_id_exported);
1924 til.push_back(Typed_identifier(id, NULL, location));
1927 this->unget_token(Token::make_identifier_token(id,
1933 id = this->gogo_->pack_hidden_name(id, is_id_exported);
1934 til.push_back(Typed_identifier(id, NULL, location));
1937 // We have a comma separated list of identifiers in TIL. If the
1938 // next token is COLONEQ, then this is a simple var decl, and we
1939 // have the complete list of identifiers. If the next token is
1940 // not COLONEQ, then the only valid parse is a tuple assignment.
1941 // The list of identifiers we have so far is really a list of
1942 // expressions. There are more expressions following.
1944 if (!this->peek_token()->is_op(OPERATOR_COLONEQ))
1946 Expression_list* exprs = new Expression_list;
1947 for (Typed_identifier_list::const_iterator p = til.begin();
1950 exprs->push_back(this->id_to_expression(p->name(),
1953 Expression_list* more_exprs = this->expression_list(NULL, true);
1954 for (Expression_list::const_iterator p = more_exprs->begin();
1955 p != more_exprs->end();
1957 exprs->push_back(*p);
1960 this->tuple_assignment(exprs, p_range_clause);
1965 gcc_assert(this->peek_token()->is_op(OPERATOR_COLONEQ));
1966 const Token* token = this->advance_token();
1968 if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
1970 this->range_clause_decl(&til, p_range_clause);
1974 Expression_list* init;
1975 if (p_type_switch == NULL)
1976 init = this->expression_list(NULL, false);
1979 bool is_type_switch = false;
1980 Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
1984 p_type_switch->found = true;
1985 p_type_switch->name = name;
1986 p_type_switch->location = location;
1987 p_type_switch->expr = expr;
1991 if (!this->peek_token()->is_op(OPERATOR_COMMA))
1993 init = new Expression_list();
1994 init->push_back(expr);
1998 this->advance_token();
1999 init = this->expression_list(expr, false);
2003 this->init_vars(&til, NULL, init, true, location);
2006 // FunctionDecl = "func" identifier Signature [ Block ] .
2007 // MethodDecl = "func" Receiver identifier Signature [ Block ] .
2010 // FunctionDecl = "func" identifier Signature
2011 // __asm__ "(" string_lit ")" .
2012 // This extension means a function whose real name is the identifier
2016 Parse::function_decl()
2018 gcc_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
2019 source_location location = this->location();
2020 const Token* token = this->advance_token();
2022 Typed_identifier* rec = NULL;
2023 if (token->is_op(OPERATOR_LPAREN))
2025 rec = this->receiver();
2026 token = this->peek_token();
2029 if (!token->is_identifier())
2031 error_at(this->location(), "expected function name");
2036 this->gogo_->pack_hidden_name(token->identifier(),
2037 token->is_identifier_exported());
2039 this->advance_token();
2041 Function_type* fntype = this->signature(rec, this->location());
2045 Named_object* named_object = NULL;
2047 if (this->peek_token()->is_keyword(KEYWORD_ASM))
2049 if (!this->advance_token()->is_op(OPERATOR_LPAREN))
2051 error_at(this->location(), "expected %<(%>");
2054 token = this->advance_token();
2055 if (!token->is_string())
2057 error_at(this->location(), "expected string");
2060 std::string asm_name = token->string_value();
2061 if (!this->advance_token()->is_op(OPERATOR_RPAREN))
2063 error_at(this->location(), "expected %<)%>");
2066 this->advance_token();
2067 if (!Gogo::is_sink_name(name))
2069 named_object = this->gogo_->declare_function(name, fntype, location);
2070 if (named_object->is_function_declaration())
2071 named_object->func_declaration_value()->set_asm_name(asm_name);
2075 // Check for the easy error of a newline before the opening brace.
2076 if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
2078 source_location semi_loc = this->location();
2079 if (this->advance_token()->is_op(OPERATOR_LCURLY))
2080 error_at(this->location(),
2081 "unexpected semicolon or newline before %<{%>");
2083 this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
2087 if (!this->peek_token()->is_op(OPERATOR_LCURLY))
2089 if (named_object == NULL && !Gogo::is_sink_name(name))
2090 this->gogo_->declare_function(name, fntype, location);
2094 this->gogo_->start_function(name, fntype, true, location);
2095 source_location end_loc = this->block();
2096 this->gogo_->finish_function(end_loc);
2100 // Receiver = "(" [ identifier ] [ "*" ] BaseTypeName ")" .
2101 // BaseTypeName = identifier .
2106 gcc_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
2109 const Token* token = this->advance_token();
2110 source_location location = token->location();
2111 if (!token->is_op(OPERATOR_MULT))
2113 if (!token->is_identifier())
2115 error_at(this->location(), "method has no receiver");
2116 while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
2117 token = this->advance_token();
2118 if (!token->is_eof())
2119 this->advance_token();
2122 name = token->identifier();
2123 bool is_exported = token->is_identifier_exported();
2124 token = this->advance_token();
2125 if (!token->is_op(OPERATOR_DOT) && !token->is_op(OPERATOR_RPAREN))
2127 // An identifier followed by something other than a dot or a
2128 // right parenthesis must be a receiver name followed by a
2130 name = this->gogo_->pack_hidden_name(name, is_exported);
2134 // This must be a type name.
2135 this->unget_token(Token::make_identifier_token(name, is_exported,
2137 token = this->peek_token();
2142 // Here the receiver name is in NAME (it is empty if the receiver is
2143 // unnamed) and TOKEN is the first token in the type.
2145 bool is_pointer = false;
2146 if (token->is_op(OPERATOR_MULT))
2149 token = this->advance_token();
2152 if (!token->is_identifier())
2154 error_at(this->location(), "expected receiver name or type");
2155 int c = token->is_op(OPERATOR_LPAREN) ? 1 : 0;
2156 while (!token->is_eof())
2158 token = this->advance_token();
2159 if (token->is_op(OPERATOR_LPAREN))
2161 else if (token->is_op(OPERATOR_RPAREN))
2168 if (!token->is_eof())
2169 this->advance_token();
2173 Type* type = this->type_name(true);
2175 if (is_pointer && !type->is_error_type())
2176 type = Type::make_pointer_type(type);
2178 if (this->peek_token()->is_op(OPERATOR_RPAREN))
2179 this->advance_token();
2182 if (this->peek_token()->is_op(OPERATOR_COMMA))
2183 error_at(this->location(), "method has multiple receivers");
2185 error_at(this->location(), "expected %<)%>");
2186 while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
2187 token = this->advance_token();
2188 if (!token->is_eof())
2189 this->advance_token();
2193 return new Typed_identifier(name, type, location);
2196 // Operand = Literal | QualifiedIdent | MethodExpr | "(" Expression ")" .
2197 // Literal = BasicLit | CompositeLit | FunctionLit .
2198 // BasicLit = int_lit | float_lit | imaginary_lit | char_lit | string_lit .
2200 // If MAY_BE_SINK is true, this operand may be "_".
2203 Parse::operand(bool may_be_sink)
2205 const Token* token = this->peek_token();
2207 switch (token->classification())
2209 case Token::TOKEN_IDENTIFIER:
2211 source_location location = token->location();
2212 std::string id = token->identifier();
2213 bool is_exported = token->is_identifier_exported();
2214 std::string packed = this->gogo_->pack_hidden_name(id, is_exported);
2216 Named_object* in_function;
2217 Named_object* named_object = this->gogo_->lookup(packed, &in_function);
2219 Package* package = NULL;
2220 if (named_object != NULL && named_object->is_package())
2222 if (!this->advance_token()->is_op(OPERATOR_DOT)
2223 || !this->advance_token()->is_identifier())
2225 error_at(location, "unexpected reference to package");
2226 return Expression::make_error(location);
2228 package = named_object->package_value();
2229 package->set_used();
2230 id = this->peek_token()->identifier();
2231 is_exported = this->peek_token()->is_identifier_exported();
2232 packed = this->gogo_->pack_hidden_name(id, is_exported);
2233 named_object = package->lookup(packed);
2234 location = this->location();
2235 gcc_assert(in_function == NULL);
2238 this->advance_token();
2240 if (named_object != NULL
2241 && named_object->is_type()
2242 && !named_object->type_value()->is_visible())
2244 gcc_assert(package != NULL);
2245 error_at(location, "invalid reference to hidden type %<%s.%s%>",
2246 Gogo::message_name(package->name()).c_str(),
2247 Gogo::message_name(id).c_str());
2248 return Expression::make_error(location);
2252 if (named_object == NULL)
2254 if (package != NULL)
2256 std::string n1 = Gogo::message_name(package->name());
2257 std::string n2 = Gogo::message_name(id);
2260 ("invalid reference to unexported identifier "
2262 n1.c_str(), n2.c_str());
2265 "reference to undefined identifier %<%s.%s%>",
2266 n1.c_str(), n2.c_str());
2267 return Expression::make_error(location);
2270 named_object = this->gogo_->add_unknown_name(packed, location);
2273 if (in_function != NULL
2274 && in_function != this->gogo_->current_function()
2275 && (named_object->is_variable()
2276 || named_object->is_result_variable()))
2277 return this->enclosing_var_reference(in_function, named_object,
2280 switch (named_object->classification())
2282 case Named_object::NAMED_OBJECT_CONST:
2283 return Expression::make_const_reference(named_object, location);
2284 case Named_object::NAMED_OBJECT_TYPE:
2285 return Expression::make_type(named_object->type_value(), location);
2286 case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
2288 Type* t = Type::make_forward_declaration(named_object);
2289 return Expression::make_type(t, location);
2291 case Named_object::NAMED_OBJECT_VAR:
2292 case Named_object::NAMED_OBJECT_RESULT_VAR:
2293 return Expression::make_var_reference(named_object, location);
2294 case Named_object::NAMED_OBJECT_SINK:
2296 return Expression::make_sink(location);
2299 error_at(location, "cannot use _ as value");
2300 return Expression::make_error(location);
2302 case Named_object::NAMED_OBJECT_FUNC:
2303 case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
2304 return Expression::make_func_reference(named_object, NULL,
2306 case Named_object::NAMED_OBJECT_UNKNOWN:
2307 return Expression::make_unknown_reference(named_object, location);
2314 case Token::TOKEN_STRING:
2315 ret = Expression::make_string(token->string_value(), token->location());
2316 this->advance_token();
2319 case Token::TOKEN_INTEGER:
2320 ret = Expression::make_integer(token->integer_value(), NULL,
2322 this->advance_token();
2325 case Token::TOKEN_FLOAT:
2326 ret = Expression::make_float(token->float_value(), NULL,
2328 this->advance_token();
2331 case Token::TOKEN_IMAGINARY:
2334 mpfr_init_set_ui(zero, 0, GMP_RNDN);
2335 ret = Expression::make_complex(&zero, token->imaginary_value(),
2336 NULL, token->location());
2338 this->advance_token();
2342 case Token::TOKEN_KEYWORD:
2343 switch (token->keyword())
2346 return this->function_lit();
2348 case KEYWORD_INTERFACE:
2350 case KEYWORD_STRUCT:
2352 source_location location = token->location();
2353 return Expression::make_type(this->type(), location);
2360 case Token::TOKEN_OPERATOR:
2361 if (token->is_op(OPERATOR_LPAREN))
2363 this->advance_token();
2364 ret = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2365 if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2366 error_at(this->location(), "missing %<)%>");
2368 this->advance_token();
2371 else if (token->is_op(OPERATOR_LSQUARE))
2373 // Here we call array_type directly, as this is the only
2374 // case where an ellipsis is permitted for an array type.
2375 source_location location = token->location();
2376 return Expression::make_type(this->array_type(true), location);
2384 error_at(this->location(), "expected operand");
2385 return Expression::make_error(this->location());
2388 // Handle a reference to a variable in an enclosing function. We add
2389 // it to a list of such variables. We return a reference to a field
2390 // in a struct which will be passed on the static chain when calling
2391 // the current function.
2394 Parse::enclosing_var_reference(Named_object* in_function, Named_object* var,
2395 source_location location)
2397 gcc_assert(var->is_variable() || var->is_result_variable());
2399 Named_object* this_function = this->gogo_->current_function();
2400 Named_object* closure = this_function->func_value()->closure_var();
2402 Enclosing_var ev(var, in_function, this->enclosing_vars_.size());
2403 std::pair<Enclosing_vars::iterator, bool> ins =
2404 this->enclosing_vars_.insert(ev);
2407 // This is a variable we have not seen before. Add a new field
2408 // to the closure type.
2409 this_function->func_value()->add_closure_field(var, location);
2412 Expression* closure_ref = Expression::make_var_reference(closure,
2414 closure_ref = Expression::make_unary(OPERATOR_MULT, closure_ref, location);
2416 // The closure structure holds pointers to the variables, so we need
2417 // to introduce an indirection.
2418 Expression* e = Expression::make_field_reference(closure_ref,
2421 e = Expression::make_unary(OPERATOR_MULT, e, location);
2425 // CompositeLit = LiteralType LiteralValue .
2426 // LiteralType = StructType | ArrayType | "[" "..." "]" ElementType |
2427 // SliceType | MapType | TypeName .
2428 // LiteralValue = "{" [ ElementList [ "," ] ] "}" .
2429 // ElementList = Element { "," Element } .
2430 // Element = [ Key ":" ] Value .
2431 // Key = Expression .
2432 // Value = Expression | LiteralValue .
2434 // We have already seen the type if there is one, and we are now
2435 // looking at the LiteralValue. The case "[" "..." "]" ElementType
2436 // will be seen here as an array type whose length is "nil". The
2437 // DEPTH parameter is non-zero if this is an embedded composite
2438 // literal and the type was omitted. It gives the number of steps up
2439 // to the type which was provided. E.g., in [][]int{{1}} it will be
2440 // 1. In [][][]int{{{1}}} it will be 2.
2443 Parse::composite_lit(Type* type, int depth, source_location location)
2445 gcc_assert(this->peek_token()->is_op(OPERATOR_LCURLY));
2446 this->advance_token();
2448 if (this->peek_token()->is_op(OPERATOR_RCURLY))
2450 this->advance_token();
2451 return Expression::make_composite_literal(type, depth, false, NULL,
2455 bool has_keys = false;
2456 Expression_list* vals = new Expression_list;
2460 bool is_type_omitted = false;
2462 const Token* token = this->peek_token();
2464 if (!token->is_op(OPERATOR_LCURLY))
2465 val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2468 // This must be a composite literal inside another composite
2469 // literal, with the type omitted for the inner one.
2470 val = this->composite_lit(type, depth + 1, token->location());
2471 is_type_omitted = true;
2474 token = this->peek_token();
2475 if (!token->is_op(OPERATOR_COLON))
2478 vals->push_back(NULL);
2482 if (is_type_omitted && !val->is_error_expression())
2484 error_at(this->location(), "unexpected %<:%>");
2485 val = Expression::make_error(this->location());
2488 this->advance_token();
2490 if (!has_keys && !vals->empty())
2492 Expression_list* newvals = new Expression_list;
2493 for (Expression_list::const_iterator p = vals->begin();
2497 newvals->push_back(NULL);
2498 newvals->push_back(*p);
2505 if (val->unknown_expression() != NULL)
2506 val->unknown_expression()->set_is_composite_literal_key();
2508 vals->push_back(val);
2510 if (!token->is_op(OPERATOR_LCURLY))
2511 val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2514 // This must be a composite literal inside another
2515 // composite literal, with the type omitted for the
2517 val = this->composite_lit(type, depth + 1, token->location());
2520 token = this->peek_token();
2523 vals->push_back(val);
2525 if (token->is_op(OPERATOR_COMMA))
2527 if (this->advance_token()->is_op(OPERATOR_RCURLY))
2529 this->advance_token();
2533 else if (token->is_op(OPERATOR_RCURLY))
2535 this->advance_token();
2540 error_at(this->location(), "expected %<,%> or %<}%>");
2543 while (!token->is_eof()
2544 && (depth > 0 || !token->is_op(OPERATOR_RCURLY)))
2546 if (token->is_op(OPERATOR_LCURLY))
2548 else if (token->is_op(OPERATOR_RCURLY))
2550 token = this->advance_token();
2552 if (token->is_op(OPERATOR_RCURLY))
2553 this->advance_token();
2555 return Expression::make_error(location);
2559 return Expression::make_composite_literal(type, depth, has_keys, vals,
2563 // FunctionLit = "func" Signature Block .
2566 Parse::function_lit()
2568 source_location location = this->location();
2569 gcc_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
2570 this->advance_token();
2572 Enclosing_vars hold_enclosing_vars;
2573 hold_enclosing_vars.swap(this->enclosing_vars_);
2575 Function_type* type = this->signature(NULL, location);
2577 type = Type::make_function_type(NULL, NULL, NULL, location);
2579 // For a function literal, the next token must be a '{'. If we
2580 // don't see that, then we may have a type expression.
2581 if (!this->peek_token()->is_op(OPERATOR_LCURLY))
2582 return Expression::make_type(type, location);
2584 Bc_stack* hold_break_stack = this->break_stack_;
2585 Bc_stack* hold_continue_stack = this->continue_stack_;
2586 this->break_stack_ = NULL;
2587 this->continue_stack_ = NULL;
2589 Named_object* no = this->gogo_->start_function("", type, true, location);
2591 source_location end_loc = this->block();
2593 this->gogo_->finish_function(end_loc);
2595 if (this->break_stack_ != NULL)
2596 delete this->break_stack_;
2597 if (this->continue_stack_ != NULL)
2598 delete this->continue_stack_;
2599 this->break_stack_ = hold_break_stack;
2600 this->continue_stack_ = hold_continue_stack;
2602 hold_enclosing_vars.swap(this->enclosing_vars_);
2604 Expression* closure = this->create_closure(no, &hold_enclosing_vars,
2607 return Expression::make_func_reference(no, closure, location);
2610 // Create a closure for the nested function FUNCTION. This is based
2611 // on ENCLOSING_VARS, which is a list of all variables defined in
2612 // enclosing functions and referenced from FUNCTION. A closure is the
2613 // address of a struct which contains the addresses of all the
2614 // referenced variables. This returns NULL if no closure is required.
2617 Parse::create_closure(Named_object* function, Enclosing_vars* enclosing_vars,
2618 source_location location)
2620 if (enclosing_vars->empty())
2623 // Get the variables in order by their field index.
2625 size_t enclosing_var_count = enclosing_vars->size();
2626 std::vector<Enclosing_var> ev(enclosing_var_count);
2627 for (Enclosing_vars::const_iterator p = enclosing_vars->begin();
2628 p != enclosing_vars->end();
2630 ev[p->index()] = *p;
2632 // Build an initializer for a composite literal of the closure's
2635 Named_object* enclosing_function = this->gogo_->current_function();
2636 Expression_list* initializer = new Expression_list;
2637 for (size_t i = 0; i < enclosing_var_count; ++i)
2639 gcc_assert(ev[i].index() == i);
2640 Named_object* var = ev[i].var();
2642 if (ev[i].in_function() == enclosing_function)
2643 ref = Expression::make_var_reference(var, location);
2645 ref = this->enclosing_var_reference(ev[i].in_function(), var,
2647 Expression* refaddr = Expression::make_unary(OPERATOR_AND, ref,
2649 initializer->push_back(refaddr);
2652 Named_object* closure_var = function->func_value()->closure_var();
2653 Struct_type* st = closure_var->var_value()->type()->deref()->struct_type();
2654 Expression* cv = Expression::make_struct_composite_literal(st, initializer,
2656 return Expression::make_heap_composite(cv, location);
2659 // PrimaryExpr = Operand { Selector | Index | Slice | TypeGuard | Call } .
2661 // If MAY_BE_SINK is true, this expression may be "_".
2663 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
2666 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2667 // guard (var := expr.("type") using the literal keyword "type").
2670 Parse::primary_expr(bool may_be_sink, bool may_be_composite_lit,
2671 bool* is_type_switch)
2673 source_location start_loc = this->location();
2674 bool is_parenthesized = this->peek_token()->is_op(OPERATOR_LPAREN);
2676 Expression* ret = this->operand(may_be_sink);
2678 // An unknown name followed by a curly brace must be a composite
2679 // literal, and the unknown name must be a type.
2680 if (may_be_composite_lit
2681 && !is_parenthesized
2682 && ret->unknown_expression() != NULL
2683 && this->peek_token()->is_op(OPERATOR_LCURLY))
2685 Named_object* no = ret->unknown_expression()->named_object();
2686 Type* type = Type::make_forward_declaration(no);
2687 ret = Expression::make_type(type, ret->location());
2690 // We handle composite literals and type casts here, as it is the
2691 // easiest way to handle types which are in parentheses, as in
2693 if (ret->is_type_expression())
2695 if (this->peek_token()->is_op(OPERATOR_LCURLY))
2697 if (is_parenthesized)
2699 "cannot parenthesize type in composite literal");
2700 ret = this->composite_lit(ret->type(), 0, ret->location());
2702 else if (this->peek_token()->is_op(OPERATOR_LPAREN))
2704 source_location loc = this->location();
2705 this->advance_token();
2706 Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
2708 if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2709 error_at(this->location(), "expected %<)%>");
2711 this->advance_token();
2712 if (expr->is_error_expression())
2714 ret = Expression::make_cast(ret->type(), expr, loc);
2720 const Token* token = this->peek_token();
2721 if (token->is_op(OPERATOR_LPAREN))
2722 ret = this->call(this->verify_not_sink(ret));
2723 else if (token->is_op(OPERATOR_DOT))
2725 ret = this->selector(this->verify_not_sink(ret), is_type_switch);
2726 if (is_type_switch != NULL && *is_type_switch)
2729 else if (token->is_op(OPERATOR_LSQUARE))
2730 ret = this->index(this->verify_not_sink(ret));
2738 // Selector = "." identifier .
2739 // TypeGuard = "." "(" QualifiedIdent ")" .
2741 // Note that Operand can expand to QualifiedIdent, which contains a
2742 // ".". That is handled directly in operand when it sees a package
2745 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2746 // guard (var := expr.("type") using the literal keyword "type").
2749 Parse::selector(Expression* left, bool* is_type_switch)
2751 gcc_assert(this->peek_token()->is_op(OPERATOR_DOT));
2752 source_location location = this->location();
2754 const Token* token = this->advance_token();
2755 if (token->is_identifier())
2757 // This could be a field in a struct, or a method in an
2758 // interface, or a method associated with a type. We can't know
2759 // which until we have seen all the types.
2761 this->gogo_->pack_hidden_name(token->identifier(),
2762 token->is_identifier_exported());
2763 if (token->identifier() == "_")
2765 error_at(this->location(), "invalid use of %<_%>");
2766 name = this->gogo_->pack_hidden_name("blank", false);
2768 this->advance_token();
2769 return Expression::make_selector(left, name, location);
2771 else if (token->is_op(OPERATOR_LPAREN))
2773 this->advance_token();
2775 if (!this->peek_token()->is_keyword(KEYWORD_TYPE))
2776 type = this->type();
2779 if (is_type_switch != NULL)
2780 *is_type_switch = true;
2783 error_at(this->location(),
2784 "use of %<.(type)%> outside type switch");
2785 type = Type::make_error_type();
2787 this->advance_token();
2789 if (!this->peek_token()->is_op(OPERATOR_RPAREN))
2790 error_at(this->location(), "missing %<)%>");
2792 this->advance_token();
2793 if (is_type_switch != NULL && *is_type_switch)
2795 return Expression::make_type_guard(left, type, location);
2799 error_at(this->location(), "expected identifier or %<(%>");
2804 // Index = "[" Expression "]" .
2805 // Slice = "[" Expression ":" [ Expression ] "]" .
2808 Parse::index(Expression* expr)
2810 source_location location = this->location();
2811 gcc_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
2812 this->advance_token();
2815 if (!this->peek_token()->is_op(OPERATOR_COLON))
2816 start = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2820 mpz_init_set_ui(zero, 0);
2821 start = Expression::make_integer(&zero, NULL, location);
2825 Expression* end = NULL;
2826 if (this->peek_token()->is_op(OPERATOR_COLON))
2828 // We use nil to indicate a missing high expression.
2829 if (this->advance_token()->is_op(OPERATOR_RSQUARE))
2830 end = Expression::make_nil(this->location());
2832 end = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
2834 if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
2835 error_at(this->location(), "missing %<]%>");
2837 this->advance_token();
2838 return Expression::make_index(expr, start, end, location);
2841 // Call = "(" [ ArgumentList [ "," ] ] ")" .
2842 // ArgumentList = ExpressionList [ "..." ] .
2845 Parse::call(Expression* func)
2847 gcc_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
2848 Expression_list* args = NULL;
2849 bool is_varargs = false;
2850 const Token* token = this->advance_token();
2851 if (!token->is_op(OPERATOR_RPAREN))
2853 args = this->expression_list(NULL, false);
2854 token = this->peek_token();
2855 if (token->is_op(OPERATOR_ELLIPSIS))
2858 token = this->advance_token();
2861 if (token->is_op(OPERATOR_COMMA))
2862 token = this->advance_token();
2863 if (!token->is_op(OPERATOR_RPAREN))
2864 error_at(this->location(), "missing %<)%>");
2866 this->advance_token();
2867 if (func->is_error_expression())
2869 return Expression::make_call(func, args, is_varargs, func->location());
2872 // Return an expression for a single unqualified identifier.
2875 Parse::id_to_expression(const std::string& name, source_location location)
2877 Named_object* in_function;
2878 Named_object* named_object = this->gogo_->lookup(name, &in_function);
2879 if (named_object == NULL)
2880 named_object = this->gogo_->add_unknown_name(name, location);
2882 if (in_function != NULL
2883 && in_function != this->gogo_->current_function()
2884 && (named_object->is_variable() || named_object->is_result_variable()))
2885 return this->enclosing_var_reference(in_function, named_object,
2888 switch (named_object->classification())
2890 case Named_object::NAMED_OBJECT_CONST:
2891 return Expression::make_const_reference(named_object, location);
2892 case Named_object::NAMED_OBJECT_VAR:
2893 case Named_object::NAMED_OBJECT_RESULT_VAR:
2894 return Expression::make_var_reference(named_object, location);
2895 case Named_object::NAMED_OBJECT_SINK:
2896 return Expression::make_sink(location);
2897 case Named_object::NAMED_OBJECT_FUNC:
2898 case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
2899 return Expression::make_func_reference(named_object, NULL, location);
2900 case Named_object::NAMED_OBJECT_UNKNOWN:
2901 return Expression::make_unknown_reference(named_object, location);
2903 error_at(this->location(), "unexpected type of identifier");
2904 return Expression::make_error(location);
2908 // Expression = UnaryExpr { binary_op Expression } .
2910 // PRECEDENCE is the precedence of the current operator.
2912 // If MAY_BE_SINK is true, this expression may be "_".
2914 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
2917 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2918 // guard (var := expr.("type") using the literal keyword "type").
2921 Parse::expression(Precedence precedence, bool may_be_sink,
2922 bool may_be_composite_lit, bool* is_type_switch)
2924 Expression* left = this->unary_expr(may_be_sink, may_be_composite_lit,
2929 if (is_type_switch != NULL && *is_type_switch)
2932 const Token* token = this->peek_token();
2933 if (token->classification() != Token::TOKEN_OPERATOR)
2939 Precedence right_precedence;
2940 switch (token->op())
2943 right_precedence = PRECEDENCE_OROR;
2945 case OPERATOR_ANDAND:
2946 right_precedence = PRECEDENCE_ANDAND;
2949 case OPERATOR_NOTEQ:
2954 right_precedence = PRECEDENCE_RELOP;
2957 case OPERATOR_MINUS:
2960 right_precedence = PRECEDENCE_ADDOP;
2965 case OPERATOR_LSHIFT:
2966 case OPERATOR_RSHIFT:
2968 case OPERATOR_BITCLEAR:
2969 right_precedence = PRECEDENCE_MULOP;
2972 right_precedence = PRECEDENCE_INVALID;
2976 if (right_precedence == PRECEDENCE_INVALID)
2982 Operator op = token->op();
2983 source_location binop_location = token->location();
2985 if (precedence >= right_precedence)
2987 // We've already seen A * B, and we see + C. We want to
2988 // return so that A * B becomes a group.
2992 this->advance_token();
2994 left = this->verify_not_sink(left);
2995 Expression* right = this->expression(right_precedence, false,
2996 may_be_composite_lit,
2998 left = Expression::make_binary(op, left, right, binop_location);
3003 Parse::expression_may_start_here()
3005 const Token* token = this->peek_token();
3006 switch (token->classification())
3008 case Token::TOKEN_INVALID:
3009 case Token::TOKEN_EOF:
3011 case Token::TOKEN_KEYWORD:
3012 switch (token->keyword())
3017 case KEYWORD_STRUCT:
3018 case KEYWORD_INTERFACE:
3023 case Token::TOKEN_IDENTIFIER:
3025 case Token::TOKEN_STRING:
3027 case Token::TOKEN_OPERATOR:
3028 switch (token->op())
3031 case OPERATOR_MINUS:
3035 case OPERATOR_CHANOP:
3037 case OPERATOR_LPAREN:
3038 case OPERATOR_LSQUARE:
3043 case Token::TOKEN_INTEGER:
3044 case Token::TOKEN_FLOAT:
3045 case Token::TOKEN_IMAGINARY:
3052 // UnaryExpr = unary_op UnaryExpr | PrimaryExpr .
3054 // If MAY_BE_SINK is true, this expression may be "_".
3056 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
3059 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3060 // guard (var := expr.("type") using the literal keyword "type").
3063 Parse::unary_expr(bool may_be_sink, bool may_be_composite_lit,
3064 bool* is_type_switch)
3066 const Token* token = this->peek_token();
3067 if (token->is_op(OPERATOR_PLUS)
3068 || token->is_op(OPERATOR_MINUS)
3069 || token->is_op(OPERATOR_NOT)
3070 || token->is_op(OPERATOR_XOR)
3071 || token->is_op(OPERATOR_CHANOP)
3072 || token->is_op(OPERATOR_MULT)
3073 || token->is_op(OPERATOR_AND))
3075 source_location location = token->location();
3076 Operator op = token->op();
3077 this->advance_token();
3079 if (op == OPERATOR_CHANOP
3080 && this->peek_token()->is_keyword(KEYWORD_CHAN))
3082 // This is "<- chan" which must be the start of a type.
3083 this->unget_token(Token::make_operator_token(op, location));
3084 return Expression::make_type(this->type(), location);
3087 Expression* expr = this->unary_expr(false, may_be_composite_lit, NULL);
3088 if (expr->is_error_expression())
3090 else if (op == OPERATOR_MULT && expr->is_type_expression())
3091 expr = Expression::make_type(Type::make_pointer_type(expr->type()),
3093 else if (op == OPERATOR_AND && expr->is_composite_literal())
3094 expr = Expression::make_heap_composite(expr, location);
3095 else if (op != OPERATOR_CHANOP)
3096 expr = Expression::make_unary(op, expr, location);
3098 expr = Expression::make_receive(expr, location);
3102 return this->primary_expr(may_be_sink, may_be_composite_lit,
3107 // Declaration | LabeledStmt | SimpleStmt |
3108 // GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
3109 // FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
3112 // LABEL is the label of this statement if it has one.
3115 Parse::statement(Label* label)
3117 const Token* token = this->peek_token();
3118 switch (token->classification())
3120 case Token::TOKEN_KEYWORD:
3122 switch (token->keyword())
3127 this->declaration();
3131 case KEYWORD_STRUCT:
3132 case KEYWORD_INTERFACE:
3133 this->simple_stat(true, false, NULL, NULL);
3137 this->go_or_defer_stat();
3139 case KEYWORD_RETURN:
3140 this->return_stat();
3145 case KEYWORD_CONTINUE:
3146 this->continue_stat();
3154 case KEYWORD_SWITCH:
3155 this->switch_stat(label);
3157 case KEYWORD_SELECT:
3158 this->select_stat(label);
3161 this->for_stat(label);
3164 error_at(this->location(), "expected statement");
3165 this->advance_token();
3171 case Token::TOKEN_IDENTIFIER:
3173 std::string identifier = token->identifier();
3174 bool is_exported = token->is_identifier_exported();
3175 source_location location = token->location();
3176 if (this->advance_token()->is_op(OPERATOR_COLON))
3178 this->advance_token();
3179 this->labeled_stmt(identifier, location);
3183 this->unget_token(Token::make_identifier_token(identifier,
3186 this->simple_stat(true, false, NULL, NULL);
3191 case Token::TOKEN_OPERATOR:
3192 if (token->is_op(OPERATOR_LCURLY))
3194 source_location location = token->location();
3195 this->gogo_->start_block(location);
3196 source_location end_loc = this->block();
3197 this->gogo_->add_block(this->gogo_->finish_block(end_loc),
3200 else if (!token->is_op(OPERATOR_SEMICOLON))
3201 this->simple_stat(true, false, NULL, NULL);
3204 case Token::TOKEN_STRING:
3205 case Token::TOKEN_INTEGER:
3206 case Token::TOKEN_FLOAT:
3207 case Token::TOKEN_IMAGINARY:
3208 this->simple_stat(true, false, NULL, NULL);
3212 error_at(this->location(), "expected statement");
3213 this->advance_token();
3219 Parse::statement_may_start_here()
3221 const Token* token = this->peek_token();
3222 switch (token->classification())
3224 case Token::TOKEN_KEYWORD:
3226 switch (token->keyword())
3233 case KEYWORD_STRUCT:
3234 case KEYWORD_INTERFACE:
3237 case KEYWORD_RETURN:
3239 case KEYWORD_CONTINUE:
3242 case KEYWORD_SWITCH:
3243 case KEYWORD_SELECT:
3253 case Token::TOKEN_IDENTIFIER:
3256 case Token::TOKEN_OPERATOR:
3257 if (token->is_op(OPERATOR_LCURLY)
3258 || token->is_op(OPERATOR_SEMICOLON))
3261 return this->expression_may_start_here();
3263 case Token::TOKEN_STRING:
3264 case Token::TOKEN_INTEGER:
3265 case Token::TOKEN_FLOAT:
3266 case Token::TOKEN_IMAGINARY:
3274 // LabeledStmt = Label ":" Statement .
3275 // Label = identifier .
3278 Parse::labeled_stmt(const std::string& label_name, source_location location)
3280 Label* label = this->gogo_->add_label_definition(label_name, location);
3282 if (this->peek_token()->is_op(OPERATOR_RCURLY))
3284 // This is a label at the end of a block. A program is
3285 // permitted to omit a semicolon here.
3289 if (!this->statement_may_start_here())
3291 // Mark the label as used to avoid a useless error about an
3293 label->set_is_used();
3295 error_at(location, "missing statement after label");
3296 this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
3301 this->statement(label);
3304 // SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt |
3305 // Assignment | ShortVarDecl .
3307 // EmptyStmt was handled in Parse::statement.
3309 // In order to make this work for if and switch statements, if
3310 // RETURN_EXP is true, and we see an ExpressionStat, we return the
3311 // expression rather than adding an expression statement to the
3312 // current block. If we see something other than an ExpressionStat,
3313 // we add the statement and return NULL.
3315 // If P_RANGE_CLAUSE is not NULL, then this will recognize a
3318 // If P_TYPE_SWITCH is not NULL, this will recognize a type switch
3319 // guard (var := expr.("type") using the literal keyword "type").
3322 Parse::simple_stat(bool may_be_composite_lit, bool return_exp,
3323 Range_clause* p_range_clause, Type_switch* p_type_switch)
3325 const Token* token = this->peek_token();
3327 // An identifier follow by := is a SimpleVarDecl.
3328 if (token->is_identifier())
3330 std::string identifier = token->identifier();
3331 bool is_exported = token->is_identifier_exported();
3332 source_location location = token->location();
3334 token = this->advance_token();
3335 if (token->is_op(OPERATOR_COLONEQ)
3336 || token->is_op(OPERATOR_COMMA))
3338 identifier = this->gogo_->pack_hidden_name(identifier, is_exported);
3339 this->simple_var_decl_or_assignment(identifier, location,
3341 (token->is_op(OPERATOR_COLONEQ)
3347 this->unget_token(Token::make_identifier_token(identifier, is_exported,
3351 Expression* exp = this->expression(PRECEDENCE_NORMAL, true,
3352 may_be_composite_lit,
3353 (p_type_switch == NULL
3355 : &p_type_switch->found));
3356 if (p_type_switch != NULL && p_type_switch->found)
3358 p_type_switch->name.clear();
3359 p_type_switch->location = exp->location();
3360 p_type_switch->expr = this->verify_not_sink(exp);
3363 token = this->peek_token();
3364 if (token->is_op(OPERATOR_CHANOP))
3365 this->send_stmt(this->verify_not_sink(exp));
3366 else if (token->is_op(OPERATOR_PLUSPLUS)
3367 || token->is_op(OPERATOR_MINUSMINUS))
3368 this->inc_dec_stat(this->verify_not_sink(exp));
3369 else if (token->is_op(OPERATOR_COMMA)
3370 || token->is_op(OPERATOR_EQ))
3371 this->assignment(exp, p_range_clause);
3372 else if (token->is_op(OPERATOR_PLUSEQ)
3373 || token->is_op(OPERATOR_MINUSEQ)
3374 || token->is_op(OPERATOR_OREQ)
3375 || token->is_op(OPERATOR_XOREQ)
3376 || token->is_op(OPERATOR_MULTEQ)
3377 || token->is_op(OPERATOR_DIVEQ)
3378 || token->is_op(OPERATOR_MODEQ)
3379 || token->is_op(OPERATOR_LSHIFTEQ)
3380 || token->is_op(OPERATOR_RSHIFTEQ)
3381 || token->is_op(OPERATOR_ANDEQ)
3382 || token->is_op(OPERATOR_BITCLEAREQ))
3383 this->assignment(this->verify_not_sink(exp), p_range_clause);
3384 else if (return_exp)
3385 return this->verify_not_sink(exp);
3387 this->expression_stat(this->verify_not_sink(exp));
3393 Parse::simple_stat_may_start_here()
3395 return this->expression_may_start_here();
3398 // Parse { Statement ";" } which is used in a few places. The list of
3399 // statements may end with a right curly brace, in which case the
3400 // semicolon may be omitted.
3403 Parse::statement_list()
3405 while (this->statement_may_start_here())
3407 this->statement(NULL);
3408 if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
3409 this->advance_token();
3410 else if (this->peek_token()->is_op(OPERATOR_RCURLY))
3414 if (!this->peek_token()->is_eof() || !saw_errors())
3415 error_at(this->location(), "expected %<;%> or %<}%> or newline");
3416 if (!this->skip_past_error(OPERATOR_RCURLY))
3423 Parse::statement_list_may_start_here()
3425 return this->statement_may_start_here();
3428 // ExpressionStat = Expression .
3431 Parse::expression_stat(Expression* exp)
3433 exp->discarding_value();
3434 this->gogo_->add_statement(Statement::make_statement(exp));
3437 // SendStmt = Channel "<-" Expression .
3438 // Channel = Expression .
3441 Parse::send_stmt(Expression* channel)
3443 gcc_assert(this->peek_token()->is_op(OPERATOR_CHANOP));
3444 source_location loc = this->location();
3445 this->advance_token();
3446 Expression* val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
3447 Statement* s = Statement::make_send_statement(channel, val, loc);
3448 this->gogo_->add_statement(s);
3451 // IncDecStat = Expression ( "++" | "--" ) .
3454 Parse::inc_dec_stat(Expression* exp)
3456 const Token* token = this->peek_token();
3458 // Lvalue maps require special handling.
3459 if (exp->index_expression() != NULL)
3460 exp->index_expression()->set_is_lvalue();
3462 if (token->is_op(OPERATOR_PLUSPLUS))
3463 this->gogo_->add_statement(Statement::make_inc_statement(exp));
3464 else if (token->is_op(OPERATOR_MINUSMINUS))
3465 this->gogo_->add_statement(Statement::make_dec_statement(exp));
3468 this->advance_token();
3471 // Assignment = ExpressionList assign_op ExpressionList .
3473 // EXP is an expression that we have already parsed.
3475 // If RANGE_CLAUSE is not NULL, then this will recognize a
3479 Parse::assignment(Expression* expr, Range_clause* p_range_clause)
3481 Expression_list* vars;
3482 if (!this->peek_token()->is_op(OPERATOR_COMMA))
3484 vars = new Expression_list();
3485 vars->push_back(expr);
3489 this->advance_token();
3490 vars = this->expression_list(expr, true);
3493 this->tuple_assignment(vars, p_range_clause);
3496 // An assignment statement. LHS is the list of expressions which
3497 // appear on the left hand side.
3499 // If RANGE_CLAUSE is not NULL, then this will recognize a
3503 Parse::tuple_assignment(Expression_list* lhs, Range_clause* p_range_clause)
3505 const Token* token = this->peek_token();
3506 if (!token->is_op(OPERATOR_EQ)
3507 && !token->is_op(OPERATOR_PLUSEQ)
3508 && !token->is_op(OPERATOR_MINUSEQ)
3509 && !token->is_op(OPERATOR_OREQ)
3510 && !token->is_op(OPERATOR_XOREQ)
3511 && !token->is_op(OPERATOR_MULTEQ)
3512 && !token->is_op(OPERATOR_DIVEQ)
3513 && !token->is_op(OPERATOR_MODEQ)
3514 && !token->is_op(OPERATOR_LSHIFTEQ)
3515 && !token->is_op(OPERATOR_RSHIFTEQ)
3516 && !token->is_op(OPERATOR_ANDEQ)
3517 && !token->is_op(OPERATOR_BITCLEAREQ))
3519 error_at(this->location(), "expected assignment operator");
3522 Operator op = token->op();
3523 source_location location = token->location();
3525 token = this->advance_token();
3527 if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
3529 if (op != OPERATOR_EQ)
3530 error_at(this->location(), "range clause requires %<=%>");
3531 this->range_clause_expr(lhs, p_range_clause);
3535 Expression_list* vals = this->expression_list(NULL, false);
3537 // We've parsed everything; check for errors.
3538 if (lhs == NULL || vals == NULL)
3540 for (Expression_list::const_iterator pe = lhs->begin();
3544 if ((*pe)->is_error_expression())
3546 if (op != OPERATOR_EQ && (*pe)->is_sink_expression())
3547 error_at((*pe)->location(), "cannot use _ as value");
3549 for (Expression_list::const_iterator pe = vals->begin();
3553 if ((*pe)->is_error_expression())
3557 // Map expressions act differently when they are lvalues.
3558 for (Expression_list::iterator plv = lhs->begin();
3561 if ((*plv)->index_expression() != NULL)
3562 (*plv)->index_expression()->set_is_lvalue();
3564 Call_expression* call;
3565 Index_expression* map_index;
3566 Receive_expression* receive;
3567 Type_guard_expression* type_guard;
3568 if (lhs->size() == vals->size())
3571 if (lhs->size() > 1)
3573 if (op != OPERATOR_EQ)
3574 error_at(location, "multiple values only permitted with %<=%>");
3575 s = Statement::make_tuple_assignment(lhs, vals, location);
3579 if (op == OPERATOR_EQ)
3580 s = Statement::make_assignment(lhs->front(), vals->front(),
3583 s = Statement::make_assignment_operation(op, lhs->front(),
3584 vals->front(), location);
3588 this->gogo_->add_statement(s);
3590 else if (vals->size() == 1
3591 && (call = (*vals->begin())->call_expression()) != NULL)
3593 if (op != OPERATOR_EQ)
3594 error_at(location, "multiple results only permitted with %<=%>");
3596 vals = new Expression_list;
3597 for (unsigned int i = 0; i < lhs->size(); ++i)
3598 vals->push_back(Expression::make_call_result(call, i));
3599 Statement* s = Statement::make_tuple_assignment(lhs, vals, location);
3600 this->gogo_->add_statement(s);
3602 else if (lhs->size() == 2
3603 && vals->size() == 1
3604 && (map_index = (*vals->begin())->index_expression()) != NULL)
3606 if (op != OPERATOR_EQ)
3607 error_at(location, "two values from map requires %<=%>");
3608 Expression* val = lhs->front();
3609 Expression* present = lhs->back();
3610 Statement* s = Statement::make_tuple_map_assignment(val, present,
3611 map_index, location);
3612 this->gogo_->add_statement(s);
3614 else if (lhs->size() == 1
3615 && vals->size() == 2
3616 && (map_index = lhs->front()->index_expression()) != NULL)
3618 if (op != OPERATOR_EQ)
3619 error_at(location, "assigning tuple to map index requires %<=%>");
3620 Expression* val = vals->front();
3621 Expression* should_set = vals->back();
3622 Statement* s = Statement::make_map_assignment(map_index, val, should_set,
3624 this->gogo_->add_statement(s);
3626 else if (lhs->size() == 2
3627 && vals->size() == 1
3628 && (receive = (*vals->begin())->receive_expression()) != NULL)
3630 if (op != OPERATOR_EQ)
3631 error_at(location, "two values from receive requires %<=%>");
3632 Expression* val = lhs->front();
3633 Expression* success = lhs->back();
3634 Expression* channel = receive->channel();
3635 Statement* s = Statement::make_tuple_receive_assignment(val, success,
3639 this->gogo_->add_statement(s);
3641 else if (lhs->size() == 2
3642 && vals->size() == 1
3643 && (type_guard = (*vals->begin())->type_guard_expression()) != NULL)
3645 if (op != OPERATOR_EQ)
3646 error_at(location, "two values from type guard requires %<=%>");
3647 Expression* val = lhs->front();
3648 Expression* ok = lhs->back();
3649 Expression* expr = type_guard->expr();
3650 Type* type = type_guard->type();
3651 Statement* s = Statement::make_tuple_type_guard_assignment(val, ok,
3654 this->gogo_->add_statement(s);
3658 error_at(location, "number of variables does not match number of values");
3662 // GoStat = "go" Expression .
3663 // DeferStat = "defer" Expression .
3666 Parse::go_or_defer_stat()
3668 gcc_assert(this->peek_token()->is_keyword(KEYWORD_GO)
3669 || this->peek_token()->is_keyword(KEYWORD_DEFER));
3670 bool is_go = this->peek_token()->is_keyword(KEYWORD_GO);
3671 source_location stat_location = this->location();
3672 this->advance_token();
3673 source_location expr_location = this->location();
3674 Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
3675 Call_expression* call_expr = expr->call_expression();
3676 if (call_expr == NULL)
3678 error_at(expr_location, "expected call expression");
3682 // Make it easier to simplify go/defer statements by putting every
3683 // statement in its own block.
3684 this->gogo_->start_block(stat_location);
3687 stat = Statement::make_go_statement(call_expr, stat_location);
3689 stat = Statement::make_defer_statement(call_expr, stat_location);
3690 this->gogo_->add_statement(stat);
3691 this->gogo_->add_block(this->gogo_->finish_block(stat_location),
3695 // ReturnStat = "return" [ ExpressionList ] .
3698 Parse::return_stat()
3700 gcc_assert(this->peek_token()->is_keyword(KEYWORD_RETURN));
3701 source_location location = this->location();
3702 this->advance_token();
3703 Expression_list* vals = NULL;
3704 if (this->expression_may_start_here())
3705 vals = this->expression_list(NULL, false);
3706 const Function* function = this->gogo_->current_function()->func_value();
3707 const Typed_identifier_list* results = function->type()->results();
3708 this->gogo_->add_statement(Statement::make_return_statement(results, vals,
3712 // IfStmt = "if" [ SimpleStmt ";" ] Expression Block [ "else" Statement ] .
3717 gcc_assert(this->peek_token()->is_keyword(KEYWORD_IF));
3718 source_location location = this->location();
3719 this->advance_token();
3721 this->gogo_->start_block(location);
3723 Expression* cond = NULL;
3724 if (this->simple_stat_may_start_here())
3725 cond = this->simple_stat(false, true, NULL, NULL);
3726 if (cond != NULL && this->peek_token()->is_op(OPERATOR_SEMICOLON))
3728 // The SimpleStat is an expression statement.
3729 this->expression_stat(cond);
3734 if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
3735 this->advance_token();
3736 cond = this->expression(PRECEDENCE_NORMAL, false, false, NULL);
3739 this->gogo_->start_block(this->location());
3740 source_location end_loc = this->block();
3741 Block* then_block = this->gogo_->finish_block(end_loc);
3743 // Check for the easy error of a newline before "else".
3744 if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
3746 source_location semi_loc = this->location();
3747 if (this->advance_token()->is_keyword(KEYWORD_ELSE))
3748 error_at(this->location(),
3749 "unexpected semicolon or newline before %<else%>");
3751 this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
3755 Block* else_block = NULL;
3756 if (this->peek_token()->is_keyword(KEYWORD_ELSE))
3758 this->advance_token();
3759 // We create a block to gather the statement.
3760 this->gogo_->start_block(this->location());
3761 this->statement(NULL);
3762 else_block = this->gogo_->finish_block(this->location());
3765 this->gogo_->add_statement(Statement::make_if_statement(cond, then_block,
3769 this->gogo_->add_block(this->gogo_->finish_block(this->location()),
3773 // SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .
3774 // ExprSwitchStmt = "switch" [ [ SimpleStat ] ";" ] [ Expression ]
3775 // "{" { ExprCaseClause } "}" .
3776 // TypeSwitchStmt = "switch" [ [ SimpleStat ] ";" ] TypeSwitchGuard
3777 // "{" { TypeCaseClause } "}" .
3778 // TypeSwitchGuard = [ identifier ":=" ] Expression "." "(" "type" ")" .
3781 Parse::switch_stat(Label* label)
3783 gcc_assert(this->peek_token()->is_keyword(KEYWORD_SWITCH));
3784 source_location location = this->location();
3785 this->advance_token();
3787 this->gogo_->start_block(location);
3789 Expression* switch_val = NULL;
3790 Type_switch type_switch;
3791 if (this->simple_stat_may_start_here())
3792 switch_val = this->simple_stat(false, true, NULL, &type_switch);
3793 if (switch_val != NULL && this->peek_token()->is_op(OPERATOR_SEMICOLON))
3795 // The SimpleStat is an expression statement.
3796 this->expression_stat(switch_val);
3799 if (switch_val == NULL && !type_switch.found)
3801 if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
3802 this->advance_token();
3803 if (!this->peek_token()->is_op(OPERATOR_LCURLY))
3805 if (this->peek_token()->is_identifier())
3807 const Token* token = this->peek_token();
3808 std::string identifier = token->identifier();
3809 bool is_exported = token->is_identifier_exported();
3810 source_location id_loc = token->location();
3812 token = this->advance_token();
3813 bool is_coloneq = token->is_op(OPERATOR_COLONEQ);
3814 this->unget_token(Token::make_identifier_token(identifier,
3819 // This must be a TypeSwitchGuard.
3820 switch_val = this->simple_stat(false, true, NULL,
3822 if (!type_switch.found)
3824 if (switch_val == NULL
3825 || !switch_val->is_error_expression())
3827 error_at(id_loc, "expected type switch assignment");
3828 switch_val = Expression::make_error(id_loc);
3833 if (switch_val == NULL && !type_switch.found)
3835 switch_val = this->expression(PRECEDENCE_NORMAL, false, false,
3836 &type_switch.found);
3837 if (type_switch.found)
3839 type_switch.name.clear();
3840 type_switch.expr = switch_val;
3841 type_switch.location = switch_val->location();
3847 if (!this->peek_token()->is_op(OPERATOR_LCURLY))
3849 source_location token_loc = this->location();
3850 if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
3851 && this->advance_token()->is_op(OPERATOR_LCURLY))
3852 error_at(token_loc, "unexpected semicolon or newline before %<{%>");
3855 error_at(this->location(), "expected %<{%>");
3856 this->gogo_->add_block(this->gogo_->finish_block(this->location()),
3861 this->advance_token();
3863 Statement* statement;
3864 if (type_switch.found)
3865 statement = this->type_switch_body(label, type_switch, location);
3867 statement = this->expr_switch_body(label, switch_val, location);
3869 if (statement != NULL)
3870 this->gogo_->add_statement(statement);
3872 this->gogo_->add_block(this->gogo_->finish_block(this->location()),
3876 // The body of an expression switch.
3877 // "{" { ExprCaseClause } "}"
3880 Parse::expr_switch_body(Label* label, Expression* switch_val,
3881 source_location location)
3883 Switch_statement* statement = Statement::make_switch_statement(switch_val,
3886 this->push_break_statement(statement, label);
3888 Case_clauses* case_clauses = new Case_clauses();
3889 bool saw_default = false;
3890 while (!this->peek_token()->is_op(OPERATOR_RCURLY))
3892 if (this->peek_token()->is_eof())
3895 error_at(this->location(), "missing %<}%>");
3898 this->expr_case_clause(case_clauses, &saw_default);
3900 this->advance_token();
3902 statement->add_clauses(case_clauses);
3904 this->pop_break_statement();
3909 // ExprCaseClause = ExprSwitchCase ":" [ StatementList ] .
3910 // FallthroughStat = "fallthrough" .
3913 Parse::expr_case_clause(Case_clauses* clauses, bool* saw_default)
3915 source_location location = this->location();
3917 bool is_default = false;
3918 Expression_list* vals = this->expr_switch_case(&is_default);
3920 if (!this->peek_token()->is_op(OPERATOR_COLON))
3923 error_at(this->location(), "expected %<:%>");
3927 this->advance_token();
3929 Block* statements = NULL;
3930 if (this->statement_list_may_start_here())
3932 this->gogo_->start_block(this->location());
3933 this->statement_list();
3934 statements = this->gogo_->finish_block(this->location());
3937 bool is_fallthrough = false;
3938 if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH))
3940 is_fallthrough = true;
3941 if (this->advance_token()->is_op(OPERATOR_SEMICOLON))
3942 this->advance_token();
3949 error_at(location, "multiple defaults in switch");
3952 *saw_default = true;
3955 if (is_default || vals != NULL)
3956 clauses->add(vals, is_default, statements, is_fallthrough, location);
3959 // ExprSwitchCase = "case" ExpressionList | "default" .
3962 Parse::expr_switch_case(bool* is_default)
3964 const Token* token = this->peek_token();
3965 if (token->is_keyword(KEYWORD_CASE))
3967 this->advance_token();
3968 return this->expression_list(NULL, false);
3970 else if (token->is_keyword(KEYWORD_DEFAULT))
3972 this->advance_token();
3979 error_at(this->location(), "expected %<case%> or %<default%>");
3980 if (!token->is_op(OPERATOR_RCURLY))
3981 this->advance_token();
3986 // The body of a type switch.
3987 // "{" { TypeCaseClause } "}" .
3990 Parse::type_switch_body(Label* label, const Type_switch& type_switch,
3991 source_location location)
3993 Named_object* switch_no = NULL;
3994 if (!type_switch.name.empty())
3996 Variable* switch_var = new Variable(NULL, type_switch.expr, false, false,
3997 false, type_switch.location);
3998 switch_no = this->gogo_->add_variable(type_switch.name, switch_var);
4001 Type_switch_statement* statement =
4002 Statement::make_type_switch_statement(switch_no,
4008 this->push_break_statement(statement, label);
4010 Type_case_clauses* case_clauses = new Type_case_clauses();
4011 bool saw_default = false;
4012 while (!this->peek_token()->is_op(OPERATOR_RCURLY))
4014 if (this->peek_token()->is_eof())
4016 error_at(this->location(), "missing %<}%>");
4019 this->type_case_clause(switch_no, case_clauses, &saw_default);
4021 this->advance_token();
4023 statement->add_clauses(case_clauses);
4025 this->pop_break_statement();
4030 // TypeCaseClause = TypeSwitchCase ":" [ StatementList ] .
4033 Parse::type_case_clause(Named_object* switch_no, Type_case_clauses* clauses,
4036 source_location location = this->location();
4038 std::vector<Type*> types;
4039 bool is_default = false;
4040 this->type_switch_case(&types, &is_default);
4042 if (!this->peek_token()->is_op(OPERATOR_COLON))
4043 error_at(this->location(), "expected %<:%>");
4045 this->advance_token();
4047 Block* statements = NULL;
4048 if (this->statement_list_may_start_here())
4050 this->gogo_->start_block(this->location());
4051 if (switch_no != NULL && types.size() == 1)
4053 Type* type = types.front();
4054 Expression* init = Expression::make_var_reference(switch_no,
4056 init = Expression::make_type_guard(init, type, location);
4057 Variable* v = new Variable(type, init, false, false, false,
4059 v->set_is_type_switch_var();
4060 this->gogo_->add_variable(switch_no->name(), v);
4062 this->statement_list();
4063 statements = this->gogo_->finish_block(this->location());
4066 if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH))
4068 error_at(this->location(),
4069 "fallthrough is not permitted in a type switch");
4070 if (this->advance_token()->is_op(OPERATOR_SEMICOLON))
4071 this->advance_token();
4076 gcc_assert(types.empty());
4079 error_at(location, "multiple defaults in type switch");
4082 *saw_default = true;
4083 clauses->add(NULL, false, true, statements, location);
4085 else if (!types.empty())
4087 for (std::vector<Type*>::const_iterator p = types.begin();
4088 p + 1 != types.end();
4090 clauses->add(*p, true, false, NULL, location);
4091 clauses->add(types.back(), false, false, statements, location);
4094 clauses->add(Type::make_error_type(), false, false, statements, location);
4097 // TypeSwitchCase = "case" type | "default"
4099 // We accept a comma separated list of types.
4102 Parse::type_switch_case(std::vector<Type*>* types, bool* is_default)
4104 const Token* token = this->peek_token();
4105 if (token->is_keyword(KEYWORD_CASE))
4107 this->advance_token();
4110 Type* t = this->type();
4111 if (!t->is_error_type())
4112 types->push_back(t);
4113 if (!this->peek_token()->is_op(OPERATOR_COMMA))
4115 this->advance_token();
4118 else if (token->is_keyword(KEYWORD_DEFAULT))
4120 this->advance_token();
4125 error_at(this->location(), "expected %<case%> or %<default%>");
4126 if (!token->is_op(OPERATOR_RCURLY))
4127 this->advance_token();
4131 // SelectStat = "select" "{" { CommClause } "}" .
4134 Parse::select_stat(Label* label)
4136 gcc_assert(this->peek_token()->is_keyword(KEYWORD_SELECT));
4137 source_location location = this->location();
4138 const Token* token = this->advance_token();
4140 if (!token->is_op(OPERATOR_LCURLY))
4142 source_location token_loc = token->location();
4143 if (token->is_op(OPERATOR_SEMICOLON)
4144 && this->advance_token()->is_op(OPERATOR_LCURLY))
4145 error_at(token_loc, "unexpected semicolon or newline before %<{%>");
4148 error_at(this->location(), "expected %<{%>");
4152 this->advance_token();
4154 Select_statement* statement = Statement::make_select_statement(location);
4156 this->push_break_statement(statement, label);
4158 Select_clauses* select_clauses = new Select_clauses();
4159 bool saw_default = false;
4160 while (!this->peek_token()->is_op(OPERATOR_RCURLY))
4162 if (this->peek_token()->is_eof())
4164 error_at(this->location(), "expected %<}%>");
4167 this->comm_clause(select_clauses, &saw_default);
4170 this->advance_token();
4172 statement->add_clauses(select_clauses);
4174 this->pop_break_statement();
4176 this->gogo_->add_statement(statement);
4179 // CommClause = CommCase ":" { Statement ";" } .
4182 Parse::comm_clause(Select_clauses* clauses, bool* saw_default)
4184 source_location location = this->location();
4185 bool is_send = false;
4186 Expression* channel = NULL;
4187 Expression* val = NULL;
4188 Expression* closed = NULL;
4189 std::string varname;
4190 std::string closedname;
4191 bool is_default = false;
4192 bool got_case = this->comm_case(&is_send, &channel, &val, &closed,
4193 &varname, &closedname, &is_default);
4195 if (this->peek_token()->is_op(OPERATOR_COLON))
4196 this->advance_token();
4198 error_at(this->location(), "expected colon");
4200 Block* statements = NULL;
4201 Named_object* var = NULL;
4202 Named_object* closedvar = NULL;
4203 if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
4204 this->advance_token();
4205 else if (this->statement_list_may_start_here())
4207 this->gogo_->start_block(this->location());
4209 if (!varname.empty())
4211 // FIXME: LOCATION is slightly wrong here.
4212 Variable* v = new Variable(NULL, channel, false, false, false,
4214 v->set_type_from_chan_element();
4215 var = this->gogo_->add_variable(varname, v);
4218 if (!closedname.empty())
4220 // FIXME: LOCATION is slightly wrong here.
4221 Variable* v = new Variable(Type::lookup_bool_type(), NULL,
4222 false, false, false, location);
4223 closedvar = this->gogo_->add_variable(closedname, v);
4226 this->statement_list();
4227 statements = this->gogo_->finish_block(this->location());
4234 error_at(location, "multiple defaults in select");
4237 *saw_default = true;
4241 clauses->add(is_send, channel, val, closed, var, closedvar, is_default,
4242 statements, location);
4243 else if (statements != NULL)
4245 // Add the statements to make sure that any names they define
4247 this->gogo_->add_block(statements, location);
4251 // CommCase = "case" ( SendStmt | RecvStmt ) | "default" .
4254 Parse::comm_case(bool* is_send, Expression** channel, Expression** val,
4255 Expression** closed, std::string* varname,
4256 std::string* closedname, bool* is_default)
4258 const Token* token = this->peek_token();
4259 if (token->is_keyword(KEYWORD_DEFAULT))
4261 this->advance_token();
4264 else if (token->is_keyword(KEYWORD_CASE))
4266 this->advance_token();
4267 if (!this->send_or_recv_stmt(is_send, channel, val, closed, varname,
4273 error_at(this->location(), "expected %<case%> or %<default%>");
4274 if (!token->is_op(OPERATOR_RCURLY))
4275 this->advance_token();
4282 // RecvStmt = [ Expression [ "," Expression ] ( "=" | ":=" ) ] RecvExpr .
4283 // RecvExpr = Expression .
4286 Parse::send_or_recv_stmt(bool* is_send, Expression** channel, Expression** val,
4287 Expression** closed, std::string* varname,
4288 std::string* closedname)
4290 const Token* token = this->peek_token();
4291 bool saw_comma = false;
4292 bool closed_is_id = false;
4293 if (token->is_identifier())
4295 Gogo* gogo = this->gogo_;
4296 std::string recv_var = token->identifier();
4297 bool is_rv_exported = token->is_identifier_exported();
4298 source_location recv_var_loc = token->location();
4299 token = this->advance_token();
4300 if (token->is_op(OPERATOR_COLONEQ))
4303 if (!this->advance_token()->is_op(OPERATOR_CHANOP))
4305 error_at(this->location(), "expected %<<-%>");
4308 if (recv_var == "_")
4310 error_at(recv_var_loc,
4311 "no new variables on left side of %<:=%>");
4315 *varname = gogo->pack_hidden_name(recv_var, is_rv_exported);
4316 this->advance_token();
4317 *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
4320 else if (token->is_op(OPERATOR_COMMA))
4322 token = this->advance_token();
4323 if (token->is_identifier())
4325 std::string recv_closed = token->identifier();
4326 bool is_rc_exported = token->is_identifier_exported();
4327 source_location recv_closed_loc = token->location();
4328 closed_is_id = true;
4330 token = this->advance_token();
4331 if (token->is_op(OPERATOR_COLONEQ))
4333 // case rv, rc := <-c:
4334 if (!this->advance_token()->is_op(OPERATOR_CHANOP))
4336 error_at(this->location(), "expected %<<-%>");
4339 if (recv_var == "_" && recv_closed == "_")
4341 error_at(recv_var_loc,
4342 "no new variables on left side of %<:=%>");
4346 if (recv_var != "_")
4347 *varname = gogo->pack_hidden_name(recv_var,
4349 if (recv_closed != "_")
4350 *closedname = gogo->pack_hidden_name(recv_closed,
4352 this->advance_token();
4353 *channel = this->expression(PRECEDENCE_NORMAL, false, true,
4358 this->unget_token(Token::make_identifier_token(recv_closed,
4363 *val = this->id_to_expression(gogo->pack_hidden_name(recv_var,
4369 this->unget_token(Token::make_identifier_token(recv_var,
4374 // If SAW_COMMA is false, then we are looking at the start of the
4375 // send or receive expression. If SAW_COMMA is true, then *VAL is
4376 // set and we just read a comma.
4379 if (saw_comma || !this->peek_token()->is_op(OPERATOR_CHANOP))
4380 e = this->expression(PRECEDENCE_NORMAL, true, true, NULL);
4385 this->advance_token();
4386 *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
4388 // The next token should be ':'. If it is '<-', then we have
4390 // which is to say, send on a channel received from a channel.
4391 if (!this->peek_token()->is_op(OPERATOR_CHANOP))
4394 e = Expression::make_receive(*channel, (*channel)->location());
4397 if (this->peek_token()->is_op(OPERATOR_EQ))
4399 if (!this->advance_token()->is_op(OPERATOR_CHANOP))
4401 error_at(this->location(), "missing %<<-%>");
4405 this->advance_token();
4406 *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
4410 // *VAL is already set.
4411 if (!e->is_sink_expression())
4417 if (!e->is_sink_expression())
4426 error_at(this->location(), "expected %<=%> or %<:=%>");
4428 error_at(this->location(), "expected %<=%>");
4432 if (this->peek_token()->is_op(OPERATOR_CHANOP))
4436 *channel = this->verify_not_sink(e);
4437 this->advance_token();
4438 *val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
4442 error_at(this->location(), "expected %<<-%> or %<=%>");
4446 // ForStat = "for" [ Condition | ForClause | RangeClause ] Block .
4447 // Condition = Expression .
4450 Parse::for_stat(Label* label)
4452 gcc_assert(this->peek_token()->is_keyword(KEYWORD_FOR));
4453 source_location location = this->location();
4454 const Token* token = this->advance_token();
4456 // Open a block to hold any variables defined in the init statement
4457 // of the for statement.
4458 this->gogo_->start_block(location);
4461 Expression* cond = NULL;
4463 Range_clause range_clause;
4465 if (!token->is_op(OPERATOR_LCURLY))
4467 if (token->is_keyword(KEYWORD_VAR))
4469 error_at(this->location(),
4470 "var declaration not allowed in for initializer");
4474 if (token->is_op(OPERATOR_SEMICOLON))
4475 this->for_clause(&cond, &post);
4478 // We might be looking at a Condition, an InitStat, or a
4480 cond = this->simple_stat(false, true, &range_clause, NULL);
4481 if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
4483 if (cond == NULL && !range_clause.found)
4484 error_at(this->location(), "parse error in for statement");
4488 if (range_clause.found)
4489 error_at(this->location(), "parse error after range clause");
4493 // COND is actually an expression statement for
4494 // InitStat at the start of a ForClause.
4495 this->expression_stat(cond);
4499 this->for_clause(&cond, &post);
4504 // Build the For_statement and note that it is the current target
4505 // for break and continue statements.
4507 For_statement* sfor;
4508 For_range_statement* srange;
4510 if (!range_clause.found)
4512 sfor = Statement::make_for_statement(init, cond, post, location);
4518 srange = Statement::make_for_range_statement(range_clause.index,
4526 this->push_break_statement(s, label);
4527 this->push_continue_statement(s, label);
4529 // Gather the block of statements in the loop and add them to the
4532 this->gogo_->start_block(this->location());
4533 source_location end_loc = this->block();
4534 Block* statements = this->gogo_->finish_block(end_loc);
4537 sfor->add_statements(statements);
4539 srange->add_statements(statements);
4541 // This is no longer the break/continue target.
4542 this->pop_break_statement();
4543 this->pop_continue_statement();
4545 // Add the For_statement to the list of statements, and close out
4546 // the block we started to hold any variables defined in the for
4549 this->gogo_->add_statement(s);
4551 this->gogo_->add_block(this->gogo_->finish_block(this->location()),
4555 // ForClause = [ InitStat ] ";" [ Condition ] ";" [ PostStat ] .
4556 // InitStat = SimpleStat .
4557 // PostStat = SimpleStat .
4559 // We have already read InitStat at this point.
4562 Parse::for_clause(Expression** cond, Block** post)
4564 gcc_assert(this->peek_token()->is_op(OPERATOR_SEMICOLON));
4565 this->advance_token();
4566 if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
4568 else if (this->peek_token()->is_op(OPERATOR_LCURLY))
4570 error_at(this->location(),
4571 "unexpected semicolon or newline before %<{%>");
4577 *cond = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
4578 if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
4579 error_at(this->location(), "expected semicolon");
4581 this->advance_token();
4583 if (this->peek_token()->is_op(OPERATOR_LCURLY))
4587 this->gogo_->start_block(this->location());
4588 this->simple_stat(false, false, NULL, NULL);
4589 *post = this->gogo_->finish_block(this->location());
4593 // RangeClause = IdentifierList ( "=" | ":=" ) "range" Expression .
4595 // This is the := version. It is called with a list of identifiers.
4598 Parse::range_clause_decl(const Typed_identifier_list* til,
4599 Range_clause* p_range_clause)
4601 gcc_assert(this->peek_token()->is_keyword(KEYWORD_RANGE));
4602 source_location location = this->location();
4604 p_range_clause->found = true;
4606 gcc_assert(til->size() >= 1);
4607 if (til->size() > 2)
4608 error_at(this->location(), "too many variables for range clause");
4610 this->advance_token();
4611 Expression* expr = this->expression(PRECEDENCE_NORMAL, false, false, NULL);
4612 p_range_clause->range = expr;
4614 bool any_new = false;
4616 const Typed_identifier* pti = &til->front();
4617 Named_object* no = this->init_var(*pti, NULL, expr, true, true, &any_new);
4618 if (any_new && no->is_variable())
4619 no->var_value()->set_type_from_range_index();
4620 p_range_clause->index = Expression::make_var_reference(no, location);
4622 if (til->size() == 1)
4623 p_range_clause->value = NULL;
4627 bool is_new = false;
4628 no = this->init_var(*pti, NULL, expr, true, true, &is_new);
4629 if (is_new && no->is_variable())
4630 no->var_value()->set_type_from_range_value();
4633 p_range_clause->value = Expression::make_var_reference(no, location);
4637 error_at(location, "variables redeclared but no variable is new");
4640 // The = version of RangeClause. This is called with a list of
4644 Parse::range_clause_expr(const Expression_list* vals,
4645 Range_clause* p_range_clause)
4647 gcc_assert(this->peek_token()->is_keyword(KEYWORD_RANGE));
4649 p_range_clause->found = true;
4651 gcc_assert(vals->size() >= 1);
4652 if (vals->size() > 2)
4653 error_at(this->location(), "too many variables for range clause");
4655 this->advance_token();
4656 p_range_clause->range = this->expression(PRECEDENCE_NORMAL, false, false,
4659 p_range_clause->index = vals->front();
4660 if (vals->size() == 1)
4661 p_range_clause->value = NULL;
4663 p_range_clause->value = vals->back();
4666 // Push a statement on the break stack.
4669 Parse::push_break_statement(Statement* enclosing, Label* label)
4671 if (this->break_stack_ == NULL)
4672 this->break_stack_ = new Bc_stack();
4673 this->break_stack_->push_back(std::make_pair(enclosing, label));
4676 // Push a statement on the continue stack.
4679 Parse::push_continue_statement(Statement* enclosing, Label* label)
4681 if (this->continue_stack_ == NULL)
4682 this->continue_stack_ = new Bc_stack();
4683 this->continue_stack_->push_back(std::make_pair(enclosing, label));
4686 // Pop the break stack.
4689 Parse::pop_break_statement()
4691 this->break_stack_->pop_back();
4694 // Pop the continue stack.
4697 Parse::pop_continue_statement()
4699 this->continue_stack_->pop_back();
4702 // Find a break or continue statement given a label name.
4705 Parse::find_bc_statement(const Bc_stack* bc_stack, const std::string& label)
4707 if (bc_stack == NULL)
4709 for (Bc_stack::const_reverse_iterator p = bc_stack->rbegin();
4710 p != bc_stack->rend();
4713 if (p->second != NULL && p->second->name() == label)
4715 p->second->set_is_used();
4722 // BreakStat = "break" [ identifier ] .
4727 gcc_assert(this->peek_token()->is_keyword(KEYWORD_BREAK));
4728 source_location location = this->location();
4730 const Token* token = this->advance_token();
4731 Statement* enclosing;
4732 if (!token->is_identifier())
4734 if (this->break_stack_ == NULL || this->break_stack_->empty())
4736 error_at(this->location(),
4737 "break statement not within for or switch or select");
4740 enclosing = this->break_stack_->back().first;
4744 enclosing = this->find_bc_statement(this->break_stack_,
4745 token->identifier());
4746 if (enclosing == NULL)
4748 // If there is a label with this name, mark it as used to
4749 // avoid a useless error about an unused label.
4750 this->gogo_->add_label_reference(token->identifier());
4752 error_at(token->location(), "invalid break label %qs",
4753 Gogo::message_name(token->identifier()).c_str());
4754 this->advance_token();
4757 this->advance_token();
4760 Unnamed_label* label;
4761 if (enclosing->classification() == Statement::STATEMENT_FOR)
4762 label = enclosing->for_statement()->break_label();
4763 else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
4764 label = enclosing->for_range_statement()->break_label();
4765 else if (enclosing->classification() == Statement::STATEMENT_SWITCH)
4766 label = enclosing->switch_statement()->break_label();
4767 else if (enclosing->classification() == Statement::STATEMENT_TYPE_SWITCH)
4768 label = enclosing->type_switch_statement()->break_label();
4769 else if (enclosing->classification() == Statement::STATEMENT_SELECT)
4770 label = enclosing->select_statement()->break_label();
4774 this->gogo_->add_statement(Statement::make_break_statement(label,
4778 // ContinueStat = "continue" [ identifier ] .
4781 Parse::continue_stat()
4783 gcc_assert(this->peek_token()->is_keyword(KEYWORD_CONTINUE));
4784 source_location location = this->location();
4786 const Token* token = this->advance_token();
4787 Statement* enclosing;
4788 if (!token->is_identifier())
4790 if (this->continue_stack_ == NULL || this->continue_stack_->empty())
4792 error_at(this->location(), "continue statement not within for");
4795 enclosing = this->continue_stack_->back().first;
4799 enclosing = this->find_bc_statement(this->continue_stack_,
4800 token->identifier());
4801 if (enclosing == NULL)
4803 // If there is a label with this name, mark it as used to
4804 // avoid a useless error about an unused label.
4805 this->gogo_->add_label_reference(token->identifier());
4807 error_at(token->location(), "invalid continue label %qs",
4808 Gogo::message_name(token->identifier()).c_str());
4809 this->advance_token();
4812 this->advance_token();
4815 Unnamed_label* label;
4816 if (enclosing->classification() == Statement::STATEMENT_FOR)
4817 label = enclosing->for_statement()->continue_label();
4818 else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
4819 label = enclosing->for_range_statement()->continue_label();
4823 this->gogo_->add_statement(Statement::make_continue_statement(label,
4827 // GotoStat = "goto" identifier .
4832 gcc_assert(this->peek_token()->is_keyword(KEYWORD_GOTO));
4833 source_location location = this->location();
4834 const Token* token = this->advance_token();
4835 if (!token->is_identifier())
4836 error_at(this->location(), "expected label for goto");
4839 Label* label = this->gogo_->add_label_reference(token->identifier());
4840 Statement* s = Statement::make_goto_statement(label, location);
4841 this->gogo_->add_statement(s);
4842 this->advance_token();
4846 // PackageClause = "package" PackageName .
4849 Parse::package_clause()
4851 const Token* token = this->peek_token();
4852 source_location location = token->location();
4854 if (!token->is_keyword(KEYWORD_PACKAGE))
4856 error_at(this->location(), "program must start with package clause");
4861 token = this->advance_token();
4862 if (token->is_identifier())
4864 name = token->identifier();
4867 error_at(this->location(), "invalid package name _");
4870 this->advance_token();
4874 error_at(this->location(), "package name must be an identifier");
4878 this->gogo_->set_package_name(name, location);
4881 // ImportDecl = "import" Decl<ImportSpec> .
4884 Parse::import_decl()
4886 gcc_assert(this->peek_token()->is_keyword(KEYWORD_IMPORT));
4887 this->advance_token();
4888 this->decl(&Parse::import_spec, NULL);
4891 // ImportSpec = [ "." | PackageName ] PackageFileName .
4894 Parse::import_spec(void*)
4896 const Token* token = this->peek_token();
4897 source_location location = token->location();
4899 std::string local_name;
4900 bool is_local_name_exported = false;
4901 if (token->is_op(OPERATOR_DOT))
4904 token = this->advance_token();
4906 else if (token->is_identifier())
4908 local_name = token->identifier();
4909 is_local_name_exported = token->is_identifier_exported();
4910 token = this->advance_token();
4913 if (!token->is_string())
4915 error_at(this->location(), "missing import package name");
4919 this->gogo_->import_package(token->string_value(), local_name,
4920 is_local_name_exported, location);
4922 this->advance_token();
4925 // SourceFile = PackageClause ";" { ImportDecl ";" }
4926 // { TopLevelDecl ";" } .
4931 this->package_clause();
4933 const Token* token = this->peek_token();
4934 if (token->is_op(OPERATOR_SEMICOLON))
4935 token = this->advance_token();
4937 error_at(this->location(),
4938 "expected %<;%> or newline after package clause");
4940 while (token->is_keyword(KEYWORD_IMPORT))
4942 this->import_decl();
4943 token = this->peek_token();
4944 if (token->is_op(OPERATOR_SEMICOLON))
4945 token = this->advance_token();
4947 error_at(this->location(),
4948 "expected %<;%> or newline after import declaration");
4951 while (!token->is_eof())
4953 if (this->declaration_may_start_here())
4954 this->declaration();
4957 error_at(this->location(), "expected declaration");
4959 this->advance_token();
4960 while (!this->peek_token()->is_eof()
4961 && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
4962 && !this->peek_token()->is_op(OPERATOR_RCURLY));
4963 if (!this->peek_token()->is_eof()
4964 && !this->peek_token()->is_op(OPERATOR_SEMICOLON))
4965 this->advance_token();
4967 token = this->peek_token();
4968 if (token->is_op(OPERATOR_SEMICOLON))
4969 token = this->advance_token();
4970 else if (!token->is_eof() || !saw_errors())
4972 error_at(this->location(),
4973 "expected %<;%> or newline after top level declaration");
4974 this->skip_past_error(OPERATOR_INVALID);
4979 // Reset the current iota value.
4987 // Return the current iota value.
4995 // Increment the current iota value.
4998 Parse::increment_iota()
5003 // Skip forward to a semicolon or OP. OP will normally be
5004 // OPERATOR_RPAREN or OPERATOR_RCURLY. If we find a semicolon, move
5005 // past it and return. If we find OP, it will be the next token to
5006 // read. Return true if we are OK, false if we found EOF.
5009 Parse::skip_past_error(Operator op)
5011 const Token* token = this->peek_token();
5012 while (!token->is_op(op))
5014 if (token->is_eof())
5016 if (token->is_op(OPERATOR_SEMICOLON))
5018 this->advance_token();
5021 token = this->advance_token();
5026 // Check that an expression is not a sink.
5029 Parse::verify_not_sink(Expression* expr)
5031 if (expr->is_sink_expression())
5033 error_at(expr->location(), "cannot use _ as value");
5034 expr = Expression::make_error(expr->location());