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(Linemap::unknown_location())),
46 unget_token_(Token::make_invalid_token(Linemap::unknown_location())),
47 unget_token_valid_(false),
48 is_erroneous_function_(false),
51 continue_stack_(NULL
),
58 // Return the current token.
63 if (this->unget_token_valid_
)
64 return &this->unget_token_
;
65 if (this->token_
.is_invalid())
66 this->token_
= this->lex_
->next_token();
70 // Advance to the next token and return it.
73 Parse::advance_token()
75 if (this->unget_token_valid_
)
77 this->unget_token_valid_
= false;
78 if (!this->token_
.is_invalid())
81 this->token_
= this->lex_
->next_token();
85 // Push a token back on the input stream.
88 Parse::unget_token(const Token
& token
)
90 go_assert(!this->unget_token_valid_
);
91 this->unget_token_
= token
;
92 this->unget_token_valid_
= true;
95 // The location of the current token.
100 return this->peek_token()->location();
103 // IdentifierList = identifier { "," identifier } .
106 Parse::identifier_list(Typed_identifier_list
* til
)
108 const Token
* token
= this->peek_token();
111 if (!token
->is_identifier())
113 error_at(this->location(), "expected identifier");
117 this->gogo_
->pack_hidden_name(token
->identifier(),
118 token
->is_identifier_exported());
119 til
->push_back(Typed_identifier(name
, NULL
, token
->location()));
120 token
= this->advance_token();
121 if (!token
->is_op(OPERATOR_COMMA
))
123 token
= this->advance_token();
127 // ExpressionList = Expression { "," Expression } .
129 // If MAY_BE_COMPOSITE_LIT is true, an expression may be a composite
132 // If MAY_BE_SINK is true, the expressions in the list may be "_".
135 Parse::expression_list(Expression
* first
, bool may_be_sink
,
136 bool may_be_composite_lit
)
138 Expression_list
* ret
= new Expression_list();
140 ret
->push_back(first
);
143 ret
->push_back(this->expression(PRECEDENCE_NORMAL
, may_be_sink
,
144 may_be_composite_lit
, NULL
));
146 const Token
* token
= this->peek_token();
147 if (!token
->is_op(OPERATOR_COMMA
))
150 // Most expression lists permit a trailing comma.
151 Location location
= token
->location();
152 this->advance_token();
153 if (!this->expression_may_start_here())
155 this->unget_token(Token::make_operator_token(OPERATOR_COMMA
,
162 // QualifiedIdent = [ PackageName "." ] identifier .
163 // PackageName = identifier .
165 // This sets *PNAME to the identifier and sets *PPACKAGE to the
166 // package or NULL if there isn't one. This returns true on success,
167 // false on failure in which case it will have emitted an error
171 Parse::qualified_ident(std::string
* pname
, Named_object
** ppackage
)
173 const Token
* token
= this->peek_token();
174 if (!token
->is_identifier())
176 error_at(this->location(), "expected identifier");
180 std::string name
= token
->identifier();
181 bool is_exported
= token
->is_identifier_exported();
182 name
= this->gogo_
->pack_hidden_name(name
, is_exported
);
184 token
= this->advance_token();
185 if (!token
->is_op(OPERATOR_DOT
))
192 Named_object
* package
= this->gogo_
->lookup(name
, NULL
);
193 if (package
== NULL
|| !package
->is_package())
195 error_at(this->location(), "expected package");
196 // We expect . IDENTIFIER; skip both.
197 if (this->advance_token()->is_identifier())
198 this->advance_token();
202 package
->package_value()->set_used();
204 token
= this->advance_token();
205 if (!token
->is_identifier())
207 error_at(this->location(), "expected identifier");
211 name
= token
->identifier();
215 error_at(this->location(), "invalid use of %<_%>");
219 if (package
->name() == this->gogo_
->package_name())
220 name
= this->gogo_
->pack_hidden_name(name
,
221 token
->is_identifier_exported());
226 this->advance_token();
231 // Type = TypeName | TypeLit | "(" Type ")" .
233 // ArrayType | StructType | PointerType | FunctionType | InterfaceType |
234 // SliceType | MapType | ChannelType .
239 const Token
* token
= this->peek_token();
240 if (token
->is_identifier())
241 return this->type_name(true);
242 else if (token
->is_op(OPERATOR_LSQUARE
))
243 return this->array_type(false);
244 else if (token
->is_keyword(KEYWORD_CHAN
)
245 || token
->is_op(OPERATOR_CHANOP
))
246 return this->channel_type();
247 else if (token
->is_keyword(KEYWORD_INTERFACE
))
248 return this->interface_type();
249 else if (token
->is_keyword(KEYWORD_FUNC
))
251 Location location
= token
->location();
252 this->advance_token();
253 Type
* type
= this->signature(NULL
, location
);
255 return Type::make_error_type();
258 else if (token
->is_keyword(KEYWORD_MAP
))
259 return this->map_type();
260 else if (token
->is_keyword(KEYWORD_STRUCT
))
261 return this->struct_type();
262 else if (token
->is_op(OPERATOR_MULT
))
263 return this->pointer_type();
264 else if (token
->is_op(OPERATOR_LPAREN
))
266 this->advance_token();
267 Type
* ret
= this->type();
268 if (this->peek_token()->is_op(OPERATOR_RPAREN
))
269 this->advance_token();
272 if (!ret
->is_error_type())
273 error_at(this->location(), "expected %<)%>");
279 error_at(token
->location(), "expected type");
280 return Type::make_error_type();
285 Parse::type_may_start_here()
287 const Token
* token
= this->peek_token();
288 return (token
->is_identifier()
289 || token
->is_op(OPERATOR_LSQUARE
)
290 || token
->is_op(OPERATOR_CHANOP
)
291 || token
->is_keyword(KEYWORD_CHAN
)
292 || token
->is_keyword(KEYWORD_INTERFACE
)
293 || token
->is_keyword(KEYWORD_FUNC
)
294 || token
->is_keyword(KEYWORD_MAP
)
295 || token
->is_keyword(KEYWORD_STRUCT
)
296 || token
->is_op(OPERATOR_MULT
)
297 || token
->is_op(OPERATOR_LPAREN
));
300 // TypeName = QualifiedIdent .
302 // If MAY_BE_NIL is true, then an identifier with the value of the
303 // predefined constant nil is accepted, returning the nil type.
306 Parse::type_name(bool issue_error
)
308 Location location
= this->location();
311 Named_object
* package
;
312 if (!this->qualified_ident(&name
, &package
))
313 return Type::make_error_type();
315 Named_object
* named_object
;
317 named_object
= this->gogo_
->lookup(name
, NULL
);
320 named_object
= package
->package_value()->lookup(name
);
321 if (named_object
== NULL
323 && package
->name() != this->gogo_
->package_name())
325 // Check whether the name is there but hidden.
326 std::string s
= ('.' + package
->package_value()->pkgpath()
328 named_object
= package
->package_value()->lookup(s
);
329 if (named_object
!= NULL
)
331 Package
* p
= package
->package_value();
332 const std::string
& packname(p
->package_name());
333 error_at(location
, "invalid reference to hidden type %<%s.%s%>",
334 Gogo::message_name(packname
).c_str(),
335 Gogo::message_name(name
).c_str());
342 if (named_object
== NULL
)
345 named_object
= this->gogo_
->add_unknown_name(name
, location
);
348 const std::string
& packname(package
->package_value()->package_name());
349 error_at(location
, "reference to undefined identifier %<%s.%s%>",
350 Gogo::message_name(packname
).c_str(),
351 Gogo::message_name(name
).c_str());
356 else if (named_object
->is_type())
358 if (!named_object
->type_value()->is_visible())
361 else if (named_object
->is_unknown() || named_object
->is_type_declaration())
369 error_at(location
, "expected type");
370 return Type::make_error_type();
373 if (named_object
->is_type())
374 return named_object
->type_value();
375 else if (named_object
->is_unknown() || named_object
->is_type_declaration())
376 return Type::make_forward_declaration(named_object
);
381 // ArrayType = "[" [ ArrayLength ] "]" ElementType .
382 // ArrayLength = Expression .
383 // ElementType = CompleteType .
386 Parse::array_type(bool may_use_ellipsis
)
388 go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE
));
389 const Token
* token
= this->advance_token();
391 Expression
* length
= NULL
;
392 if (token
->is_op(OPERATOR_RSQUARE
))
393 this->advance_token();
396 if (!token
->is_op(OPERATOR_ELLIPSIS
))
397 length
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
398 else if (may_use_ellipsis
)
400 // An ellipsis is used in composite literals to represent a
401 // fixed array of the size of the number of elements. We
402 // use a length of nil to represent this, and change the
403 // length when parsing the composite literal.
404 length
= Expression::make_nil(this->location());
405 this->advance_token();
409 error_at(this->location(),
410 "use of %<[...]%> outside of array literal");
411 length
= Expression::make_error(this->location());
412 this->advance_token();
414 if (!this->peek_token()->is_op(OPERATOR_RSQUARE
))
416 error_at(this->location(), "expected %<]%>");
417 return Type::make_error_type();
419 this->advance_token();
422 Type
* element_type
= this->type();
424 return Type::make_array_type(element_type
, length
);
427 // MapType = "map" "[" KeyType "]" ValueType .
428 // KeyType = CompleteType .
429 // ValueType = CompleteType .
434 Location location
= this->location();
435 go_assert(this->peek_token()->is_keyword(KEYWORD_MAP
));
436 if (!this->advance_token()->is_op(OPERATOR_LSQUARE
))
438 error_at(this->location(), "expected %<[%>");
439 return Type::make_error_type();
441 this->advance_token();
443 Type
* key_type
= this->type();
445 if (!this->peek_token()->is_op(OPERATOR_RSQUARE
))
447 error_at(this->location(), "expected %<]%>");
448 return Type::make_error_type();
450 this->advance_token();
452 Type
* value_type
= this->type();
454 if (key_type
->is_error_type() || value_type
->is_error_type())
455 return Type::make_error_type();
457 return Type::make_map_type(key_type
, value_type
, location
);
460 // StructType = "struct" "{" { FieldDecl ";" } "}" .
465 go_assert(this->peek_token()->is_keyword(KEYWORD_STRUCT
));
466 Location location
= this->location();
467 if (!this->advance_token()->is_op(OPERATOR_LCURLY
))
469 Location token_loc
= this->location();
470 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
)
471 && this->advance_token()->is_op(OPERATOR_LCURLY
))
472 error_at(token_loc
, "unexpected semicolon or newline before %<{%>");
475 error_at(this->location(), "expected %<{%>");
476 return Type::make_error_type();
479 this->advance_token();
481 Struct_field_list
* sfl
= new Struct_field_list
;
482 while (!this->peek_token()->is_op(OPERATOR_RCURLY
))
484 this->field_decl(sfl
);
485 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
))
486 this->advance_token();
487 else if (!this->peek_token()->is_op(OPERATOR_RCURLY
))
489 error_at(this->location(), "expected %<;%> or %<}%> or newline");
490 if (!this->skip_past_error(OPERATOR_RCURLY
))
491 return Type::make_error_type();
494 this->advance_token();
496 for (Struct_field_list::const_iterator pi
= sfl
->begin();
500 if (pi
->type()->is_error_type())
502 for (Struct_field_list::const_iterator pj
= pi
+ 1;
506 if (pi
->field_name() == pj
->field_name()
507 && !Gogo::is_sink_name(pi
->field_name()))
508 error_at(pi
->location(), "duplicate field name %<%s%>",
509 Gogo::message_name(pi
->field_name()).c_str());
513 return Type::make_struct_type(sfl
, location
);
516 // FieldDecl = (IdentifierList CompleteType | TypeName) [ Tag ] .
517 // Tag = string_lit .
520 Parse::field_decl(Struct_field_list
* sfl
)
522 const Token
* token
= this->peek_token();
523 Location location
= token
->location();
525 bool is_anonymous_pointer
;
526 if (token
->is_op(OPERATOR_MULT
))
529 is_anonymous_pointer
= true;
531 else if (token
->is_identifier())
533 std::string id
= token
->identifier();
534 bool is_id_exported
= token
->is_identifier_exported();
535 Location id_location
= token
->location();
536 token
= this->advance_token();
537 is_anonymous
= (token
->is_op(OPERATOR_SEMICOLON
)
538 || token
->is_op(OPERATOR_RCURLY
)
539 || token
->is_op(OPERATOR_DOT
)
540 || token
->is_string());
541 is_anonymous_pointer
= false;
542 this->unget_token(Token::make_identifier_token(id
, is_id_exported
,
547 error_at(this->location(), "expected field name");
548 this->gogo_
->mark_locals_used();
549 while (!token
->is_op(OPERATOR_SEMICOLON
)
550 && !token
->is_op(OPERATOR_RCURLY
)
552 token
= this->advance_token();
558 if (is_anonymous_pointer
)
560 this->advance_token();
561 if (!this->peek_token()->is_identifier())
563 error_at(this->location(), "expected field name");
564 this->gogo_
->mark_locals_used();
565 while (!token
->is_op(OPERATOR_SEMICOLON
)
566 && !token
->is_op(OPERATOR_RCURLY
)
568 token
= this->advance_token();
572 Type
* type
= this->type_name(true);
575 if (this->peek_token()->is_string())
577 tag
= this->peek_token()->string_value();
578 this->advance_token();
581 if (!type
->is_error_type())
583 if (is_anonymous_pointer
)
584 type
= Type::make_pointer_type(type
);
585 sfl
->push_back(Struct_field(Typed_identifier("", type
, location
)));
587 sfl
->back().set_tag(tag
);
592 Typed_identifier_list til
;
595 token
= this->peek_token();
596 if (!token
->is_identifier())
598 error_at(this->location(), "expected identifier");
602 this->gogo_
->pack_hidden_name(token
->identifier(),
603 token
->is_identifier_exported());
604 til
.push_back(Typed_identifier(name
, NULL
, token
->location()));
605 if (!this->advance_token()->is_op(OPERATOR_COMMA
))
607 this->advance_token();
610 Type
* type
= this->type();
613 if (this->peek_token()->is_string())
615 tag
= this->peek_token()->string_value();
616 this->advance_token();
619 for (Typed_identifier_list::iterator p
= til
.begin();
624 sfl
->push_back(Struct_field(*p
));
626 sfl
->back().set_tag(tag
);
631 // PointerType = "*" Type .
634 Parse::pointer_type()
636 go_assert(this->peek_token()->is_op(OPERATOR_MULT
));
637 this->advance_token();
638 Type
* type
= this->type();
639 if (type
->is_error_type())
641 return Type::make_pointer_type(type
);
644 // ChannelType = Channel | SendChannel | RecvChannel .
645 // Channel = "chan" ElementType .
646 // SendChannel = "chan" "<-" ElementType .
647 // RecvChannel = "<-" "chan" ElementType .
650 Parse::channel_type()
652 const Token
* token
= this->peek_token();
655 if (token
->is_op(OPERATOR_CHANOP
))
657 if (!this->advance_token()->is_keyword(KEYWORD_CHAN
))
659 error_at(this->location(), "expected %<chan%>");
660 return Type::make_error_type();
663 this->advance_token();
667 go_assert(token
->is_keyword(KEYWORD_CHAN
));
668 if (this->advance_token()->is_op(OPERATOR_CHANOP
))
671 this->advance_token();
675 // Better error messages for the common error of omitting the
676 // channel element type.
677 if (!this->type_may_start_here())
679 token
= this->peek_token();
680 if (token
->is_op(OPERATOR_RCURLY
))
681 error_at(this->location(), "unexpected %<}%> in channel type");
682 else if (token
->is_op(OPERATOR_RPAREN
))
683 error_at(this->location(), "unexpected %<)%> in channel type");
684 else if (token
->is_op(OPERATOR_COMMA
))
685 error_at(this->location(), "unexpected comma in channel type");
687 error_at(this->location(), "expected channel element type");
688 return Type::make_error_type();
691 Type
* element_type
= this->type();
692 return Type::make_channel_type(send
, receive
, element_type
);
695 // Give an error for a duplicate parameter or receiver name.
698 Parse::check_signature_names(const Typed_identifier_list
* params
,
701 for (Typed_identifier_list::const_iterator p
= params
->begin();
705 if (p
->name().empty() || Gogo::is_sink_name(p
->name()))
707 std::pair
<std::string
, const Typed_identifier
*> val
=
708 std::make_pair(p
->name(), &*p
);
709 std::pair
<Parse::Names::iterator
, bool> ins
= names
->insert(val
);
712 error_at(p
->location(), "redefinition of %qs",
713 Gogo::message_name(p
->name()).c_str());
714 inform(ins
.first
->second
->location(),
715 "previous definition of %qs was here",
716 Gogo::message_name(p
->name()).c_str());
721 // Signature = Parameters [ Result ] .
723 // RECEIVER is the receiver if there is one, or NULL. LOCATION is the
724 // location of the start of the type.
726 // This returns NULL on a parse error.
729 Parse::signature(Typed_identifier
* receiver
, Location location
)
731 bool is_varargs
= false;
732 Typed_identifier_list
* params
;
733 bool params_ok
= this->parameters(¶ms
, &is_varargs
);
735 Typed_identifier_list
* results
= NULL
;
736 if (this->peek_token()->is_op(OPERATOR_LPAREN
)
737 || this->type_may_start_here())
739 if (!this->result(&results
))
748 this->check_signature_names(params
, &names
);
750 this->check_signature_names(results
, &names
);
752 Function_type
* ret
= Type::make_function_type(receiver
, params
, results
,
755 ret
->set_is_varargs();
759 // Parameters = "(" [ ParameterList [ "," ] ] ")" .
761 // This returns false on a parse error.
764 Parse::parameters(Typed_identifier_list
** pparams
, bool* is_varargs
)
768 if (!this->peek_token()->is_op(OPERATOR_LPAREN
))
770 error_at(this->location(), "expected %<(%>");
774 Typed_identifier_list
* params
= NULL
;
775 bool saw_error
= false;
777 const Token
* token
= this->advance_token();
778 if (!token
->is_op(OPERATOR_RPAREN
))
780 params
= this->parameter_list(is_varargs
);
783 token
= this->peek_token();
786 // The optional trailing comma is picked up in parameter_list.
788 if (!token
->is_op(OPERATOR_RPAREN
))
789 error_at(this->location(), "expected %<)%>");
791 this->advance_token();
800 // ParameterList = ParameterDecl { "," ParameterDecl } .
802 // This sets *IS_VARARGS if the list ends with an ellipsis.
803 // IS_VARARGS will be NULL if varargs are not permitted.
805 // We pick up an optional trailing comma.
807 // This returns NULL if some error is seen.
809 Typed_identifier_list
*
810 Parse::parameter_list(bool* is_varargs
)
812 Location location
= this->location();
813 Typed_identifier_list
* ret
= new Typed_identifier_list();
815 bool saw_error
= false;
817 // If we see an identifier and then a comma, then we don't know
818 // whether we are looking at a list of identifiers followed by a
819 // type, or a list of types given by name. We have to do an
820 // arbitrary lookahead to figure it out.
822 bool parameters_have_names
;
823 const Token
* token
= this->peek_token();
824 if (!token
->is_identifier())
826 // This must be a type which starts with something like '*'.
827 parameters_have_names
= false;
831 std::string name
= token
->identifier();
832 bool is_exported
= token
->is_identifier_exported();
833 Location location
= token
->location();
834 token
= this->advance_token();
835 if (!token
->is_op(OPERATOR_COMMA
))
837 if (token
->is_op(OPERATOR_DOT
))
839 // This is a qualified identifier, which must turn out
841 parameters_have_names
= false;
843 else if (token
->is_op(OPERATOR_RPAREN
))
845 // A single identifier followed by a parenthesis must be
847 parameters_have_names
= false;
851 // An identifier followed by something other than a
852 // comma or a dot or a right parenthesis must be a
853 // parameter name followed by a type.
854 parameters_have_names
= true;
857 this->unget_token(Token::make_identifier_token(name
, is_exported
,
862 // An identifier followed by a comma may be the first in a
863 // list of parameter names followed by a type, or it may be
864 // the first in a list of types without parameter names. To
865 // find out we gather as many identifiers separated by
867 std::string id_name
= this->gogo_
->pack_hidden_name(name
,
869 ret
->push_back(Typed_identifier(id_name
, NULL
, location
));
870 bool just_saw_comma
= true;
871 while (this->advance_token()->is_identifier())
873 name
= this->peek_token()->identifier();
874 is_exported
= this->peek_token()->is_identifier_exported();
875 location
= this->peek_token()->location();
876 id_name
= this->gogo_
->pack_hidden_name(name
, is_exported
);
877 ret
->push_back(Typed_identifier(id_name
, NULL
, location
));
878 if (!this->advance_token()->is_op(OPERATOR_COMMA
))
880 just_saw_comma
= false;
887 // We saw ID1 "," ID2 "," followed by something which
888 // was not an identifier. We must be seeing the start
889 // of a type, and ID1 and ID2 must be types, and the
890 // parameters don't have names.
891 parameters_have_names
= false;
893 else if (this->peek_token()->is_op(OPERATOR_RPAREN
))
895 // We saw ID1 "," ID2 ")". ID1 and ID2 must be types,
896 // and the parameters don't have names.
897 parameters_have_names
= false;
899 else if (this->peek_token()->is_op(OPERATOR_DOT
))
901 // We saw ID1 "," ID2 ".". ID2 must be a package name,
902 // ID1 must be a type, and the parameters don't have
904 parameters_have_names
= false;
905 this->unget_token(Token::make_identifier_token(name
, is_exported
,
908 just_saw_comma
= true;
912 // We saw ID1 "," ID2 followed by something other than
913 // ",", ".", or ")". We must be looking at the start of
914 // a type, and ID1 and ID2 must be parameter names.
915 parameters_have_names
= true;
918 if (parameters_have_names
)
920 go_assert(!just_saw_comma
);
921 // We have just seen ID1, ID2 xxx.
923 if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS
))
927 error_at(this->location(), "%<...%> only permits one name");
929 this->advance_token();
932 for (size_t i
= 0; i
< ret
->size(); ++i
)
933 ret
->set_type(i
, type
);
934 if (!this->peek_token()->is_op(OPERATOR_COMMA
))
935 return saw_error
? NULL
: ret
;
936 if (this->advance_token()->is_op(OPERATOR_RPAREN
))
937 return saw_error
? NULL
: ret
;
941 Typed_identifier_list
* tret
= new Typed_identifier_list();
942 for (Typed_identifier_list::const_iterator p
= ret
->begin();
946 Named_object
* no
= this->gogo_
->lookup(p
->name(), NULL
);
949 no
= this->gogo_
->add_unknown_name(p
->name(),
953 type
= no
->type_value();
954 else if (no
->is_unknown() || no
->is_type_declaration())
955 type
= Type::make_forward_declaration(no
);
958 error_at(p
->location(), "expected %<%s%> to be a type",
959 Gogo::message_name(p
->name()).c_str());
961 type
= Type::make_error_type();
963 tret
->push_back(Typed_identifier("", type
, p
->location()));
968 || this->peek_token()->is_op(OPERATOR_RPAREN
))
969 return saw_error
? NULL
: ret
;
974 bool mix_error
= false;
975 this->parameter_decl(parameters_have_names
, ret
, is_varargs
, &mix_error
);
976 while (this->peek_token()->is_op(OPERATOR_COMMA
))
978 if (is_varargs
!= NULL
&& *is_varargs
)
980 error_at(this->location(), "%<...%> must be last parameter");
983 if (this->advance_token()->is_op(OPERATOR_RPAREN
))
985 this->parameter_decl(parameters_have_names
, ret
, is_varargs
, &mix_error
);
989 error_at(location
, "invalid named/anonymous mix");
1000 // ParameterDecl = [ IdentifierList ] [ "..." ] Type .
1003 Parse::parameter_decl(bool parameters_have_names
,
1004 Typed_identifier_list
* til
,
1008 if (!parameters_have_names
)
1011 Location location
= this->location();
1012 if (!this->peek_token()->is_identifier())
1014 if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS
))
1015 type
= this->type();
1018 if (is_varargs
== NULL
)
1019 error_at(this->location(), "invalid use of %<...%>");
1022 this->advance_token();
1023 if (is_varargs
== NULL
1024 && this->peek_token()->is_op(OPERATOR_RPAREN
))
1025 type
= Type::make_error_type();
1028 Type
* element_type
= this->type();
1029 type
= Type::make_array_type(element_type
, NULL
);
1035 type
= this->type_name(false);
1036 if (type
->is_error_type()
1037 || (!this->peek_token()->is_op(OPERATOR_COMMA
)
1038 && !this->peek_token()->is_op(OPERATOR_RPAREN
)))
1041 while (!this->peek_token()->is_op(OPERATOR_COMMA
)
1042 && !this->peek_token()->is_op(OPERATOR_RPAREN
))
1043 this->advance_token();
1046 if (!type
->is_error_type())
1047 til
->push_back(Typed_identifier("", type
, location
));
1051 size_t orig_count
= til
->size();
1052 if (this->peek_token()->is_identifier())
1053 this->identifier_list(til
);
1056 size_t new_count
= til
->size();
1059 if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS
))
1060 type
= this->type();
1063 if (is_varargs
== NULL
)
1064 error_at(this->location(), "invalid use of %<...%>");
1065 else if (new_count
> orig_count
+ 1)
1066 error_at(this->location(), "%<...%> only permits one name");
1069 this->advance_token();
1070 Type
* element_type
= this->type();
1071 type
= Type::make_array_type(element_type
, NULL
);
1073 for (size_t i
= orig_count
; i
< new_count
; ++i
)
1074 til
->set_type(i
, type
);
1078 // Result = Parameters | Type .
1080 // This returns false on a parse error.
1083 Parse::result(Typed_identifier_list
** presults
)
1085 if (this->peek_token()->is_op(OPERATOR_LPAREN
))
1086 return this->parameters(presults
, NULL
);
1089 Location location
= this->location();
1090 Type
* type
= this->type();
1091 if (type
->is_error_type())
1096 Typed_identifier_list
* til
= new Typed_identifier_list();
1097 til
->push_back(Typed_identifier("", type
, location
));
1103 // Block = "{" [ StatementList ] "}" .
1105 // Returns the location of the closing brace.
1110 if (!this->peek_token()->is_op(OPERATOR_LCURLY
))
1112 Location loc
= this->location();
1113 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
)
1114 && this->advance_token()->is_op(OPERATOR_LCURLY
))
1115 error_at(loc
, "unexpected semicolon or newline before %<{%>");
1118 error_at(this->location(), "expected %<{%>");
1119 return Linemap::unknown_location();
1123 const Token
* token
= this->advance_token();
1125 if (!token
->is_op(OPERATOR_RCURLY
))
1127 this->statement_list();
1128 token
= this->peek_token();
1129 if (!token
->is_op(OPERATOR_RCURLY
))
1131 if (!token
->is_eof() || !saw_errors())
1132 error_at(this->location(), "expected %<}%>");
1134 this->gogo_
->mark_locals_used();
1136 // Skip ahead to the end of the block, in hopes of avoiding
1137 // lots of meaningless errors.
1138 Location ret
= token
->location();
1140 while (!token
->is_eof())
1142 if (token
->is_op(OPERATOR_LCURLY
))
1144 else if (token
->is_op(OPERATOR_RCURLY
))
1149 this->advance_token();
1153 token
= this->advance_token();
1154 ret
= token
->location();
1160 Location ret
= token
->location();
1161 this->advance_token();
1165 // InterfaceType = "interface" "{" [ MethodSpecList ] "}" .
1166 // MethodSpecList = MethodSpec { ";" MethodSpec } [ ";" ] .
1169 Parse::interface_type()
1171 go_assert(this->peek_token()->is_keyword(KEYWORD_INTERFACE
));
1172 Location location
= this->location();
1174 if (!this->advance_token()->is_op(OPERATOR_LCURLY
))
1176 Location token_loc
= this->location();
1177 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
)
1178 && this->advance_token()->is_op(OPERATOR_LCURLY
))
1179 error_at(token_loc
, "unexpected semicolon or newline before %<{%>");
1182 error_at(this->location(), "expected %<{%>");
1183 return Type::make_error_type();
1186 this->advance_token();
1188 Typed_identifier_list
* methods
= new Typed_identifier_list();
1189 if (!this->peek_token()->is_op(OPERATOR_RCURLY
))
1191 this->method_spec(methods
);
1192 while (this->peek_token()->is_op(OPERATOR_SEMICOLON
))
1194 if (this->advance_token()->is_op(OPERATOR_RCURLY
))
1196 this->method_spec(methods
);
1198 if (!this->peek_token()->is_op(OPERATOR_RCURLY
))
1200 error_at(this->location(), "expected %<}%>");
1201 while (!this->advance_token()->is_op(OPERATOR_RCURLY
))
1203 if (this->peek_token()->is_eof())
1204 return Type::make_error_type();
1208 this->advance_token();
1210 if (methods
->empty())
1216 Interface_type
* ret
= Type::make_interface_type(methods
, location
);
1217 this->gogo_
->record_interface_type(ret
);
1221 // MethodSpec = MethodName Signature | InterfaceTypeName .
1222 // MethodName = identifier .
1223 // InterfaceTypeName = TypeName .
1226 Parse::method_spec(Typed_identifier_list
* methods
)
1228 const Token
* token
= this->peek_token();
1229 if (!token
->is_identifier())
1231 error_at(this->location(), "expected identifier");
1235 std::string name
= token
->identifier();
1236 bool is_exported
= token
->is_identifier_exported();
1237 Location location
= token
->location();
1239 if (this->advance_token()->is_op(OPERATOR_LPAREN
))
1241 // This is a MethodName.
1242 name
= this->gogo_
->pack_hidden_name(name
, is_exported
);
1243 Type
* type
= this->signature(NULL
, location
);
1246 methods
->push_back(Typed_identifier(name
, type
, location
));
1250 this->unget_token(Token::make_identifier_token(name
, is_exported
,
1252 Type
* type
= this->type_name(false);
1253 if (type
->is_error_type()
1254 || (!this->peek_token()->is_op(OPERATOR_SEMICOLON
)
1255 && !this->peek_token()->is_op(OPERATOR_RCURLY
)))
1257 if (this->peek_token()->is_op(OPERATOR_COMMA
))
1258 error_at(this->location(),
1259 "name list not allowed in interface type");
1261 error_at(location
, "expected signature or type name");
1262 this->gogo_
->mark_locals_used();
1263 token
= this->peek_token();
1264 while (!token
->is_eof()
1265 && !token
->is_op(OPERATOR_SEMICOLON
)
1266 && !token
->is_op(OPERATOR_RCURLY
))
1267 token
= this->advance_token();
1270 // This must be an interface type, but we can't check that now.
1271 // We check it and pull out the methods in
1272 // Interface_type::do_verify.
1273 methods
->push_back(Typed_identifier("", type
, location
));
1277 // Declaration = ConstDecl | TypeDecl | VarDecl | FunctionDecl | MethodDecl .
1280 Parse::declaration()
1282 const Token
* token
= this->peek_token();
1283 if (token
->is_keyword(KEYWORD_CONST
))
1285 else if (token
->is_keyword(KEYWORD_TYPE
))
1287 else if (token
->is_keyword(KEYWORD_VAR
))
1289 else if (token
->is_keyword(KEYWORD_FUNC
))
1290 this->function_decl();
1293 error_at(this->location(), "expected declaration");
1294 this->advance_token();
1299 Parse::declaration_may_start_here()
1301 const Token
* token
= this->peek_token();
1302 return (token
->is_keyword(KEYWORD_CONST
)
1303 || token
->is_keyword(KEYWORD_TYPE
)
1304 || token
->is_keyword(KEYWORD_VAR
)
1305 || token
->is_keyword(KEYWORD_FUNC
));
1308 // Decl<P> = P | "(" [ List<P> ] ")" .
1311 Parse::decl(void (Parse::*pfn
)(void*), void* varg
)
1313 if (this->peek_token()->is_eof())
1316 error_at(this->location(), "unexpected end of file");
1320 if (!this->peek_token()->is_op(OPERATOR_LPAREN
))
1324 if (!this->advance_token()->is_op(OPERATOR_RPAREN
))
1326 this->list(pfn
, varg
, true);
1327 if (!this->peek_token()->is_op(OPERATOR_RPAREN
))
1329 error_at(this->location(), "missing %<)%>");
1330 while (!this->advance_token()->is_op(OPERATOR_RPAREN
))
1332 if (this->peek_token()->is_eof())
1337 this->advance_token();
1341 // List<P> = P { ";" P } [ ";" ] .
1343 // In order to pick up the trailing semicolon we need to know what
1344 // might follow. This is either a '}' or a ')'.
1347 Parse::list(void (Parse::*pfn
)(void*), void* varg
, bool follow_is_paren
)
1350 Operator follow
= follow_is_paren
? OPERATOR_RPAREN
: OPERATOR_RCURLY
;
1351 while (this->peek_token()->is_op(OPERATOR_SEMICOLON
)
1352 || this->peek_token()->is_op(OPERATOR_COMMA
))
1354 if (this->peek_token()->is_op(OPERATOR_COMMA
))
1355 error_at(this->location(), "unexpected comma");
1356 if (this->advance_token()->is_op(follow
))
1362 // ConstDecl = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
1367 go_assert(this->peek_token()->is_keyword(KEYWORD_CONST
));
1368 this->advance_token();
1371 Type
* last_type
= NULL
;
1372 Expression_list
* last_expr_list
= NULL
;
1374 if (!this->peek_token()->is_op(OPERATOR_LPAREN
))
1375 this->const_spec(&last_type
, &last_expr_list
);
1378 this->advance_token();
1379 while (!this->peek_token()->is_op(OPERATOR_RPAREN
))
1381 this->const_spec(&last_type
, &last_expr_list
);
1382 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
))
1383 this->advance_token();
1384 else if (!this->peek_token()->is_op(OPERATOR_RPAREN
))
1386 error_at(this->location(), "expected %<;%> or %<)%> or newline");
1387 if (!this->skip_past_error(OPERATOR_RPAREN
))
1391 this->advance_token();
1394 if (last_expr_list
!= NULL
)
1395 delete last_expr_list
;
1398 // ConstSpec = IdentifierList [ [ CompleteType ] "=" ExpressionList ] .
1401 Parse::const_spec(Type
** last_type
, Expression_list
** last_expr_list
)
1403 Typed_identifier_list til
;
1404 this->identifier_list(&til
);
1407 if (this->type_may_start_here())
1409 type
= this->type();
1411 *last_expr_list
= NULL
;
1414 Expression_list
*expr_list
;
1415 if (!this->peek_token()->is_op(OPERATOR_EQ
))
1417 if (*last_expr_list
== NULL
)
1419 error_at(this->location(), "expected %<=%>");
1423 expr_list
= new Expression_list
;
1424 for (Expression_list::const_iterator p
= (*last_expr_list
)->begin();
1425 p
!= (*last_expr_list
)->end();
1427 expr_list
->push_back((*p
)->copy());
1431 this->advance_token();
1432 expr_list
= this->expression_list(NULL
, false, true);
1434 if (*last_expr_list
!= NULL
)
1435 delete *last_expr_list
;
1436 *last_expr_list
= expr_list
;
1439 Expression_list::const_iterator pe
= expr_list
->begin();
1440 for (Typed_identifier_list::iterator pi
= til
.begin();
1444 if (pe
== expr_list
->end())
1446 error_at(this->location(), "not enough initializers");
1452 if (!Gogo::is_sink_name(pi
->name()))
1453 this->gogo_
->add_constant(*pi
, *pe
, this->iota_value());
1455 if (pe
!= expr_list
->end())
1456 error_at(this->location(), "too many initializers");
1458 this->increment_iota();
1463 // TypeDecl = "type" Decl<TypeSpec> .
1468 go_assert(this->peek_token()->is_keyword(KEYWORD_TYPE
));
1469 this->advance_token();
1470 this->decl(&Parse::type_spec
, NULL
);
1473 // TypeSpec = identifier Type .
1476 Parse::type_spec(void*)
1478 const Token
* token
= this->peek_token();
1479 if (!token
->is_identifier())
1481 error_at(this->location(), "expected identifier");
1484 std::string name
= token
->identifier();
1485 bool is_exported
= token
->is_identifier_exported();
1486 Location location
= token
->location();
1487 token
= this->advance_token();
1489 // The scope of the type name starts at the point where the
1490 // identifier appears in the source code. We implement this by
1491 // declaring the type before we read the type definition.
1492 Named_object
* named_type
= NULL
;
1495 name
= this->gogo_
->pack_hidden_name(name
, is_exported
);
1496 named_type
= this->gogo_
->declare_type(name
, location
);
1500 if (!this->peek_token()->is_op(OPERATOR_SEMICOLON
))
1501 type
= this->type();
1504 error_at(this->location(),
1505 "unexpected semicolon or newline in type declaration");
1506 type
= Type::make_error_type();
1507 this->advance_token();
1510 if (type
->is_error_type())
1512 this->gogo_
->mark_locals_used();
1513 while (!this->peek_token()->is_op(OPERATOR_SEMICOLON
)
1514 && !this->peek_token()->is_eof())
1515 this->advance_token();
1520 if (named_type
->is_type_declaration())
1522 Type
* ftype
= type
->forwarded();
1523 if (ftype
->forward_declaration_type() != NULL
1524 && (ftype
->forward_declaration_type()->named_object()
1527 error_at(location
, "invalid recursive type");
1528 type
= Type::make_error_type();
1531 this->gogo_
->define_type(named_type
,
1532 Type::make_named_type(named_type
, type
,
1534 go_assert(named_type
->package() == NULL
);
1538 // This will probably give a redefinition error.
1539 this->gogo_
->add_type(name
, type
, location
);
1544 // VarDecl = "var" Decl<VarSpec> .
1549 go_assert(this->peek_token()->is_keyword(KEYWORD_VAR
));
1550 this->advance_token();
1551 this->decl(&Parse::var_spec
, NULL
);
1554 // VarSpec = IdentifierList
1555 // ( CompleteType [ "=" ExpressionList ] | "=" ExpressionList ) .
1558 Parse::var_spec(void*)
1560 // Get the variable names.
1561 Typed_identifier_list til
;
1562 this->identifier_list(&til
);
1564 Location location
= this->location();
1567 Expression_list
* init
= NULL
;
1568 if (!this->peek_token()->is_op(OPERATOR_EQ
))
1570 type
= this->type();
1571 if (type
->is_error_type())
1573 this->gogo_
->mark_locals_used();
1574 while (!this->peek_token()->is_op(OPERATOR_EQ
)
1575 && !this->peek_token()->is_op(OPERATOR_SEMICOLON
)
1576 && !this->peek_token()->is_eof())
1577 this->advance_token();
1579 if (this->peek_token()->is_op(OPERATOR_EQ
))
1581 this->advance_token();
1582 init
= this->expression_list(NULL
, false, true);
1587 this->advance_token();
1588 init
= this->expression_list(NULL
, false, true);
1591 this->init_vars(&til
, type
, init
, false, location
);
1597 // Create variables. TIL is a list of variable names. If TYPE is not
1598 // NULL, it is the type of all the variables. If INIT is not NULL, it
1599 // is an initializer list for the variables.
1602 Parse::init_vars(const Typed_identifier_list
* til
, Type
* type
,
1603 Expression_list
* init
, bool is_coloneq
,
1606 // Check for an initialization which can yield multiple values.
1607 if (init
!= NULL
&& init
->size() == 1 && til
->size() > 1)
1609 if (this->init_vars_from_call(til
, type
, *init
->begin(), is_coloneq
,
1612 if (this->init_vars_from_map(til
, type
, *init
->begin(), is_coloneq
,
1615 if (this->init_vars_from_receive(til
, type
, *init
->begin(), is_coloneq
,
1618 if (this->init_vars_from_type_guard(til
, type
, *init
->begin(),
1619 is_coloneq
, location
))
1623 if (init
!= NULL
&& init
->size() != til
->size())
1625 if (init
->empty() || !init
->front()->is_error_expression())
1626 error_at(location
, "wrong number of initializations");
1629 type
= Type::make_error_type();
1632 // Note that INIT was already parsed with the old name bindings, so
1633 // we don't have to worry that it will accidentally refer to the
1634 // newly declared variables.
1636 Expression_list::const_iterator pexpr
;
1638 pexpr
= init
->begin();
1639 bool any_new
= false;
1640 for (Typed_identifier_list::const_iterator p
= til
->begin();
1645 go_assert(pexpr
!= init
->end());
1646 this->init_var(*p
, type
, init
== NULL
? NULL
: *pexpr
, is_coloneq
,
1652 go_assert(pexpr
== init
->end());
1653 if (is_coloneq
&& !any_new
)
1654 error_at(location
, "variables redeclared but no variable is new");
1657 // See if we need to initialize a list of variables from a function
1658 // call. This returns true if we have set up the variables and the
1662 Parse::init_vars_from_call(const Typed_identifier_list
* vars
, Type
* type
,
1663 Expression
* expr
, bool is_coloneq
,
1666 Call_expression
* call
= expr
->call_expression();
1670 // This is a function call. We can't check here whether it returns
1671 // the right number of values, but it might. Declare the variables,
1672 // and then assign the results of the call to them.
1674 Named_object
* first_var
= NULL
;
1675 unsigned int index
= 0;
1676 bool any_new
= false;
1677 for (Typed_identifier_list::const_iterator pv
= vars
->begin();
1681 Expression
* init
= Expression::make_call_result(call
, index
);
1682 Named_object
* no
= this->init_var(*pv
, type
, init
, is_coloneq
, false,
1685 if (this->gogo_
->in_global_scope() && no
->is_variable())
1687 if (first_var
== NULL
)
1691 // The subsequent vars have an implicit dependency on
1692 // the first one, so that everything gets initialized in
1693 // the right order and so that we detect cycles
1695 this->gogo_
->record_var_depends_on(no
->var_value(), first_var
);
1700 if (is_coloneq
&& !any_new
)
1701 error_at(location
, "variables redeclared but no variable is new");
1706 // See if we need to initialize a pair of values from a map index
1707 // expression. This returns true if we have set up the variables and
1708 // the initialization.
1711 Parse::init_vars_from_map(const Typed_identifier_list
* vars
, Type
* type
,
1712 Expression
* expr
, bool is_coloneq
,
1715 Index_expression
* index
= expr
->index_expression();
1718 if (vars
->size() != 2)
1721 // This is an index which is being assigned to two variables. It
1722 // must be a map index. Declare the variables, and then assign the
1723 // results of the map index.
1724 bool any_new
= false;
1725 Typed_identifier_list::const_iterator p
= vars
->begin();
1726 Expression
* init
= type
== NULL
? index
: NULL
;
1727 Named_object
* val_no
= this->init_var(*p
, type
, init
, is_coloneq
,
1728 type
== NULL
, &any_new
);
1729 if (type
== NULL
&& any_new
&& val_no
->is_variable())
1730 val_no
->var_value()->set_type_from_init_tuple();
1731 Expression
* val_var
= Expression::make_var_reference(val_no
, location
);
1734 Type
* var_type
= type
;
1735 if (var_type
== NULL
)
1736 var_type
= Type::lookup_bool_type();
1737 Named_object
* no
= this->init_var(*p
, var_type
, NULL
, is_coloneq
, false,
1739 Expression
* present_var
= Expression::make_var_reference(no
, location
);
1741 if (is_coloneq
&& !any_new
)
1742 error_at(location
, "variables redeclared but no variable is new");
1744 Statement
* s
= Statement::make_tuple_map_assignment(val_var
, present_var
,
1747 if (!this->gogo_
->in_global_scope())
1748 this->gogo_
->add_statement(s
);
1749 else if (!val_no
->is_sink())
1751 if (val_no
->is_variable())
1752 val_no
->var_value()->add_preinit_statement(this->gogo_
, s
);
1754 else if (!no
->is_sink())
1756 if (no
->is_variable())
1757 no
->var_value()->add_preinit_statement(this->gogo_
, s
);
1761 // Execute the map index expression just so that we can fail if
1763 Named_object
* dummy
= this->create_dummy_global(Type::lookup_bool_type(),
1765 dummy
->var_value()->add_preinit_statement(this->gogo_
, s
);
1771 // See if we need to initialize a pair of values from a receive
1772 // expression. This returns true if we have set up the variables and
1773 // the initialization.
1776 Parse::init_vars_from_receive(const Typed_identifier_list
* vars
, Type
* type
,
1777 Expression
* expr
, bool is_coloneq
,
1780 Receive_expression
* receive
= expr
->receive_expression();
1781 if (receive
== NULL
)
1783 if (vars
->size() != 2)
1786 // This is a receive expression which is being assigned to two
1787 // variables. Declare the variables, and then assign the results of
1789 bool any_new
= false;
1790 Typed_identifier_list::const_iterator p
= vars
->begin();
1791 Expression
* init
= type
== NULL
? receive
: NULL
;
1792 Named_object
* val_no
= this->init_var(*p
, type
, init
, is_coloneq
,
1793 type
== NULL
, &any_new
);
1794 if (type
== NULL
&& any_new
&& val_no
->is_variable())
1795 val_no
->var_value()->set_type_from_init_tuple();
1796 Expression
* val_var
= Expression::make_var_reference(val_no
, location
);
1799 Type
* var_type
= type
;
1800 if (var_type
== NULL
)
1801 var_type
= Type::lookup_bool_type();
1802 Named_object
* no
= this->init_var(*p
, var_type
, NULL
, is_coloneq
, false,
1804 Expression
* received_var
= Expression::make_var_reference(no
, location
);
1806 if (is_coloneq
&& !any_new
)
1807 error_at(location
, "variables redeclared but no variable is new");
1809 Statement
* s
= Statement::make_tuple_receive_assignment(val_var
,
1814 if (!this->gogo_
->in_global_scope())
1815 this->gogo_
->add_statement(s
);
1816 else if (!val_no
->is_sink())
1818 if (val_no
->is_variable())
1819 val_no
->var_value()->add_preinit_statement(this->gogo_
, s
);
1821 else if (!no
->is_sink())
1823 if (no
->is_variable())
1824 no
->var_value()->add_preinit_statement(this->gogo_
, s
);
1828 Named_object
* dummy
= this->create_dummy_global(Type::lookup_bool_type(),
1830 dummy
->var_value()->add_preinit_statement(this->gogo_
, s
);
1836 // See if we need to initialize a pair of values from a type guard
1837 // expression. This returns true if we have set up the variables and
1838 // the initialization.
1841 Parse::init_vars_from_type_guard(const Typed_identifier_list
* vars
,
1842 Type
* type
, Expression
* expr
,
1843 bool is_coloneq
, Location location
)
1845 Type_guard_expression
* type_guard
= expr
->type_guard_expression();
1846 if (type_guard
== NULL
)
1848 if (vars
->size() != 2)
1851 // This is a type guard expression which is being assigned to two
1852 // variables. Declare the variables, and then assign the results of
1854 bool any_new
= false;
1855 Typed_identifier_list::const_iterator p
= vars
->begin();
1856 Type
* var_type
= type
;
1857 if (var_type
== NULL
)
1858 var_type
= type_guard
->type();
1859 Named_object
* val_no
= this->init_var(*p
, var_type
, NULL
, is_coloneq
, false,
1861 Expression
* val_var
= Expression::make_var_reference(val_no
, location
);
1865 if (var_type
== NULL
)
1866 var_type
= Type::lookup_bool_type();
1867 Named_object
* no
= this->init_var(*p
, var_type
, NULL
, is_coloneq
, false,
1869 Expression
* ok_var
= Expression::make_var_reference(no
, location
);
1871 Expression
* texpr
= type_guard
->expr();
1872 Type
* t
= type_guard
->type();
1873 Statement
* s
= Statement::make_tuple_type_guard_assignment(val_var
, ok_var
,
1877 if (is_coloneq
&& !any_new
)
1878 error_at(location
, "variables redeclared but no variable is new");
1880 if (!this->gogo_
->in_global_scope())
1881 this->gogo_
->add_statement(s
);
1882 else if (!val_no
->is_sink())
1884 if (val_no
->is_variable())
1885 val_no
->var_value()->add_preinit_statement(this->gogo_
, s
);
1887 else if (!no
->is_sink())
1889 if (no
->is_variable())
1890 no
->var_value()->add_preinit_statement(this->gogo_
, s
);
1894 Named_object
* dummy
= this->create_dummy_global(type
, NULL
, location
);
1895 dummy
->var_value()->add_preinit_statement(this->gogo_
, s
);
1901 // Create a single variable. If IS_COLONEQ is true, we permit
1902 // redeclarations in the same block, and we set *IS_NEW when we find a
1903 // new variable which is not a redeclaration.
1906 Parse::init_var(const Typed_identifier
& tid
, Type
* type
, Expression
* init
,
1907 bool is_coloneq
, bool type_from_init
, bool* is_new
)
1909 Location location
= tid
.location();
1911 if (Gogo::is_sink_name(tid
.name()))
1913 if (!type_from_init
&& init
!= NULL
)
1915 if (this->gogo_
->in_global_scope())
1916 return this->create_dummy_global(type
, init
, location
);
1917 else if (type
== NULL
)
1918 this->gogo_
->add_statement(Statement::make_statement(init
, true));
1921 // With both a type and an initializer, create a dummy
1922 // variable so that we will check whether the
1923 // initializer can be assigned to the type.
1924 Variable
* var
= new Variable(type
, init
, false, false, false,
1929 snprintf(buf
, sizeof buf
, "sink$%d", count
);
1931 return this->gogo_
->add_variable(buf
, var
);
1935 this->gogo_
->add_type_to_verify(type
);
1936 return this->gogo_
->add_sink();
1941 Named_object
* no
= this->gogo_
->lookup_in_block(tid
.name());
1943 && (no
->is_variable() || no
->is_result_variable()))
1945 // INIT may be NULL even when IS_COLONEQ is true for cases
1946 // like v, ok := x.(int).
1947 if (!type_from_init
&& init
!= NULL
)
1949 Expression
*v
= Expression::make_var_reference(no
, location
);
1950 Statement
*s
= Statement::make_assignment(v
, init
, location
);
1951 this->gogo_
->add_statement(s
);
1957 Variable
* var
= new Variable(type
, init
, this->gogo_
->in_global_scope(),
1958 false, false, location
);
1959 Named_object
* no
= this->gogo_
->add_variable(tid
.name(), var
);
1960 if (!no
->is_variable())
1962 // The name is already defined, so we just gave an error.
1963 return this->gogo_
->add_sink();
1968 // Create a dummy global variable to force an initializer to be run in
1969 // the right place. This is used when a sink variable is initialized
1973 Parse::create_dummy_global(Type
* type
, Expression
* init
,
1976 if (type
== NULL
&& init
== NULL
)
1977 type
= Type::lookup_bool_type();
1978 Variable
* var
= new Variable(type
, init
, true, false, false, location
);
1981 snprintf(buf
, sizeof buf
, "_.%d", count
);
1983 return this->gogo_
->add_variable(buf
, var
);
1986 // SimpleVarDecl = identifier ":=" Expression .
1988 // We've already seen the identifier.
1990 // FIXME: We also have to implement
1991 // IdentifierList ":=" ExpressionList
1992 // In order to support both "a, b := 1, 0" and "a, b = 1, 0" we accept
1993 // tuple assignments here as well.
1995 // If MAY_BE_COMPOSITE_LIT is true, the expression on the right hand
1996 // side may be a composite literal.
1998 // If P_RANGE_CLAUSE is not NULL, then this will recognize a
2001 // If P_TYPE_SWITCH is not NULL, this will recognize a type switch
2002 // guard (var := expr.("type") using the literal keyword "type").
2005 Parse::simple_var_decl_or_assignment(const std::string
& name
,
2007 bool may_be_composite_lit
,
2008 Range_clause
* p_range_clause
,
2009 Type_switch
* p_type_switch
)
2011 Typed_identifier_list til
;
2012 til
.push_back(Typed_identifier(name
, NULL
, location
));
2014 // We've seen one identifier. If we see a comma now, this could be
2016 if (this->peek_token()->is_op(OPERATOR_COMMA
))
2018 go_assert(p_type_switch
== NULL
);
2021 const Token
* token
= this->advance_token();
2022 if (!token
->is_identifier())
2025 std::string id
= token
->identifier();
2026 bool is_id_exported
= token
->is_identifier_exported();
2027 Location id_location
= token
->location();
2029 token
= this->advance_token();
2030 if (!token
->is_op(OPERATOR_COMMA
))
2032 if (token
->is_op(OPERATOR_COLONEQ
))
2034 id
= this->gogo_
->pack_hidden_name(id
, is_id_exported
);
2035 til
.push_back(Typed_identifier(id
, NULL
, location
));
2038 this->unget_token(Token::make_identifier_token(id
,
2044 id
= this->gogo_
->pack_hidden_name(id
, is_id_exported
);
2045 til
.push_back(Typed_identifier(id
, NULL
, location
));
2048 // We have a comma separated list of identifiers in TIL. If the
2049 // next token is COLONEQ, then this is a simple var decl, and we
2050 // have the complete list of identifiers. If the next token is
2051 // not COLONEQ, then the only valid parse is a tuple assignment.
2052 // The list of identifiers we have so far is really a list of
2053 // expressions. There are more expressions following.
2055 if (!this->peek_token()->is_op(OPERATOR_COLONEQ
))
2057 Expression_list
* exprs
= new Expression_list
;
2058 for (Typed_identifier_list::const_iterator p
= til
.begin();
2061 exprs
->push_back(this->id_to_expression(p
->name(),
2064 Expression_list
* more_exprs
=
2065 this->expression_list(NULL
, true, may_be_composite_lit
);
2066 for (Expression_list::const_iterator p
= more_exprs
->begin();
2067 p
!= more_exprs
->end();
2069 exprs
->push_back(*p
);
2072 this->tuple_assignment(exprs
, may_be_composite_lit
, p_range_clause
);
2077 go_assert(this->peek_token()->is_op(OPERATOR_COLONEQ
));
2078 const Token
* token
= this->advance_token();
2080 if (p_range_clause
!= NULL
&& token
->is_keyword(KEYWORD_RANGE
))
2082 this->range_clause_decl(&til
, p_range_clause
);
2086 Expression_list
* init
;
2087 if (p_type_switch
== NULL
)
2088 init
= this->expression_list(NULL
, false, may_be_composite_lit
);
2091 bool is_type_switch
= false;
2092 Expression
* expr
= this->expression(PRECEDENCE_NORMAL
, false,
2093 may_be_composite_lit
,
2097 p_type_switch
->found
= true;
2098 p_type_switch
->name
= name
;
2099 p_type_switch
->location
= location
;
2100 p_type_switch
->expr
= expr
;
2104 if (!this->peek_token()->is_op(OPERATOR_COMMA
))
2106 init
= new Expression_list();
2107 init
->push_back(expr
);
2111 this->advance_token();
2112 init
= this->expression_list(expr
, false, may_be_composite_lit
);
2116 this->init_vars(&til
, NULL
, init
, true, location
);
2119 // FunctionDecl = "func" identifier Signature [ Block ] .
2120 // MethodDecl = "func" Receiver identifier Signature [ Block ] .
2122 // Deprecated gcc extension:
2123 // FunctionDecl = "func" identifier Signature
2124 // __asm__ "(" string_lit ")" .
2125 // This extension means a function whose real name is the identifier
2126 // inside the asm. This extension will be removed at some future
2127 // date. It has been replaced with //extern comments.
2130 Parse::function_decl()
2132 go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC
));
2133 Location location
= this->location();
2134 std::string extern_name
= this->lex_
->extern_name();
2135 const Token
* token
= this->advance_token();
2137 Typed_identifier
* rec
= NULL
;
2138 if (token
->is_op(OPERATOR_LPAREN
))
2140 rec
= this->receiver();
2141 token
= this->peek_token();
2144 if (!token
->is_identifier())
2146 error_at(this->location(), "expected function name");
2151 this->gogo_
->pack_hidden_name(token
->identifier(),
2152 token
->is_identifier_exported());
2154 this->advance_token();
2156 Function_type
* fntype
= this->signature(rec
, this->location());
2158 Named_object
* named_object
= NULL
;
2160 if (this->peek_token()->is_keyword(KEYWORD_ASM
))
2162 if (!this->advance_token()->is_op(OPERATOR_LPAREN
))
2164 error_at(this->location(), "expected %<(%>");
2167 token
= this->advance_token();
2168 if (!token
->is_string())
2170 error_at(this->location(), "expected string");
2173 std::string asm_name
= token
->string_value();
2174 if (!this->advance_token()->is_op(OPERATOR_RPAREN
))
2176 error_at(this->location(), "expected %<)%>");
2179 this->advance_token();
2180 if (!Gogo::is_sink_name(name
))
2182 named_object
= this->gogo_
->declare_function(name
, fntype
, location
);
2183 if (named_object
->is_function_declaration())
2184 named_object
->func_declaration_value()->set_asm_name(asm_name
);
2188 // Check for the easy error of a newline before the opening brace.
2189 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
))
2191 Location semi_loc
= this->location();
2192 if (this->advance_token()->is_op(OPERATOR_LCURLY
))
2193 error_at(this->location(),
2194 "unexpected semicolon or newline before %<{%>");
2196 this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON
,
2200 if (!this->peek_token()->is_op(OPERATOR_LCURLY
))
2202 if (named_object
== NULL
&& !Gogo::is_sink_name(name
))
2205 this->gogo_
->add_erroneous_name(name
);
2208 named_object
= this->gogo_
->declare_function(name
, fntype
,
2210 if (!extern_name
.empty()
2211 && named_object
->is_function_declaration())
2213 Function_declaration
* fd
=
2214 named_object
->func_declaration_value();
2215 fd
->set_asm_name(extern_name
);
2222 bool hold_is_erroneous_function
= this->is_erroneous_function_
;
2225 fntype
= Type::make_function_type(NULL
, NULL
, NULL
, location
);
2226 this->is_erroneous_function_
= true;
2227 if (!Gogo::is_sink_name(name
))
2228 this->gogo_
->add_erroneous_name(name
);
2229 name
= this->gogo_
->pack_hidden_name("_", false);
2231 this->gogo_
->start_function(name
, fntype
, true, location
);
2232 Location end_loc
= this->block();
2233 this->gogo_
->finish_function(end_loc
);
2234 this->is_erroneous_function_
= hold_is_erroneous_function
;
2238 // Receiver = "(" [ identifier ] [ "*" ] BaseTypeName ")" .
2239 // BaseTypeName = identifier .
2244 go_assert(this->peek_token()->is_op(OPERATOR_LPAREN
));
2247 const Token
* token
= this->advance_token();
2248 Location location
= token
->location();
2249 if (!token
->is_op(OPERATOR_MULT
))
2251 if (!token
->is_identifier())
2253 error_at(this->location(), "method has no receiver");
2254 this->gogo_
->mark_locals_used();
2255 while (!token
->is_eof() && !token
->is_op(OPERATOR_RPAREN
))
2256 token
= this->advance_token();
2257 if (!token
->is_eof())
2258 this->advance_token();
2261 name
= token
->identifier();
2262 bool is_exported
= token
->is_identifier_exported();
2263 token
= this->advance_token();
2264 if (!token
->is_op(OPERATOR_DOT
) && !token
->is_op(OPERATOR_RPAREN
))
2266 // An identifier followed by something other than a dot or a
2267 // right parenthesis must be a receiver name followed by a
2269 name
= this->gogo_
->pack_hidden_name(name
, is_exported
);
2273 // This must be a type name.
2274 this->unget_token(Token::make_identifier_token(name
, is_exported
,
2276 token
= this->peek_token();
2281 // Here the receiver name is in NAME (it is empty if the receiver is
2282 // unnamed) and TOKEN is the first token in the type.
2284 bool is_pointer
= false;
2285 if (token
->is_op(OPERATOR_MULT
))
2288 token
= this->advance_token();
2291 if (!token
->is_identifier())
2293 error_at(this->location(), "expected receiver name or type");
2294 this->gogo_
->mark_locals_used();
2295 int c
= token
->is_op(OPERATOR_LPAREN
) ? 1 : 0;
2296 while (!token
->is_eof())
2298 token
= this->advance_token();
2299 if (token
->is_op(OPERATOR_LPAREN
))
2301 else if (token
->is_op(OPERATOR_RPAREN
))
2308 if (!token
->is_eof())
2309 this->advance_token();
2313 Type
* type
= this->type_name(true);
2315 if (is_pointer
&& !type
->is_error_type())
2316 type
= Type::make_pointer_type(type
);
2318 if (this->peek_token()->is_op(OPERATOR_RPAREN
))
2319 this->advance_token();
2322 if (this->peek_token()->is_op(OPERATOR_COMMA
))
2323 error_at(this->location(), "method has multiple receivers");
2325 error_at(this->location(), "expected %<)%>");
2326 this->gogo_
->mark_locals_used();
2327 while (!token
->is_eof() && !token
->is_op(OPERATOR_RPAREN
))
2328 token
= this->advance_token();
2329 if (!token
->is_eof())
2330 this->advance_token();
2334 return new Typed_identifier(name
, type
, location
);
2337 // Operand = Literal | QualifiedIdent | MethodExpr | "(" Expression ")" .
2338 // Literal = BasicLit | CompositeLit | FunctionLit .
2339 // BasicLit = int_lit | float_lit | imaginary_lit | char_lit | string_lit .
2341 // If MAY_BE_SINK is true, this operand may be "_".
2344 Parse::operand(bool may_be_sink
)
2346 const Token
* token
= this->peek_token();
2348 switch (token
->classification())
2350 case Token::TOKEN_IDENTIFIER
:
2352 Location location
= token
->location();
2353 std::string id
= token
->identifier();
2354 bool is_exported
= token
->is_identifier_exported();
2355 std::string packed
= this->gogo_
->pack_hidden_name(id
, is_exported
);
2357 Named_object
* in_function
;
2358 Named_object
* named_object
= this->gogo_
->lookup(packed
, &in_function
);
2360 Package
* package
= NULL
;
2361 if (named_object
!= NULL
&& named_object
->is_package())
2363 if (!this->advance_token()->is_op(OPERATOR_DOT
)
2364 || !this->advance_token()->is_identifier())
2366 error_at(location
, "unexpected reference to package");
2367 return Expression::make_error(location
);
2369 package
= named_object
->package_value();
2370 package
->set_used();
2371 id
= this->peek_token()->identifier();
2372 is_exported
= this->peek_token()->is_identifier_exported();
2373 packed
= this->gogo_
->pack_hidden_name(id
, is_exported
);
2374 named_object
= package
->lookup(packed
);
2375 location
= this->location();
2376 go_assert(in_function
== NULL
);
2379 this->advance_token();
2381 if (named_object
!= NULL
2382 && named_object
->is_type()
2383 && !named_object
->type_value()->is_visible())
2385 go_assert(package
!= NULL
);
2386 error_at(location
, "invalid reference to hidden type %<%s.%s%>",
2387 Gogo::message_name(package
->package_name()).c_str(),
2388 Gogo::message_name(id
).c_str());
2389 return Expression::make_error(location
);
2393 if (named_object
== NULL
)
2395 if (package
!= NULL
)
2397 std::string n1
= Gogo::message_name(package
->package_name());
2398 std::string n2
= Gogo::message_name(id
);
2401 ("invalid reference to unexported identifier "
2403 n1
.c_str(), n2
.c_str());
2406 "reference to undefined identifier %<%s.%s%>",
2407 n1
.c_str(), n2
.c_str());
2408 return Expression::make_error(location
);
2411 named_object
= this->gogo_
->add_unknown_name(packed
, location
);
2414 if (in_function
!= NULL
2415 && in_function
!= this->gogo_
->current_function()
2416 && (named_object
->is_variable()
2417 || named_object
->is_result_variable()))
2418 return this->enclosing_var_reference(in_function
, named_object
,
2421 switch (named_object
->classification())
2423 case Named_object::NAMED_OBJECT_CONST
:
2424 return Expression::make_const_reference(named_object
, location
);
2425 case Named_object::NAMED_OBJECT_TYPE
:
2426 return Expression::make_type(named_object
->type_value(), location
);
2427 case Named_object::NAMED_OBJECT_TYPE_DECLARATION
:
2429 Type
* t
= Type::make_forward_declaration(named_object
);
2430 return Expression::make_type(t
, location
);
2432 case Named_object::NAMED_OBJECT_VAR
:
2433 case Named_object::NAMED_OBJECT_RESULT_VAR
:
2434 this->mark_var_used(named_object
);
2435 return Expression::make_var_reference(named_object
, location
);
2436 case Named_object::NAMED_OBJECT_SINK
:
2438 return Expression::make_sink(location
);
2441 error_at(location
, "cannot use _ as value");
2442 return Expression::make_error(location
);
2444 case Named_object::NAMED_OBJECT_FUNC
:
2445 case Named_object::NAMED_OBJECT_FUNC_DECLARATION
:
2446 return Expression::make_func_reference(named_object
, NULL
,
2448 case Named_object::NAMED_OBJECT_UNKNOWN
:
2450 Unknown_expression
* ue
=
2451 Expression::make_unknown_reference(named_object
, location
);
2452 if (this->is_erroneous_function_
)
2453 ue
->set_no_error_message();
2456 case Named_object::NAMED_OBJECT_ERRONEOUS
:
2457 return Expression::make_error(location
);
2464 case Token::TOKEN_STRING
:
2465 ret
= Expression::make_string(token
->string_value(), token
->location());
2466 this->advance_token();
2469 case Token::TOKEN_CHARACTER
:
2470 ret
= Expression::make_character(token
->character_value(), NULL
,
2472 this->advance_token();
2475 case Token::TOKEN_INTEGER
:
2476 ret
= Expression::make_integer(token
->integer_value(), NULL
,
2478 this->advance_token();
2481 case Token::TOKEN_FLOAT
:
2482 ret
= Expression::make_float(token
->float_value(), NULL
,
2484 this->advance_token();
2487 case Token::TOKEN_IMAGINARY
:
2490 mpfr_init_set_ui(zero
, 0, GMP_RNDN
);
2491 ret
= Expression::make_complex(&zero
, token
->imaginary_value(),
2492 NULL
, token
->location());
2494 this->advance_token();
2498 case Token::TOKEN_KEYWORD
:
2499 switch (token
->keyword())
2502 return this->function_lit();
2504 case KEYWORD_INTERFACE
:
2506 case KEYWORD_STRUCT
:
2508 Location location
= token
->location();
2509 return Expression::make_type(this->type(), location
);
2516 case Token::TOKEN_OPERATOR
:
2517 if (token
->is_op(OPERATOR_LPAREN
))
2519 this->advance_token();
2520 ret
= this->expression(PRECEDENCE_NORMAL
, may_be_sink
, true, NULL
);
2521 if (!this->peek_token()->is_op(OPERATOR_RPAREN
))
2522 error_at(this->location(), "missing %<)%>");
2524 this->advance_token();
2527 else if (token
->is_op(OPERATOR_LSQUARE
))
2529 // Here we call array_type directly, as this is the only
2530 // case where an ellipsis is permitted for an array type.
2531 Location location
= token
->location();
2532 return Expression::make_type(this->array_type(true), location
);
2540 error_at(this->location(), "expected operand");
2541 return Expression::make_error(this->location());
2544 // Handle a reference to a variable in an enclosing function. We add
2545 // it to a list of such variables. We return a reference to a field
2546 // in a struct which will be passed on the static chain when calling
2547 // the current function.
2550 Parse::enclosing_var_reference(Named_object
* in_function
, Named_object
* var
,
2553 go_assert(var
->is_variable() || var
->is_result_variable());
2555 this->mark_var_used(var
);
2557 Named_object
* this_function
= this->gogo_
->current_function();
2558 Named_object
* closure
= this_function
->func_value()->closure_var();
2560 Enclosing_var
ev(var
, in_function
, this->enclosing_vars_
.size());
2561 std::pair
<Enclosing_vars::iterator
, bool> ins
=
2562 this->enclosing_vars_
.insert(ev
);
2565 // This is a variable we have not seen before. Add a new field
2566 // to the closure type.
2567 this_function
->func_value()->add_closure_field(var
, location
);
2570 Expression
* closure_ref
= Expression::make_var_reference(closure
,
2572 closure_ref
= Expression::make_unary(OPERATOR_MULT
, closure_ref
, location
);
2574 // The closure structure holds pointers to the variables, so we need
2575 // to introduce an indirection.
2576 Expression
* e
= Expression::make_field_reference(closure_ref
,
2579 e
= Expression::make_unary(OPERATOR_MULT
, e
, location
);
2583 // CompositeLit = LiteralType LiteralValue .
2584 // LiteralType = StructType | ArrayType | "[" "..." "]" ElementType |
2585 // SliceType | MapType | TypeName .
2586 // LiteralValue = "{" [ ElementList [ "," ] ] "}" .
2587 // ElementList = Element { "," Element } .
2588 // Element = [ Key ":" ] Value .
2589 // Key = FieldName | ElementIndex .
2590 // FieldName = identifier .
2591 // ElementIndex = Expression .
2592 // Value = Expression | LiteralValue .
2594 // We have already seen the type if there is one, and we are now
2595 // looking at the LiteralValue. The case "[" "..." "]" ElementType
2596 // will be seen here as an array type whose length is "nil". The
2597 // DEPTH parameter is non-zero if this is an embedded composite
2598 // literal and the type was omitted. It gives the number of steps up
2599 // to the type which was provided. E.g., in [][]int{{1}} it will be
2600 // 1. In [][][]int{{{1}}} it will be 2.
2603 Parse::composite_lit(Type
* type
, int depth
, Location location
)
2605 go_assert(this->peek_token()->is_op(OPERATOR_LCURLY
));
2606 this->advance_token();
2608 if (this->peek_token()->is_op(OPERATOR_RCURLY
))
2610 this->advance_token();
2611 return Expression::make_composite_literal(type
, depth
, false, NULL
,
2615 bool has_keys
= false;
2616 Expression_list
* vals
= new Expression_list
;
2620 bool is_type_omitted
= false;
2622 const Token
* token
= this->peek_token();
2624 if (token
->is_identifier())
2626 std::string identifier
= token
->identifier();
2627 bool is_exported
= token
->is_identifier_exported();
2628 Location location
= token
->location();
2630 if (this->advance_token()->is_op(OPERATOR_COLON
))
2632 // This may be a field name. We don't know for sure--it
2633 // could also be an expression for an array index. We
2634 // don't want to parse it as an expression because may
2635 // trigger various errors, e.g., if this identifier
2636 // happens to be the name of a package.
2637 Gogo
* gogo
= this->gogo_
;
2638 val
= this->id_to_expression(gogo
->pack_hidden_name(identifier
,
2644 this->unget_token(Token::make_identifier_token(identifier
,
2647 val
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
2650 else if (!token
->is_op(OPERATOR_LCURLY
))
2651 val
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
2654 // This must be a composite literal inside another composite
2655 // literal, with the type omitted for the inner one.
2656 val
= this->composite_lit(type
, depth
+ 1, token
->location());
2657 is_type_omitted
= true;
2660 token
= this->peek_token();
2661 if (!token
->is_op(OPERATOR_COLON
))
2664 vals
->push_back(NULL
);
2668 if (is_type_omitted
&& !val
->is_error_expression())
2670 error_at(this->location(), "unexpected %<:%>");
2671 val
= Expression::make_error(this->location());
2674 this->advance_token();
2676 if (!has_keys
&& !vals
->empty())
2678 Expression_list
* newvals
= new Expression_list
;
2679 for (Expression_list::const_iterator p
= vals
->begin();
2683 newvals
->push_back(NULL
);
2684 newvals
->push_back(*p
);
2691 if (val
->unknown_expression() != NULL
)
2692 val
->unknown_expression()->set_is_composite_literal_key();
2694 vals
->push_back(val
);
2696 if (!token
->is_op(OPERATOR_LCURLY
))
2697 val
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
2700 // This must be a composite literal inside another
2701 // composite literal, with the type omitted for the
2703 val
= this->composite_lit(type
, depth
+ 1, token
->location());
2706 token
= this->peek_token();
2709 vals
->push_back(val
);
2711 if (token
->is_op(OPERATOR_COMMA
))
2713 if (this->advance_token()->is_op(OPERATOR_RCURLY
))
2715 this->advance_token();
2719 else if (token
->is_op(OPERATOR_RCURLY
))
2721 this->advance_token();
2726 if (token
->is_op(OPERATOR_SEMICOLON
))
2727 error_at(this->location(),
2728 "need trailing comma before newline in composite literal");
2730 error_at(this->location(), "expected %<,%> or %<}%>");
2732 this->gogo_
->mark_locals_used();
2734 while (!token
->is_eof()
2735 && (depth
> 0 || !token
->is_op(OPERATOR_RCURLY
)))
2737 if (token
->is_op(OPERATOR_LCURLY
))
2739 else if (token
->is_op(OPERATOR_RCURLY
))
2741 token
= this->advance_token();
2743 if (token
->is_op(OPERATOR_RCURLY
))
2744 this->advance_token();
2746 return Expression::make_error(location
);
2750 return Expression::make_composite_literal(type
, depth
, has_keys
, vals
,
2754 // FunctionLit = "func" Signature Block .
2757 Parse::function_lit()
2759 Location location
= this->location();
2760 go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC
));
2761 this->advance_token();
2763 Enclosing_vars hold_enclosing_vars
;
2764 hold_enclosing_vars
.swap(this->enclosing_vars_
);
2766 Function_type
* type
= this->signature(NULL
, location
);
2767 bool fntype_is_error
= false;
2770 type
= Type::make_function_type(NULL
, NULL
, NULL
, location
);
2771 fntype_is_error
= true;
2774 // For a function literal, the next token must be a '{'. If we
2775 // don't see that, then we may have a type expression.
2776 if (!this->peek_token()->is_op(OPERATOR_LCURLY
))
2777 return Expression::make_type(type
, location
);
2779 bool hold_is_erroneous_function
= this->is_erroneous_function_
;
2780 if (fntype_is_error
)
2781 this->is_erroneous_function_
= true;
2783 Bc_stack
* hold_break_stack
= this->break_stack_
;
2784 Bc_stack
* hold_continue_stack
= this->continue_stack_
;
2785 this->break_stack_
= NULL
;
2786 this->continue_stack_
= NULL
;
2788 Named_object
* no
= this->gogo_
->start_function("", type
, true, location
);
2790 Location end_loc
= this->block();
2792 this->gogo_
->finish_function(end_loc
);
2794 if (this->break_stack_
!= NULL
)
2795 delete this->break_stack_
;
2796 if (this->continue_stack_
!= NULL
)
2797 delete this->continue_stack_
;
2798 this->break_stack_
= hold_break_stack
;
2799 this->continue_stack_
= hold_continue_stack
;
2801 this->is_erroneous_function_
= hold_is_erroneous_function
;
2803 hold_enclosing_vars
.swap(this->enclosing_vars_
);
2805 Expression
* closure
= this->create_closure(no
, &hold_enclosing_vars
,
2808 return Expression::make_func_reference(no
, closure
, location
);
2811 // Create a closure for the nested function FUNCTION. This is based
2812 // on ENCLOSING_VARS, which is a list of all variables defined in
2813 // enclosing functions and referenced from FUNCTION. A closure is the
2814 // address of a struct which contains the addresses of all the
2815 // referenced variables. This returns NULL if no closure is required.
2818 Parse::create_closure(Named_object
* function
, Enclosing_vars
* enclosing_vars
,
2821 if (enclosing_vars
->empty())
2824 // Get the variables in order by their field index.
2826 size_t enclosing_var_count
= enclosing_vars
->size();
2827 std::vector
<Enclosing_var
> ev(enclosing_var_count
);
2828 for (Enclosing_vars::const_iterator p
= enclosing_vars
->begin();
2829 p
!= enclosing_vars
->end();
2831 ev
[p
->index()] = *p
;
2833 // Build an initializer for a composite literal of the closure's
2836 Named_object
* enclosing_function
= this->gogo_
->current_function();
2837 Expression_list
* initializer
= new Expression_list
;
2838 for (size_t i
= 0; i
< enclosing_var_count
; ++i
)
2840 go_assert(ev
[i
].index() == i
);
2841 Named_object
* var
= ev
[i
].var();
2843 if (ev
[i
].in_function() == enclosing_function
)
2844 ref
= Expression::make_var_reference(var
, location
);
2846 ref
= this->enclosing_var_reference(ev
[i
].in_function(), var
,
2848 Expression
* refaddr
= Expression::make_unary(OPERATOR_AND
, ref
,
2850 initializer
->push_back(refaddr
);
2853 Named_object
* closure_var
= function
->func_value()->closure_var();
2854 Struct_type
* st
= closure_var
->var_value()->type()->deref()->struct_type();
2855 Expression
* cv
= Expression::make_struct_composite_literal(st
, initializer
,
2857 return Expression::make_heap_composite(cv
, location
);
2860 // PrimaryExpr = Operand { Selector | Index | Slice | TypeGuard | Call } .
2862 // If MAY_BE_SINK is true, this expression may be "_".
2864 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
2867 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2868 // guard (var := expr.("type") using the literal keyword "type").
2871 Parse::primary_expr(bool may_be_sink
, bool may_be_composite_lit
,
2872 bool* is_type_switch
)
2874 Location start_loc
= this->location();
2875 bool is_parenthesized
= this->peek_token()->is_op(OPERATOR_LPAREN
);
2877 Expression
* ret
= this->operand(may_be_sink
);
2879 // An unknown name followed by a curly brace must be a composite
2880 // literal, and the unknown name must be a type.
2881 if (may_be_composite_lit
2882 && !is_parenthesized
2883 && ret
->unknown_expression() != NULL
2884 && this->peek_token()->is_op(OPERATOR_LCURLY
))
2886 Named_object
* no
= ret
->unknown_expression()->named_object();
2887 Type
* type
= Type::make_forward_declaration(no
);
2888 ret
= Expression::make_type(type
, ret
->location());
2891 // We handle composite literals and type casts here, as it is the
2892 // easiest way to handle types which are in parentheses, as in
2894 if (ret
->is_type_expression())
2896 if (this->peek_token()->is_op(OPERATOR_LCURLY
))
2898 if (!may_be_composite_lit
)
2900 Type
* t
= ret
->type();
2901 if (t
->named_type() != NULL
2902 || t
->forward_declaration_type() != NULL
)
2904 _("parentheses required around this composite literal"
2905 "to avoid parsing ambiguity"));
2907 else if (is_parenthesized
)
2909 "cannot parenthesize type in composite literal");
2910 ret
= this->composite_lit(ret
->type(), 0, ret
->location());
2912 else if (this->peek_token()->is_op(OPERATOR_LPAREN
))
2914 Location loc
= this->location();
2915 this->advance_token();
2916 Expression
* expr
= this->expression(PRECEDENCE_NORMAL
, false, true,
2918 if (this->peek_token()->is_op(OPERATOR_ELLIPSIS
))
2920 error_at(this->location(),
2921 "invalid use of %<...%> in type conversion");
2922 this->advance_token();
2924 if (!this->peek_token()->is_op(OPERATOR_RPAREN
))
2925 error_at(this->location(), "expected %<)%>");
2927 this->advance_token();
2928 if (expr
->is_error_expression())
2932 Type
* t
= ret
->type();
2933 if (t
->classification() == Type::TYPE_ARRAY
2934 && t
->array_type()->length() != NULL
2935 && t
->array_type()->length()->is_nil_expression())
2937 error_at(ret
->location(),
2938 "invalid use of %<...%> in type conversion");
2939 ret
= Expression::make_error(loc
);
2942 ret
= Expression::make_cast(t
, expr
, loc
);
2949 const Token
* token
= this->peek_token();
2950 if (token
->is_op(OPERATOR_LPAREN
))
2951 ret
= this->call(this->verify_not_sink(ret
));
2952 else if (token
->is_op(OPERATOR_DOT
))
2954 ret
= this->selector(this->verify_not_sink(ret
), is_type_switch
);
2955 if (is_type_switch
!= NULL
&& *is_type_switch
)
2958 else if (token
->is_op(OPERATOR_LSQUARE
))
2959 ret
= this->index(this->verify_not_sink(ret
));
2967 // Selector = "." identifier .
2968 // TypeGuard = "." "(" QualifiedIdent ")" .
2970 // Note that Operand can expand to QualifiedIdent, which contains a
2971 // ".". That is handled directly in operand when it sees a package
2974 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
2975 // guard (var := expr.("type") using the literal keyword "type").
2978 Parse::selector(Expression
* left
, bool* is_type_switch
)
2980 go_assert(this->peek_token()->is_op(OPERATOR_DOT
));
2981 Location location
= this->location();
2983 const Token
* token
= this->advance_token();
2984 if (token
->is_identifier())
2986 // This could be a field in a struct, or a method in an
2987 // interface, or a method associated with a type. We can't know
2988 // which until we have seen all the types.
2990 this->gogo_
->pack_hidden_name(token
->identifier(),
2991 token
->is_identifier_exported());
2992 if (token
->identifier() == "_")
2994 error_at(this->location(), "invalid use of %<_%>");
2995 name
= this->gogo_
->pack_hidden_name("blank", false);
2997 this->advance_token();
2998 return Expression::make_selector(left
, name
, location
);
3000 else if (token
->is_op(OPERATOR_LPAREN
))
3002 this->advance_token();
3004 if (!this->peek_token()->is_keyword(KEYWORD_TYPE
))
3005 type
= this->type();
3008 if (is_type_switch
!= NULL
)
3009 *is_type_switch
= true;
3012 error_at(this->location(),
3013 "use of %<.(type)%> outside type switch");
3014 type
= Type::make_error_type();
3016 this->advance_token();
3018 if (!this->peek_token()->is_op(OPERATOR_RPAREN
))
3019 error_at(this->location(), "missing %<)%>");
3021 this->advance_token();
3022 if (is_type_switch
!= NULL
&& *is_type_switch
)
3024 return Expression::make_type_guard(left
, type
, location
);
3028 error_at(this->location(), "expected identifier or %<(%>");
3033 // Index = "[" Expression "]" .
3034 // Slice = "[" Expression ":" [ Expression ] "]" .
3037 Parse::index(Expression
* expr
)
3039 Location location
= this->location();
3040 go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE
));
3041 this->advance_token();
3044 if (!this->peek_token()->is_op(OPERATOR_COLON
))
3045 start
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
3049 mpz_init_set_ui(zero
, 0);
3050 start
= Expression::make_integer(&zero
, NULL
, location
);
3054 Expression
* end
= NULL
;
3055 if (this->peek_token()->is_op(OPERATOR_COLON
))
3057 // We use nil to indicate a missing high expression.
3058 if (this->advance_token()->is_op(OPERATOR_RSQUARE
))
3059 end
= Expression::make_nil(this->location());
3061 end
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
3063 if (!this->peek_token()->is_op(OPERATOR_RSQUARE
))
3064 error_at(this->location(), "missing %<]%>");
3066 this->advance_token();
3067 return Expression::make_index(expr
, start
, end
, location
);
3070 // Call = "(" [ ArgumentList [ "," ] ] ")" .
3071 // ArgumentList = ExpressionList [ "..." ] .
3074 Parse::call(Expression
* func
)
3076 go_assert(this->peek_token()->is_op(OPERATOR_LPAREN
));
3077 Expression_list
* args
= NULL
;
3078 bool is_varargs
= false;
3079 const Token
* token
= this->advance_token();
3080 if (!token
->is_op(OPERATOR_RPAREN
))
3082 args
= this->expression_list(NULL
, false, true);
3083 token
= this->peek_token();
3084 if (token
->is_op(OPERATOR_ELLIPSIS
))
3087 token
= this->advance_token();
3090 if (token
->is_op(OPERATOR_COMMA
))
3091 token
= this->advance_token();
3092 if (!token
->is_op(OPERATOR_RPAREN
))
3093 error_at(this->location(), "missing %<)%>");
3095 this->advance_token();
3096 if (func
->is_error_expression())
3098 return Expression::make_call(func
, args
, is_varargs
, func
->location());
3101 // Return an expression for a single unqualified identifier.
3104 Parse::id_to_expression(const std::string
& name
, Location location
)
3106 Named_object
* in_function
;
3107 Named_object
* named_object
= this->gogo_
->lookup(name
, &in_function
);
3108 if (named_object
== NULL
)
3109 named_object
= this->gogo_
->add_unknown_name(name
, location
);
3111 if (in_function
!= NULL
3112 && in_function
!= this->gogo_
->current_function()
3113 && (named_object
->is_variable() || named_object
->is_result_variable()))
3114 return this->enclosing_var_reference(in_function
, named_object
,
3117 switch (named_object
->classification())
3119 case Named_object::NAMED_OBJECT_CONST
:
3120 return Expression::make_const_reference(named_object
, location
);
3121 case Named_object::NAMED_OBJECT_VAR
:
3122 case Named_object::NAMED_OBJECT_RESULT_VAR
:
3123 this->mark_var_used(named_object
);
3124 return Expression::make_var_reference(named_object
, location
);
3125 case Named_object::NAMED_OBJECT_SINK
:
3126 return Expression::make_sink(location
);
3127 case Named_object::NAMED_OBJECT_FUNC
:
3128 case Named_object::NAMED_OBJECT_FUNC_DECLARATION
:
3129 return Expression::make_func_reference(named_object
, NULL
, location
);
3130 case Named_object::NAMED_OBJECT_UNKNOWN
:
3132 Unknown_expression
* ue
=
3133 Expression::make_unknown_reference(named_object
, location
);
3134 if (this->is_erroneous_function_
)
3135 ue
->set_no_error_message();
3138 case Named_object::NAMED_OBJECT_PACKAGE
:
3139 case Named_object::NAMED_OBJECT_TYPE
:
3140 case Named_object::NAMED_OBJECT_TYPE_DECLARATION
:
3142 // These cases can arise for a field name in a composite
3144 Unknown_expression
* ue
=
3145 Expression::make_unknown_reference(named_object
, location
);
3146 if (this->is_erroneous_function_
)
3147 ue
->set_no_error_message();
3150 case Named_object::NAMED_OBJECT_ERRONEOUS
:
3151 return Expression::make_error(location
);
3153 error_at(this->location(), "unexpected type of identifier");
3154 return Expression::make_error(location
);
3158 // Expression = UnaryExpr { binary_op Expression } .
3160 // PRECEDENCE is the precedence of the current operator.
3162 // If MAY_BE_SINK is true, this expression may be "_".
3164 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
3167 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3168 // guard (var := expr.("type") using the literal keyword "type").
3171 Parse::expression(Precedence precedence
, bool may_be_sink
,
3172 bool may_be_composite_lit
, bool* is_type_switch
)
3174 Expression
* left
= this->unary_expr(may_be_sink
, may_be_composite_lit
,
3179 if (is_type_switch
!= NULL
&& *is_type_switch
)
3182 const Token
* token
= this->peek_token();
3183 if (token
->classification() != Token::TOKEN_OPERATOR
)
3189 Precedence right_precedence
;
3190 switch (token
->op())
3193 right_precedence
= PRECEDENCE_OROR
;
3195 case OPERATOR_ANDAND
:
3196 right_precedence
= PRECEDENCE_ANDAND
;
3199 case OPERATOR_NOTEQ
:
3204 right_precedence
= PRECEDENCE_RELOP
;
3207 case OPERATOR_MINUS
:
3210 right_precedence
= PRECEDENCE_ADDOP
;
3215 case OPERATOR_LSHIFT
:
3216 case OPERATOR_RSHIFT
:
3218 case OPERATOR_BITCLEAR
:
3219 right_precedence
= PRECEDENCE_MULOP
;
3222 right_precedence
= PRECEDENCE_INVALID
;
3226 if (right_precedence
== PRECEDENCE_INVALID
)
3232 Operator op
= token
->op();
3233 Location binop_location
= token
->location();
3235 if (precedence
>= right_precedence
)
3237 // We've already seen A * B, and we see + C. We want to
3238 // return so that A * B becomes a group.
3242 this->advance_token();
3244 left
= this->verify_not_sink(left
);
3245 Expression
* right
= this->expression(right_precedence
, false,
3246 may_be_composite_lit
,
3248 left
= Expression::make_binary(op
, left
, right
, binop_location
);
3253 Parse::expression_may_start_here()
3255 const Token
* token
= this->peek_token();
3256 switch (token
->classification())
3258 case Token::TOKEN_INVALID
:
3259 case Token::TOKEN_EOF
:
3261 case Token::TOKEN_KEYWORD
:
3262 switch (token
->keyword())
3267 case KEYWORD_STRUCT
:
3268 case KEYWORD_INTERFACE
:
3273 case Token::TOKEN_IDENTIFIER
:
3275 case Token::TOKEN_STRING
:
3277 case Token::TOKEN_OPERATOR
:
3278 switch (token
->op())
3281 case OPERATOR_MINUS
:
3285 case OPERATOR_CHANOP
:
3287 case OPERATOR_LPAREN
:
3288 case OPERATOR_LSQUARE
:
3293 case Token::TOKEN_CHARACTER
:
3294 case Token::TOKEN_INTEGER
:
3295 case Token::TOKEN_FLOAT
:
3296 case Token::TOKEN_IMAGINARY
:
3303 // UnaryExpr = unary_op UnaryExpr | PrimaryExpr .
3305 // If MAY_BE_SINK is true, this expression may be "_".
3307 // If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
3310 // If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
3311 // guard (var := expr.("type") using the literal keyword "type").
3314 Parse::unary_expr(bool may_be_sink
, bool may_be_composite_lit
,
3315 bool* is_type_switch
)
3317 const Token
* token
= this->peek_token();
3319 // There is a complex parse for <- chan. The choices are
3320 // Convert x to type <- chan int:
3322 // Receive from (x converted to type chan <- chan int):
3323 // (<- chan <- chan int (x))
3324 // Convert x to type <- chan (<- chan int).
3325 // (<- chan <- chan int)(x)
3326 if (token
->is_op(OPERATOR_CHANOP
))
3328 Location location
= token
->location();
3329 if (this->advance_token()->is_keyword(KEYWORD_CHAN
))
3331 Expression
* expr
= this->primary_expr(false, may_be_composite_lit
,
3333 if (expr
->is_error_expression())
3335 else if (!expr
->is_type_expression())
3336 return Expression::make_receive(expr
, location
);
3339 if (expr
->type()->is_error_type())
3342 // We picked up "chan TYPE", but it is not a type
3344 Channel_type
* ct
= expr
->type()->channel_type();
3347 // This is probably impossible.
3348 error_at(location
, "expected channel type");
3349 return Expression::make_error(location
);
3351 else if (ct
->may_receive())
3354 Type
* t
= Type::make_channel_type(false, true,
3355 ct
->element_type());
3356 return Expression::make_type(t
, location
);
3360 // <- chan <- TYPE. Because we skipped the leading
3361 // <-, we parsed this as chan <- TYPE. With the
3362 // leading <-, we parse it as <- chan (<- TYPE).
3363 Type
*t
= this->reassociate_chan_direction(ct
, location
);
3364 return Expression::make_type(t
, location
);
3369 this->unget_token(Token::make_operator_token(OPERATOR_CHANOP
, location
));
3370 token
= this->peek_token();
3373 if (token
->is_op(OPERATOR_PLUS
)
3374 || token
->is_op(OPERATOR_MINUS
)
3375 || token
->is_op(OPERATOR_NOT
)
3376 || token
->is_op(OPERATOR_XOR
)
3377 || token
->is_op(OPERATOR_CHANOP
)
3378 || token
->is_op(OPERATOR_MULT
)
3379 || token
->is_op(OPERATOR_AND
))
3381 Location location
= token
->location();
3382 Operator op
= token
->op();
3383 this->advance_token();
3385 Expression
* expr
= this->unary_expr(false, may_be_composite_lit
, NULL
);
3386 if (expr
->is_error_expression())
3388 else if (op
== OPERATOR_MULT
&& expr
->is_type_expression())
3389 expr
= Expression::make_type(Type::make_pointer_type(expr
->type()),
3391 else if (op
== OPERATOR_AND
&& expr
->is_composite_literal())
3392 expr
= Expression::make_heap_composite(expr
, location
);
3393 else if (op
!= OPERATOR_CHANOP
)
3394 expr
= Expression::make_unary(op
, expr
, location
);
3396 expr
= Expression::make_receive(expr
, location
);
3400 return this->primary_expr(may_be_sink
, may_be_composite_lit
,
3404 // This is called for the obscure case of
3405 // (<- chan <- chan int)(x)
3406 // In unary_expr we remove the leading <- and parse the remainder,
3408 // chan <- (chan int)
3409 // When we add the leading <- back in, we really want
3410 // <- chan (<- chan int)
3411 // This means that we need to reassociate.
3414 Parse::reassociate_chan_direction(Channel_type
*ct
, Location location
)
3416 Channel_type
* ele
= ct
->element_type()->channel_type();
3419 error_at(location
, "parse error");
3420 return Type::make_error_type();
3423 if (ele
->may_send())
3424 sub
= Type::make_channel_type(false, true, ele
->element_type());
3426 sub
= this->reassociate_chan_direction(ele
, location
);
3427 return Type::make_channel_type(false, true, sub
);
3431 // Declaration | LabeledStmt | SimpleStmt |
3432 // GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
3433 // FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
3436 // LABEL is the label of this statement if it has one.
3439 Parse::statement(Label
* label
)
3441 const Token
* token
= this->peek_token();
3442 switch (token
->classification())
3444 case Token::TOKEN_KEYWORD
:
3446 switch (token
->keyword())
3451 this->declaration();
3455 case KEYWORD_STRUCT
:
3456 case KEYWORD_INTERFACE
:
3457 this->simple_stat(true, NULL
, NULL
, NULL
);
3461 this->go_or_defer_stat();
3463 case KEYWORD_RETURN
:
3464 this->return_stat();
3469 case KEYWORD_CONTINUE
:
3470 this->continue_stat();
3478 case KEYWORD_SWITCH
:
3479 this->switch_stat(label
);
3481 case KEYWORD_SELECT
:
3482 this->select_stat(label
);
3485 this->for_stat(label
);
3488 error_at(this->location(), "expected statement");
3489 this->advance_token();
3495 case Token::TOKEN_IDENTIFIER
:
3497 std::string identifier
= token
->identifier();
3498 bool is_exported
= token
->is_identifier_exported();
3499 Location location
= token
->location();
3500 if (this->advance_token()->is_op(OPERATOR_COLON
))
3502 this->advance_token();
3503 this->labeled_stmt(identifier
, location
);
3507 this->unget_token(Token::make_identifier_token(identifier
,
3510 this->simple_stat(true, NULL
, NULL
, NULL
);
3515 case Token::TOKEN_OPERATOR
:
3516 if (token
->is_op(OPERATOR_LCURLY
))
3518 Location location
= token
->location();
3519 this->gogo_
->start_block(location
);
3520 Location end_loc
= this->block();
3521 this->gogo_
->add_block(this->gogo_
->finish_block(end_loc
),
3524 else if (!token
->is_op(OPERATOR_SEMICOLON
))
3525 this->simple_stat(true, NULL
, NULL
, NULL
);
3528 case Token::TOKEN_STRING
:
3529 case Token::TOKEN_CHARACTER
:
3530 case Token::TOKEN_INTEGER
:
3531 case Token::TOKEN_FLOAT
:
3532 case Token::TOKEN_IMAGINARY
:
3533 this->simple_stat(true, NULL
, NULL
, NULL
);
3537 error_at(this->location(), "expected statement");
3538 this->advance_token();
3544 Parse::statement_may_start_here()
3546 const Token
* token
= this->peek_token();
3547 switch (token
->classification())
3549 case Token::TOKEN_KEYWORD
:
3551 switch (token
->keyword())
3558 case KEYWORD_STRUCT
:
3559 case KEYWORD_INTERFACE
:
3562 case KEYWORD_RETURN
:
3564 case KEYWORD_CONTINUE
:
3567 case KEYWORD_SWITCH
:
3568 case KEYWORD_SELECT
:
3578 case Token::TOKEN_IDENTIFIER
:
3581 case Token::TOKEN_OPERATOR
:
3582 if (token
->is_op(OPERATOR_LCURLY
)
3583 || token
->is_op(OPERATOR_SEMICOLON
))
3586 return this->expression_may_start_here();
3588 case Token::TOKEN_STRING
:
3589 case Token::TOKEN_CHARACTER
:
3590 case Token::TOKEN_INTEGER
:
3591 case Token::TOKEN_FLOAT
:
3592 case Token::TOKEN_IMAGINARY
:
3600 // LabeledStmt = Label ":" Statement .
3601 // Label = identifier .
3604 Parse::labeled_stmt(const std::string
& label_name
, Location location
)
3606 Label
* label
= this->gogo_
->add_label_definition(label_name
, location
);
3608 if (this->peek_token()->is_op(OPERATOR_RCURLY
))
3610 // This is a label at the end of a block. A program is
3611 // permitted to omit a semicolon here.
3615 if (!this->statement_may_start_here())
3617 // Mark the label as used to avoid a useless error about an
3619 label
->set_is_used();
3621 error_at(location
, "missing statement after label");
3622 this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON
,
3627 this->statement(label
);
3630 // SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt |
3631 // Assignment | ShortVarDecl .
3633 // EmptyStmt was handled in Parse::statement.
3635 // In order to make this work for if and switch statements, if
3636 // RETURN_EXP is not NULL, and we see an ExpressionStat, we return the
3637 // expression rather than adding an expression statement to the
3638 // current block. If we see something other than an ExpressionStat,
3639 // we add the statement, set *RETURN_EXP to true if we saw a send
3640 // statement, and return NULL. The handling of send statements is for
3641 // better error messages.
3643 // If P_RANGE_CLAUSE is not NULL, then this will recognize a
3646 // If P_TYPE_SWITCH is not NULL, this will recognize a type switch
3647 // guard (var := expr.("type") using the literal keyword "type").
3650 Parse::simple_stat(bool may_be_composite_lit
, bool* return_exp
,
3651 Range_clause
* p_range_clause
, Type_switch
* p_type_switch
)
3653 const Token
* token
= this->peek_token();
3655 // An identifier follow by := is a SimpleVarDecl.
3656 if (token
->is_identifier())
3658 std::string identifier
= token
->identifier();
3659 bool is_exported
= token
->is_identifier_exported();
3660 Location location
= token
->location();
3662 token
= this->advance_token();
3663 if (token
->is_op(OPERATOR_COLONEQ
)
3664 || token
->is_op(OPERATOR_COMMA
))
3666 identifier
= this->gogo_
->pack_hidden_name(identifier
, is_exported
);
3667 this->simple_var_decl_or_assignment(identifier
, location
,
3668 may_be_composite_lit
,
3670 (token
->is_op(OPERATOR_COLONEQ
)
3676 this->unget_token(Token::make_identifier_token(identifier
, is_exported
,
3680 Expression
* exp
= this->expression(PRECEDENCE_NORMAL
, true,
3681 may_be_composite_lit
,
3682 (p_type_switch
== NULL
3684 : &p_type_switch
->found
));
3685 if (p_type_switch
!= NULL
&& p_type_switch
->found
)
3687 p_type_switch
->name
.clear();
3688 p_type_switch
->location
= exp
->location();
3689 p_type_switch
->expr
= this->verify_not_sink(exp
);
3692 token
= this->peek_token();
3693 if (token
->is_op(OPERATOR_CHANOP
))
3695 this->send_stmt(this->verify_not_sink(exp
));
3696 if (return_exp
!= NULL
)
3699 else if (token
->is_op(OPERATOR_PLUSPLUS
)
3700 || token
->is_op(OPERATOR_MINUSMINUS
))
3701 this->inc_dec_stat(this->verify_not_sink(exp
));
3702 else if (token
->is_op(OPERATOR_COMMA
)
3703 || token
->is_op(OPERATOR_EQ
))
3704 this->assignment(exp
, may_be_composite_lit
, p_range_clause
);
3705 else if (token
->is_op(OPERATOR_PLUSEQ
)
3706 || token
->is_op(OPERATOR_MINUSEQ
)
3707 || token
->is_op(OPERATOR_OREQ
)
3708 || token
->is_op(OPERATOR_XOREQ
)
3709 || token
->is_op(OPERATOR_MULTEQ
)
3710 || token
->is_op(OPERATOR_DIVEQ
)
3711 || token
->is_op(OPERATOR_MODEQ
)
3712 || token
->is_op(OPERATOR_LSHIFTEQ
)
3713 || token
->is_op(OPERATOR_RSHIFTEQ
)
3714 || token
->is_op(OPERATOR_ANDEQ
)
3715 || token
->is_op(OPERATOR_BITCLEAREQ
))
3716 this->assignment(this->verify_not_sink(exp
), may_be_composite_lit
,
3718 else if (return_exp
!= NULL
)
3719 return this->verify_not_sink(exp
);
3722 exp
= this->verify_not_sink(exp
);
3724 if (token
->is_op(OPERATOR_COLONEQ
))
3726 if (!exp
->is_error_expression())
3727 error_at(token
->location(), "non-name on left side of %<:=%>");
3728 this->gogo_
->mark_locals_used();
3729 while (!token
->is_op(OPERATOR_SEMICOLON
)
3730 && !token
->is_eof())
3731 token
= this->advance_token();
3735 this->expression_stat(exp
);
3742 Parse::simple_stat_may_start_here()
3744 return this->expression_may_start_here();
3747 // Parse { Statement ";" } which is used in a few places. The list of
3748 // statements may end with a right curly brace, in which case the
3749 // semicolon may be omitted.
3752 Parse::statement_list()
3754 while (this->statement_may_start_here())
3756 this->statement(NULL
);
3757 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
))
3758 this->advance_token();
3759 else if (this->peek_token()->is_op(OPERATOR_RCURLY
))
3763 if (!this->peek_token()->is_eof() || !saw_errors())
3764 error_at(this->location(), "expected %<;%> or %<}%> or newline");
3765 if (!this->skip_past_error(OPERATOR_RCURLY
))
3772 Parse::statement_list_may_start_here()
3774 return this->statement_may_start_here();
3777 // ExpressionStat = Expression .
3780 Parse::expression_stat(Expression
* exp
)
3782 this->gogo_
->add_statement(Statement::make_statement(exp
, false));
3785 // SendStmt = Channel "<-" Expression .
3786 // Channel = Expression .
3789 Parse::send_stmt(Expression
* channel
)
3791 go_assert(this->peek_token()->is_op(OPERATOR_CHANOP
));
3792 Location loc
= this->location();
3793 this->advance_token();
3794 Expression
* val
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
3795 Statement
* s
= Statement::make_send_statement(channel
, val
, loc
);
3796 this->gogo_
->add_statement(s
);
3799 // IncDecStat = Expression ( "++" | "--" ) .
3802 Parse::inc_dec_stat(Expression
* exp
)
3804 const Token
* token
= this->peek_token();
3806 // Lvalue maps require special handling.
3807 if (exp
->index_expression() != NULL
)
3808 exp
->index_expression()->set_is_lvalue();
3810 if (token
->is_op(OPERATOR_PLUSPLUS
))
3811 this->gogo_
->add_statement(Statement::make_inc_statement(exp
));
3812 else if (token
->is_op(OPERATOR_MINUSMINUS
))
3813 this->gogo_
->add_statement(Statement::make_dec_statement(exp
));
3816 this->advance_token();
3819 // Assignment = ExpressionList assign_op ExpressionList .
3821 // EXP is an expression that we have already parsed.
3823 // If MAY_BE_COMPOSITE_LIT is true, an expression on the right hand
3824 // side may be a composite literal.
3826 // If RANGE_CLAUSE is not NULL, then this will recognize a
3830 Parse::assignment(Expression
* expr
, bool may_be_composite_lit
,
3831 Range_clause
* p_range_clause
)
3833 Expression_list
* vars
;
3834 if (!this->peek_token()->is_op(OPERATOR_COMMA
))
3836 vars
= new Expression_list();
3837 vars
->push_back(expr
);
3841 this->advance_token();
3842 vars
= this->expression_list(expr
, true, may_be_composite_lit
);
3845 this->tuple_assignment(vars
, may_be_composite_lit
, p_range_clause
);
3848 // An assignment statement. LHS is the list of expressions which
3849 // appear on the left hand side.
3851 // If MAY_BE_COMPOSITE_LIT is true, an expression on the right hand
3852 // side may be a composite literal.
3854 // If RANGE_CLAUSE is not NULL, then this will recognize a
3858 Parse::tuple_assignment(Expression_list
* lhs
, bool may_be_composite_lit
,
3859 Range_clause
* p_range_clause
)
3861 const Token
* token
= this->peek_token();
3862 if (!token
->is_op(OPERATOR_EQ
)
3863 && !token
->is_op(OPERATOR_PLUSEQ
)
3864 && !token
->is_op(OPERATOR_MINUSEQ
)
3865 && !token
->is_op(OPERATOR_OREQ
)
3866 && !token
->is_op(OPERATOR_XOREQ
)
3867 && !token
->is_op(OPERATOR_MULTEQ
)
3868 && !token
->is_op(OPERATOR_DIVEQ
)
3869 && !token
->is_op(OPERATOR_MODEQ
)
3870 && !token
->is_op(OPERATOR_LSHIFTEQ
)
3871 && !token
->is_op(OPERATOR_RSHIFTEQ
)
3872 && !token
->is_op(OPERATOR_ANDEQ
)
3873 && !token
->is_op(OPERATOR_BITCLEAREQ
))
3875 error_at(this->location(), "expected assignment operator");
3878 Operator op
= token
->op();
3879 Location location
= token
->location();
3881 token
= this->advance_token();
3883 if (p_range_clause
!= NULL
&& token
->is_keyword(KEYWORD_RANGE
))
3885 if (op
!= OPERATOR_EQ
)
3886 error_at(this->location(), "range clause requires %<=%>");
3887 this->range_clause_expr(lhs
, p_range_clause
);
3891 Expression_list
* vals
= this->expression_list(NULL
, false,
3892 may_be_composite_lit
);
3894 // We've parsed everything; check for errors.
3895 if (lhs
== NULL
|| vals
== NULL
)
3897 for (Expression_list::const_iterator pe
= lhs
->begin();
3901 if ((*pe
)->is_error_expression())
3903 if (op
!= OPERATOR_EQ
&& (*pe
)->is_sink_expression())
3904 error_at((*pe
)->location(), "cannot use _ as value");
3906 for (Expression_list::const_iterator pe
= vals
->begin();
3910 if ((*pe
)->is_error_expression())
3914 // Map expressions act differently when they are lvalues.
3915 for (Expression_list::iterator plv
= lhs
->begin();
3918 if ((*plv
)->index_expression() != NULL
)
3919 (*plv
)->index_expression()->set_is_lvalue();
3921 Call_expression
* call
;
3922 Index_expression
* map_index
;
3923 Receive_expression
* receive
;
3924 Type_guard_expression
* type_guard
;
3925 if (lhs
->size() == vals
->size())
3928 if (lhs
->size() > 1)
3930 if (op
!= OPERATOR_EQ
)
3931 error_at(location
, "multiple values only permitted with %<=%>");
3932 s
= Statement::make_tuple_assignment(lhs
, vals
, location
);
3936 if (op
== OPERATOR_EQ
)
3937 s
= Statement::make_assignment(lhs
->front(), vals
->front(),
3940 s
= Statement::make_assignment_operation(op
, lhs
->front(),
3941 vals
->front(), location
);
3945 this->gogo_
->add_statement(s
);
3947 else if (vals
->size() == 1
3948 && (call
= (*vals
->begin())->call_expression()) != NULL
)
3950 if (op
!= OPERATOR_EQ
)
3951 error_at(location
, "multiple results only permitted with %<=%>");
3953 vals
= new Expression_list
;
3954 for (unsigned int i
= 0; i
< lhs
->size(); ++i
)
3955 vals
->push_back(Expression::make_call_result(call
, i
));
3956 Statement
* s
= Statement::make_tuple_assignment(lhs
, vals
, location
);
3957 this->gogo_
->add_statement(s
);
3959 else if (lhs
->size() == 2
3960 && vals
->size() == 1
3961 && (map_index
= (*vals
->begin())->index_expression()) != NULL
)
3963 if (op
!= OPERATOR_EQ
)
3964 error_at(location
, "two values from map requires %<=%>");
3965 Expression
* val
= lhs
->front();
3966 Expression
* present
= lhs
->back();
3967 Statement
* s
= Statement::make_tuple_map_assignment(val
, present
,
3968 map_index
, location
);
3969 this->gogo_
->add_statement(s
);
3971 else if (lhs
->size() == 1
3972 && vals
->size() == 2
3973 && (map_index
= lhs
->front()->index_expression()) != NULL
)
3975 if (op
!= OPERATOR_EQ
)
3976 error_at(location
, "assigning tuple to map index requires %<=%>");
3977 Expression
* val
= vals
->front();
3978 Expression
* should_set
= vals
->back();
3979 Statement
* s
= Statement::make_map_assignment(map_index
, val
, should_set
,
3981 this->gogo_
->add_statement(s
);
3983 else if (lhs
->size() == 2
3984 && vals
->size() == 1
3985 && (receive
= (*vals
->begin())->receive_expression()) != NULL
)
3987 if (op
!= OPERATOR_EQ
)
3988 error_at(location
, "two values from receive requires %<=%>");
3989 Expression
* val
= lhs
->front();
3990 Expression
* success
= lhs
->back();
3991 Expression
* channel
= receive
->channel();
3992 Statement
* s
= Statement::make_tuple_receive_assignment(val
, success
,
3995 this->gogo_
->add_statement(s
);
3997 else if (lhs
->size() == 2
3998 && vals
->size() == 1
3999 && (type_guard
= (*vals
->begin())->type_guard_expression()) != NULL
)
4001 if (op
!= OPERATOR_EQ
)
4002 error_at(location
, "two values from type guard requires %<=%>");
4003 Expression
* val
= lhs
->front();
4004 Expression
* ok
= lhs
->back();
4005 Expression
* expr
= type_guard
->expr();
4006 Type
* type
= type_guard
->type();
4007 Statement
* s
= Statement::make_tuple_type_guard_assignment(val
, ok
,
4010 this->gogo_
->add_statement(s
);
4014 error_at(location
, "number of variables does not match number of values");
4018 // GoStat = "go" Expression .
4019 // DeferStat = "defer" Expression .
4022 Parse::go_or_defer_stat()
4024 go_assert(this->peek_token()->is_keyword(KEYWORD_GO
)
4025 || this->peek_token()->is_keyword(KEYWORD_DEFER
));
4026 bool is_go
= this->peek_token()->is_keyword(KEYWORD_GO
);
4027 Location stat_location
= this->location();
4028 this->advance_token();
4029 Location expr_location
= this->location();
4030 Expression
* expr
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
4031 Call_expression
* call_expr
= expr
->call_expression();
4032 if (call_expr
== NULL
)
4034 error_at(expr_location
, "expected call expression");
4038 // Make it easier to simplify go/defer statements by putting every
4039 // statement in its own block.
4040 this->gogo_
->start_block(stat_location
);
4043 stat
= Statement::make_go_statement(call_expr
, stat_location
);
4045 stat
= Statement::make_defer_statement(call_expr
, stat_location
);
4046 this->gogo_
->add_statement(stat
);
4047 this->gogo_
->add_block(this->gogo_
->finish_block(stat_location
),
4051 // ReturnStat = "return" [ ExpressionList ] .
4054 Parse::return_stat()
4056 go_assert(this->peek_token()->is_keyword(KEYWORD_RETURN
));
4057 Location location
= this->location();
4058 this->advance_token();
4059 Expression_list
* vals
= NULL
;
4060 if (this->expression_may_start_here())
4061 vals
= this->expression_list(NULL
, false, true);
4062 this->gogo_
->add_statement(Statement::make_return_statement(vals
, location
));
4065 && this->gogo_
->current_function()->func_value()->results_are_named())
4067 Named_object
* function
= this->gogo_
->current_function();
4068 Function::Results
* results
= function
->func_value()->result_variables();
4069 for (Function::Results::const_iterator p
= results
->begin();
4070 p
!= results
->end();
4073 Named_object
* no
= this->gogo_
->lookup((*p
)->name(), NULL
);
4075 go_assert(saw_errors());
4076 else if (!no
->is_result_variable())
4077 error_at(location
, "%qs is shadowed during return",
4078 (*p
)->message_name().c_str());
4083 // IfStmt = "if" [ SimpleStmt ";" ] Expression Block
4084 // [ "else" ( IfStmt | Block ) ] .
4089 go_assert(this->peek_token()->is_keyword(KEYWORD_IF
));
4090 Location location
= this->location();
4091 this->advance_token();
4093 this->gogo_
->start_block(location
);
4095 bool saw_simple_stat
= false;
4096 Expression
* cond
= NULL
;
4097 bool saw_send_stmt
= false;
4098 if (this->simple_stat_may_start_here())
4100 cond
= this->simple_stat(false, &saw_send_stmt
, NULL
, NULL
);
4101 saw_simple_stat
= true;
4103 if (cond
!= NULL
&& this->peek_token()->is_op(OPERATOR_SEMICOLON
))
4105 // The SimpleStat is an expression statement.
4106 this->expression_stat(cond
);
4111 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
))
4112 this->advance_token();
4113 else if (saw_simple_stat
)
4116 error_at(this->location(),
4117 ("send statement used as value; "
4118 "use select for non-blocking send"));
4120 error_at(this->location(),
4121 "expected %<;%> after statement in if expression");
4122 if (!this->expression_may_start_here())
4123 cond
= Expression::make_error(this->location());
4125 if (cond
== NULL
&& this->peek_token()->is_op(OPERATOR_LCURLY
))
4127 error_at(this->location(),
4128 "missing condition in if statement");
4129 cond
= Expression::make_error(this->location());
4132 cond
= this->expression(PRECEDENCE_NORMAL
, false, false, NULL
);
4135 this->gogo_
->start_block(this->location());
4136 Location end_loc
= this->block();
4137 Block
* then_block
= this->gogo_
->finish_block(end_loc
);
4139 // Check for the easy error of a newline before "else".
4140 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
))
4142 Location semi_loc
= this->location();
4143 if (this->advance_token()->is_keyword(KEYWORD_ELSE
))
4144 error_at(this->location(),
4145 "unexpected semicolon or newline before %<else%>");
4147 this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON
,
4151 Block
* else_block
= NULL
;
4152 if (this->peek_token()->is_keyword(KEYWORD_ELSE
))
4154 this->gogo_
->start_block(this->location());
4155 const Token
* token
= this->advance_token();
4156 if (token
->is_keyword(KEYWORD_IF
))
4158 else if (token
->is_op(OPERATOR_LCURLY
))
4162 error_at(this->location(), "expected %<if%> or %<{%>");
4163 this->statement(NULL
);
4165 else_block
= this->gogo_
->finish_block(this->location());
4168 this->gogo_
->add_statement(Statement::make_if_statement(cond
, then_block
,
4172 this->gogo_
->add_block(this->gogo_
->finish_block(this->location()),
4176 // SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .
4177 // ExprSwitchStmt = "switch" [ [ SimpleStat ] ";" ] [ Expression ]
4178 // "{" { ExprCaseClause } "}" .
4179 // TypeSwitchStmt = "switch" [ [ SimpleStat ] ";" ] TypeSwitchGuard
4180 // "{" { TypeCaseClause } "}" .
4181 // TypeSwitchGuard = [ identifier ":=" ] Expression "." "(" "type" ")" .
4184 Parse::switch_stat(Label
* label
)
4186 go_assert(this->peek_token()->is_keyword(KEYWORD_SWITCH
));
4187 Location location
= this->location();
4188 this->advance_token();
4190 this->gogo_
->start_block(location
);
4192 bool saw_simple_stat
= false;
4193 Expression
* switch_val
= NULL
;
4195 Type_switch type_switch
;
4196 bool have_type_switch_block
= false;
4197 if (this->simple_stat_may_start_here())
4199 switch_val
= this->simple_stat(false, &saw_send_stmt
, NULL
,
4201 saw_simple_stat
= true;
4203 if (switch_val
!= NULL
&& this->peek_token()->is_op(OPERATOR_SEMICOLON
))
4205 // The SimpleStat is an expression statement.
4206 this->expression_stat(switch_val
);
4209 if (switch_val
== NULL
&& !type_switch
.found
)
4211 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
))
4212 this->advance_token();
4213 else if (saw_simple_stat
)
4216 error_at(this->location(),
4217 ("send statement used as value; "
4218 "use select for non-blocking send"));
4220 error_at(this->location(),
4221 "expected %<;%> after statement in switch expression");
4223 if (!this->peek_token()->is_op(OPERATOR_LCURLY
))
4225 if (this->peek_token()->is_identifier())
4227 const Token
* token
= this->peek_token();
4228 std::string identifier
= token
->identifier();
4229 bool is_exported
= token
->is_identifier_exported();
4230 Location id_loc
= token
->location();
4232 token
= this->advance_token();
4233 bool is_coloneq
= token
->is_op(OPERATOR_COLONEQ
);
4234 this->unget_token(Token::make_identifier_token(identifier
,
4239 // This must be a TypeSwitchGuard. It is in a
4240 // different block from any initial SimpleStat.
4241 if (saw_simple_stat
)
4243 this->gogo_
->start_block(id_loc
);
4244 have_type_switch_block
= true;
4247 switch_val
= this->simple_stat(false, &saw_send_stmt
, NULL
,
4249 if (!type_switch
.found
)
4251 if (switch_val
== NULL
4252 || !switch_val
->is_error_expression())
4254 error_at(id_loc
, "expected type switch assignment");
4255 switch_val
= Expression::make_error(id_loc
);
4260 if (switch_val
== NULL
&& !type_switch
.found
)
4262 switch_val
= this->expression(PRECEDENCE_NORMAL
, false, false,
4263 &type_switch
.found
);
4264 if (type_switch
.found
)
4266 type_switch
.name
.clear();
4267 type_switch
.expr
= switch_val
;
4268 type_switch
.location
= switch_val
->location();
4274 if (!this->peek_token()->is_op(OPERATOR_LCURLY
))
4276 Location token_loc
= this->location();
4277 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
)
4278 && this->advance_token()->is_op(OPERATOR_LCURLY
))
4279 error_at(token_loc
, "unexpected semicolon or newline before %<{%>");
4280 else if (this->peek_token()->is_op(OPERATOR_COLONEQ
))
4282 error_at(token_loc
, "invalid variable name");
4283 this->advance_token();
4284 this->expression(PRECEDENCE_NORMAL
, false, false,
4285 &type_switch
.found
);
4286 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
))
4287 this->advance_token();
4288 if (!this->peek_token()->is_op(OPERATOR_LCURLY
))
4290 if (have_type_switch_block
)
4291 this->gogo_
->add_block(this->gogo_
->finish_block(location
),
4293 this->gogo_
->add_block(this->gogo_
->finish_block(location
),
4297 if (type_switch
.found
)
4298 type_switch
.expr
= Expression::make_error(location
);
4302 error_at(this->location(), "expected %<{%>");
4303 if (have_type_switch_block
)
4304 this->gogo_
->add_block(this->gogo_
->finish_block(this->location()),
4306 this->gogo_
->add_block(this->gogo_
->finish_block(this->location()),
4311 this->advance_token();
4313 Statement
* statement
;
4314 if (type_switch
.found
)
4315 statement
= this->type_switch_body(label
, type_switch
, location
);
4317 statement
= this->expr_switch_body(label
, switch_val
, location
);
4319 if (statement
!= NULL
)
4320 this->gogo_
->add_statement(statement
);
4322 if (have_type_switch_block
)
4323 this->gogo_
->add_block(this->gogo_
->finish_block(this->location()),
4326 this->gogo_
->add_block(this->gogo_
->finish_block(this->location()),
4330 // The body of an expression switch.
4331 // "{" { ExprCaseClause } "}"
4334 Parse::expr_switch_body(Label
* label
, Expression
* switch_val
,
4337 Switch_statement
* statement
= Statement::make_switch_statement(switch_val
,
4340 this->push_break_statement(statement
, label
);
4342 Case_clauses
* case_clauses
= new Case_clauses();
4343 bool saw_default
= false;
4344 while (!this->peek_token()->is_op(OPERATOR_RCURLY
))
4346 if (this->peek_token()->is_eof())
4349 error_at(this->location(), "missing %<}%>");
4352 this->expr_case_clause(case_clauses
, &saw_default
);
4354 this->advance_token();
4356 statement
->add_clauses(case_clauses
);
4358 this->pop_break_statement();
4363 // ExprCaseClause = ExprSwitchCase ":" [ StatementList ] .
4364 // FallthroughStat = "fallthrough" .
4367 Parse::expr_case_clause(Case_clauses
* clauses
, bool* saw_default
)
4369 Location location
= this->location();
4371 bool is_default
= false;
4372 Expression_list
* vals
= this->expr_switch_case(&is_default
);
4374 if (!this->peek_token()->is_op(OPERATOR_COLON
))
4377 error_at(this->location(), "expected %<:%>");
4381 this->advance_token();
4383 Block
* statements
= NULL
;
4384 if (this->statement_list_may_start_here())
4386 this->gogo_
->start_block(this->location());
4387 this->statement_list();
4388 statements
= this->gogo_
->finish_block(this->location());
4391 bool is_fallthrough
= false;
4392 if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH
))
4394 is_fallthrough
= true;
4395 if (this->advance_token()->is_op(OPERATOR_SEMICOLON
))
4396 this->advance_token();
4403 error_at(location
, "multiple defaults in switch");
4406 *saw_default
= true;
4409 if (is_default
|| vals
!= NULL
)
4410 clauses
->add(vals
, is_default
, statements
, is_fallthrough
, location
);
4413 // ExprSwitchCase = "case" ExpressionList | "default" .
4416 Parse::expr_switch_case(bool* is_default
)
4418 const Token
* token
= this->peek_token();
4419 if (token
->is_keyword(KEYWORD_CASE
))
4421 this->advance_token();
4422 return this->expression_list(NULL
, false, true);
4424 else if (token
->is_keyword(KEYWORD_DEFAULT
))
4426 this->advance_token();
4433 error_at(this->location(), "expected %<case%> or %<default%>");
4434 if (!token
->is_op(OPERATOR_RCURLY
))
4435 this->advance_token();
4440 // The body of a type switch.
4441 // "{" { TypeCaseClause } "}" .
4444 Parse::type_switch_body(Label
* label
, const Type_switch
& type_switch
,
4447 Named_object
* switch_no
= NULL
;
4448 if (!type_switch
.name
.empty())
4450 if (Gogo::is_sink_name(type_switch
.name
))
4451 error_at(type_switch
.location
,
4452 "no new variables on left side of %<:=%>");
4455 Variable
* switch_var
= new Variable(NULL
, type_switch
.expr
, false,
4457 type_switch
.location
);
4458 switch_no
= this->gogo_
->add_variable(type_switch
.name
, switch_var
);
4462 Type_switch_statement
* statement
=
4463 Statement::make_type_switch_statement(switch_no
,
4469 this->push_break_statement(statement
, label
);
4471 Type_case_clauses
* case_clauses
= new Type_case_clauses();
4472 bool saw_default
= false;
4473 while (!this->peek_token()->is_op(OPERATOR_RCURLY
))
4475 if (this->peek_token()->is_eof())
4477 error_at(this->location(), "missing %<}%>");
4480 this->type_case_clause(switch_no
, case_clauses
, &saw_default
);
4482 this->advance_token();
4484 statement
->add_clauses(case_clauses
);
4486 this->pop_break_statement();
4491 // TypeCaseClause = TypeSwitchCase ":" [ StatementList ] .
4494 Parse::type_case_clause(Named_object
* switch_no
, Type_case_clauses
* clauses
,
4497 Location location
= this->location();
4499 std::vector
<Type
*> types
;
4500 bool is_default
= false;
4501 this->type_switch_case(&types
, &is_default
);
4503 if (!this->peek_token()->is_op(OPERATOR_COLON
))
4504 error_at(this->location(), "expected %<:%>");
4506 this->advance_token();
4508 Block
* statements
= NULL
;
4509 if (this->statement_list_may_start_here())
4511 this->gogo_
->start_block(this->location());
4512 if (switch_no
!= NULL
&& types
.size() == 1)
4514 Type
* type
= types
.front();
4515 Expression
* init
= Expression::make_var_reference(switch_no
,
4517 init
= Expression::make_type_guard(init
, type
, location
);
4518 Variable
* v
= new Variable(type
, init
, false, false, false,
4520 v
->set_is_type_switch_var();
4521 Named_object
* no
= this->gogo_
->add_variable(switch_no
->name(), v
);
4523 // We don't want to issue an error if the compiler
4524 // introduced special variable is not used. Instead we want
4525 // to issue an error if the variable defined by the switch
4526 // is not used. That is handled via type_switch_vars_ and
4527 // Parse::mark_var_used.
4529 this->type_switch_vars_
[no
] = switch_no
;
4531 this->statement_list();
4532 statements
= this->gogo_
->finish_block(this->location());
4535 if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH
))
4537 error_at(this->location(),
4538 "fallthrough is not permitted in a type switch");
4539 if (this->advance_token()->is_op(OPERATOR_SEMICOLON
))
4540 this->advance_token();
4545 go_assert(types
.empty());
4548 error_at(location
, "multiple defaults in type switch");
4551 *saw_default
= true;
4552 clauses
->add(NULL
, false, true, statements
, location
);
4554 else if (!types
.empty())
4556 for (std::vector
<Type
*>::const_iterator p
= types
.begin();
4557 p
+ 1 != types
.end();
4559 clauses
->add(*p
, true, false, NULL
, location
);
4560 clauses
->add(types
.back(), false, false, statements
, location
);
4563 clauses
->add(Type::make_error_type(), false, false, statements
, location
);
4566 // TypeSwitchCase = "case" type | "default"
4568 // We accept a comma separated list of types.
4571 Parse::type_switch_case(std::vector
<Type
*>* types
, bool* is_default
)
4573 const Token
* token
= this->peek_token();
4574 if (token
->is_keyword(KEYWORD_CASE
))
4576 this->advance_token();
4579 Type
* t
= this->type();
4581 if (!t
->is_error_type())
4582 types
->push_back(t
);
4585 this->gogo_
->mark_locals_used();
4586 token
= this->peek_token();
4587 while (!token
->is_op(OPERATOR_COLON
)
4588 && !token
->is_op(OPERATOR_COMMA
)
4589 && !token
->is_op(OPERATOR_RCURLY
)
4590 && !token
->is_eof())
4591 token
= this->advance_token();
4594 if (!this->peek_token()->is_op(OPERATOR_COMMA
))
4596 this->advance_token();
4599 else if (token
->is_keyword(KEYWORD_DEFAULT
))
4601 this->advance_token();
4606 error_at(this->location(), "expected %<case%> or %<default%>");
4607 if (!token
->is_op(OPERATOR_RCURLY
))
4608 this->advance_token();
4612 // SelectStat = "select" "{" { CommClause } "}" .
4615 Parse::select_stat(Label
* label
)
4617 go_assert(this->peek_token()->is_keyword(KEYWORD_SELECT
));
4618 Location location
= this->location();
4619 const Token
* token
= this->advance_token();
4621 if (!token
->is_op(OPERATOR_LCURLY
))
4623 Location token_loc
= token
->location();
4624 if (token
->is_op(OPERATOR_SEMICOLON
)
4625 && this->advance_token()->is_op(OPERATOR_LCURLY
))
4626 error_at(token_loc
, "unexpected semicolon or newline before %<{%>");
4629 error_at(this->location(), "expected %<{%>");
4633 this->advance_token();
4635 Select_statement
* statement
= Statement::make_select_statement(location
);
4637 this->push_break_statement(statement
, label
);
4639 Select_clauses
* select_clauses
= new Select_clauses();
4640 bool saw_default
= false;
4641 while (!this->peek_token()->is_op(OPERATOR_RCURLY
))
4643 if (this->peek_token()->is_eof())
4645 error_at(this->location(), "expected %<}%>");
4648 this->comm_clause(select_clauses
, &saw_default
);
4651 this->advance_token();
4653 statement
->add_clauses(select_clauses
);
4655 this->pop_break_statement();
4657 this->gogo_
->add_statement(statement
);
4660 // CommClause = CommCase ":" { Statement ";" } .
4663 Parse::comm_clause(Select_clauses
* clauses
, bool* saw_default
)
4665 Location location
= this->location();
4666 bool is_send
= false;
4667 Expression
* channel
= NULL
;
4668 Expression
* val
= NULL
;
4669 Expression
* closed
= NULL
;
4670 std::string varname
;
4671 std::string closedname
;
4672 bool is_default
= false;
4673 bool got_case
= this->comm_case(&is_send
, &channel
, &val
, &closed
,
4674 &varname
, &closedname
, &is_default
);
4678 && closedname
.empty()
4680 && val
->index_expression() != NULL
)
4681 val
->index_expression()->set_is_lvalue();
4683 if (this->peek_token()->is_op(OPERATOR_COLON
))
4684 this->advance_token();
4686 error_at(this->location(), "expected colon");
4688 this->gogo_
->start_block(this->location());
4690 Named_object
* var
= NULL
;
4691 if (!varname
.empty())
4693 // FIXME: LOCATION is slightly wrong here.
4694 Variable
* v
= new Variable(NULL
, channel
, false, false, false,
4696 v
->set_type_from_chan_element();
4697 var
= this->gogo_
->add_variable(varname
, v
);
4700 Named_object
* closedvar
= NULL
;
4701 if (!closedname
.empty())
4703 // FIXME: LOCATION is slightly wrong here.
4704 Variable
* v
= new Variable(Type::lookup_bool_type(), NULL
,
4705 false, false, false, location
);
4706 closedvar
= this->gogo_
->add_variable(closedname
, v
);
4709 this->statement_list();
4711 Block
* statements
= this->gogo_
->finish_block(this->location());
4717 error_at(location
, "multiple defaults in select");
4720 *saw_default
= true;
4724 clauses
->add(is_send
, channel
, val
, closed
, var
, closedvar
, is_default
,
4725 statements
, location
);
4726 else if (statements
!= NULL
)
4728 // Add the statements to make sure that any names they define
4730 this->gogo_
->add_block(statements
, location
);
4734 // CommCase = "case" ( SendStmt | RecvStmt ) | "default" .
4737 Parse::comm_case(bool* is_send
, Expression
** channel
, Expression
** val
,
4738 Expression
** closed
, std::string
* varname
,
4739 std::string
* closedname
, bool* is_default
)
4741 const Token
* token
= this->peek_token();
4742 if (token
->is_keyword(KEYWORD_DEFAULT
))
4744 this->advance_token();
4747 else if (token
->is_keyword(KEYWORD_CASE
))
4749 this->advance_token();
4750 if (!this->send_or_recv_stmt(is_send
, channel
, val
, closed
, varname
,
4756 error_at(this->location(), "expected %<case%> or %<default%>");
4757 if (!token
->is_op(OPERATOR_RCURLY
))
4758 this->advance_token();
4765 // RecvStmt = [ Expression [ "," Expression ] ( "=" | ":=" ) ] RecvExpr .
4766 // RecvExpr = Expression .
4769 Parse::send_or_recv_stmt(bool* is_send
, Expression
** channel
, Expression
** val
,
4770 Expression
** closed
, std::string
* varname
,
4771 std::string
* closedname
)
4773 const Token
* token
= this->peek_token();
4774 bool saw_comma
= false;
4775 bool closed_is_id
= false;
4776 if (token
->is_identifier())
4778 Gogo
* gogo
= this->gogo_
;
4779 std::string recv_var
= token
->identifier();
4780 bool is_rv_exported
= token
->is_identifier_exported();
4781 Location recv_var_loc
= token
->location();
4782 token
= this->advance_token();
4783 if (token
->is_op(OPERATOR_COLONEQ
))
4786 this->advance_token();
4787 Expression
* e
= this->expression(PRECEDENCE_NORMAL
, false, false,
4789 Receive_expression
* re
= e
->receive_expression();
4792 if (!e
->is_error_expression())
4793 error_at(this->location(), "expected receive expression");
4796 if (recv_var
== "_")
4798 error_at(recv_var_loc
,
4799 "no new variables on left side of %<:=%>");
4803 *varname
= gogo
->pack_hidden_name(recv_var
, is_rv_exported
);
4804 *channel
= re
->channel();
4807 else if (token
->is_op(OPERATOR_COMMA
))
4809 token
= this->advance_token();
4810 if (token
->is_identifier())
4812 std::string recv_closed
= token
->identifier();
4813 bool is_rc_exported
= token
->is_identifier_exported();
4814 Location recv_closed_loc
= token
->location();
4815 closed_is_id
= true;
4817 token
= this->advance_token();
4818 if (token
->is_op(OPERATOR_COLONEQ
))
4820 // case rv, rc := <-c:
4821 this->advance_token();
4822 Expression
* e
= this->expression(PRECEDENCE_NORMAL
, false,
4824 Receive_expression
* re
= e
->receive_expression();
4827 if (!e
->is_error_expression())
4828 error_at(this->location(),
4829 "expected receive expression");
4832 if (recv_var
== "_" && recv_closed
== "_")
4834 error_at(recv_var_loc
,
4835 "no new variables on left side of %<:=%>");
4839 if (recv_var
!= "_")
4840 *varname
= gogo
->pack_hidden_name(recv_var
,
4842 if (recv_closed
!= "_")
4843 *closedname
= gogo
->pack_hidden_name(recv_closed
,
4845 *channel
= re
->channel();
4849 this->unget_token(Token::make_identifier_token(recv_closed
,
4854 *val
= this->id_to_expression(gogo
->pack_hidden_name(recv_var
,
4860 this->unget_token(Token::make_identifier_token(recv_var
,
4865 // If SAW_COMMA is false, then we are looking at the start of the
4866 // send or receive expression. If SAW_COMMA is true, then *VAL is
4867 // set and we just read a comma.
4870 if (saw_comma
|| !this->peek_token()->is_op(OPERATOR_CHANOP
))
4871 e
= this->expression(PRECEDENCE_NORMAL
, true, true, NULL
);
4876 this->advance_token();
4877 *channel
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
4879 // The next token should be ':'. If it is '<-', then we have
4881 // which is to say, send on a channel received from a channel.
4882 if (!this->peek_token()->is_op(OPERATOR_CHANOP
))
4885 e
= Expression::make_receive(*channel
, (*channel
)->location());
4888 if (this->peek_token()->is_op(OPERATOR_EQ
))
4890 if (!this->advance_token()->is_op(OPERATOR_CHANOP
))
4892 error_at(this->location(), "missing %<<-%>");
4896 this->advance_token();
4897 *channel
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
4901 // *VAL is already set.
4902 if (!e
->is_sink_expression())
4908 if (!e
->is_sink_expression())
4917 error_at(this->location(), "expected %<=%> or %<:=%>");
4919 error_at(this->location(), "expected %<=%>");
4923 if (this->peek_token()->is_op(OPERATOR_CHANOP
))
4927 *channel
= this->verify_not_sink(e
);
4928 this->advance_token();
4929 *val
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
4933 error_at(this->location(), "expected %<<-%> or %<=%>");
4937 // ForStat = "for" [ Condition | ForClause | RangeClause ] Block .
4938 // Condition = Expression .
4941 Parse::for_stat(Label
* label
)
4943 go_assert(this->peek_token()->is_keyword(KEYWORD_FOR
));
4944 Location location
= this->location();
4945 const Token
* token
= this->advance_token();
4947 // Open a block to hold any variables defined in the init statement
4948 // of the for statement.
4949 this->gogo_
->start_block(location
);
4952 Expression
* cond
= NULL
;
4954 Range_clause range_clause
;
4956 if (!token
->is_op(OPERATOR_LCURLY
))
4958 if (token
->is_keyword(KEYWORD_VAR
))
4960 error_at(this->location(),
4961 "var declaration not allowed in for initializer");
4965 if (token
->is_op(OPERATOR_SEMICOLON
))
4966 this->for_clause(&cond
, &post
);
4969 // We might be looking at a Condition, an InitStat, or a
4972 cond
= this->simple_stat(false, &saw_send_stmt
, &range_clause
, NULL
);
4973 if (!this->peek_token()->is_op(OPERATOR_SEMICOLON
))
4975 if (cond
== NULL
&& !range_clause
.found
)
4978 error_at(this->location(),
4979 ("send statement used as value; "
4980 "use select for non-blocking send"));
4982 error_at(this->location(), "parse error in for statement");
4987 if (range_clause
.found
)
4988 error_at(this->location(), "parse error after range clause");
4992 // COND is actually an expression statement for
4993 // InitStat at the start of a ForClause.
4994 this->expression_stat(cond
);
4998 this->for_clause(&cond
, &post
);
5003 // Build the For_statement and note that it is the current target
5004 // for break and continue statements.
5006 For_statement
* sfor
;
5007 For_range_statement
* srange
;
5009 if (!range_clause
.found
)
5011 sfor
= Statement::make_for_statement(init
, cond
, post
, location
);
5017 srange
= Statement::make_for_range_statement(range_clause
.index
,
5025 this->push_break_statement(s
, label
);
5026 this->push_continue_statement(s
, label
);
5028 // Gather the block of statements in the loop and add them to the
5031 this->gogo_
->start_block(this->location());
5032 Location end_loc
= this->block();
5033 Block
* statements
= this->gogo_
->finish_block(end_loc
);
5036 sfor
->add_statements(statements
);
5038 srange
->add_statements(statements
);
5040 // This is no longer the break/continue target.
5041 this->pop_break_statement();
5042 this->pop_continue_statement();
5044 // Add the For_statement to the list of statements, and close out
5045 // the block we started to hold any variables defined in the for
5048 this->gogo_
->add_statement(s
);
5050 this->gogo_
->add_block(this->gogo_
->finish_block(this->location()),
5054 // ForClause = [ InitStat ] ";" [ Condition ] ";" [ PostStat ] .
5055 // InitStat = SimpleStat .
5056 // PostStat = SimpleStat .
5058 // We have already read InitStat at this point.
5061 Parse::for_clause(Expression
** cond
, Block
** post
)
5063 go_assert(this->peek_token()->is_op(OPERATOR_SEMICOLON
));
5064 this->advance_token();
5065 if (this->peek_token()->is_op(OPERATOR_SEMICOLON
))
5067 else if (this->peek_token()->is_op(OPERATOR_LCURLY
))
5069 error_at(this->location(),
5070 "unexpected semicolon or newline before %<{%>");
5076 *cond
= this->expression(PRECEDENCE_NORMAL
, false, true, NULL
);
5077 if (!this->peek_token()->is_op(OPERATOR_SEMICOLON
))
5078 error_at(this->location(), "expected semicolon");
5080 this->advance_token();
5082 if (this->peek_token()->is_op(OPERATOR_LCURLY
))
5086 this->gogo_
->start_block(this->location());
5087 this->simple_stat(false, NULL
, NULL
, NULL
);
5088 *post
= this->gogo_
->finish_block(this->location());
5092 // RangeClause = IdentifierList ( "=" | ":=" ) "range" Expression .
5094 // This is the := version. It is called with a list of identifiers.
5097 Parse::range_clause_decl(const Typed_identifier_list
* til
,
5098 Range_clause
* p_range_clause
)
5100 go_assert(this->peek_token()->is_keyword(KEYWORD_RANGE
));
5101 Location location
= this->location();
5103 p_range_clause
->found
= true;
5105 go_assert(til
->size() >= 1);
5106 if (til
->size() > 2)
5107 error_at(this->location(), "too many variables for range clause");
5109 this->advance_token();
5110 Expression
* expr
= this->expression(PRECEDENCE_NORMAL
, false, false, NULL
);
5111 p_range_clause
->range
= expr
;
5113 bool any_new
= false;
5115 const Typed_identifier
* pti
= &til
->front();
5116 Named_object
* no
= this->init_var(*pti
, NULL
, expr
, true, true, &any_new
);
5117 if (any_new
&& no
->is_variable())
5118 no
->var_value()->set_type_from_range_index();
5119 p_range_clause
->index
= Expression::make_var_reference(no
, location
);
5121 if (til
->size() == 1)
5122 p_range_clause
->value
= NULL
;
5126 bool is_new
= false;
5127 no
= this->init_var(*pti
, NULL
, expr
, true, true, &is_new
);
5128 if (is_new
&& no
->is_variable())
5129 no
->var_value()->set_type_from_range_value();
5132 p_range_clause
->value
= Expression::make_var_reference(no
, location
);
5136 error_at(location
, "variables redeclared but no variable is new");
5139 // The = version of RangeClause. This is called with a list of
5143 Parse::range_clause_expr(const Expression_list
* vals
,
5144 Range_clause
* p_range_clause
)
5146 go_assert(this->peek_token()->is_keyword(KEYWORD_RANGE
));
5148 p_range_clause
->found
= true;
5150 go_assert(vals
->size() >= 1);
5151 if (vals
->size() > 2)
5152 error_at(this->location(), "too many variables for range clause");
5154 this->advance_token();
5155 p_range_clause
->range
= this->expression(PRECEDENCE_NORMAL
, false, false,
5158 p_range_clause
->index
= vals
->front();
5159 if (vals
->size() == 1)
5160 p_range_clause
->value
= NULL
;
5162 p_range_clause
->value
= vals
->back();
5165 // Push a statement on the break stack.
5168 Parse::push_break_statement(Statement
* enclosing
, Label
* label
)
5170 if (this->break_stack_
== NULL
)
5171 this->break_stack_
= new Bc_stack();
5172 this->break_stack_
->push_back(std::make_pair(enclosing
, label
));
5175 // Push a statement on the continue stack.
5178 Parse::push_continue_statement(Statement
* enclosing
, Label
* label
)
5180 if (this->continue_stack_
== NULL
)
5181 this->continue_stack_
= new Bc_stack();
5182 this->continue_stack_
->push_back(std::make_pair(enclosing
, label
));
5185 // Pop the break stack.
5188 Parse::pop_break_statement()
5190 this->break_stack_
->pop_back();
5193 // Pop the continue stack.
5196 Parse::pop_continue_statement()
5198 this->continue_stack_
->pop_back();
5201 // Find a break or continue statement given a label name.
5204 Parse::find_bc_statement(const Bc_stack
* bc_stack
, const std::string
& label
)
5206 if (bc_stack
== NULL
)
5208 for (Bc_stack::const_reverse_iterator p
= bc_stack
->rbegin();
5209 p
!= bc_stack
->rend();
5212 if (p
->second
!= NULL
&& p
->second
->name() == label
)
5214 p
->second
->set_is_used();
5221 // BreakStat = "break" [ identifier ] .
5226 go_assert(this->peek_token()->is_keyword(KEYWORD_BREAK
));
5227 Location location
= this->location();
5229 const Token
* token
= this->advance_token();
5230 Statement
* enclosing
;
5231 if (!token
->is_identifier())
5233 if (this->break_stack_
== NULL
|| this->break_stack_
->empty())
5235 error_at(this->location(),
5236 "break statement not within for or switch or select");
5239 enclosing
= this->break_stack_
->back().first
;
5243 enclosing
= this->find_bc_statement(this->break_stack_
,
5244 token
->identifier());
5245 if (enclosing
== NULL
)
5247 // If there is a label with this name, mark it as used to
5248 // avoid a useless error about an unused label.
5249 this->gogo_
->add_label_reference(token
->identifier(),
5250 Linemap::unknown_location(), false);
5252 error_at(token
->location(), "invalid break label %qs",
5253 Gogo::message_name(token
->identifier()).c_str());
5254 this->advance_token();
5257 this->advance_token();
5260 Unnamed_label
* label
;
5261 if (enclosing
->classification() == Statement::STATEMENT_FOR
)
5262 label
= enclosing
->for_statement()->break_label();
5263 else if (enclosing
->classification() == Statement::STATEMENT_FOR_RANGE
)
5264 label
= enclosing
->for_range_statement()->break_label();
5265 else if (enclosing
->classification() == Statement::STATEMENT_SWITCH
)
5266 label
= enclosing
->switch_statement()->break_label();
5267 else if (enclosing
->classification() == Statement::STATEMENT_TYPE_SWITCH
)
5268 label
= enclosing
->type_switch_statement()->break_label();
5269 else if (enclosing
->classification() == Statement::STATEMENT_SELECT
)
5270 label
= enclosing
->select_statement()->break_label();
5274 this->gogo_
->add_statement(Statement::make_break_statement(label
,
5278 // ContinueStat = "continue" [ identifier ] .
5281 Parse::continue_stat()
5283 go_assert(this->peek_token()->is_keyword(KEYWORD_CONTINUE
));
5284 Location location
= this->location();
5286 const Token
* token
= this->advance_token();
5287 Statement
* enclosing
;
5288 if (!token
->is_identifier())
5290 if (this->continue_stack_
== NULL
|| this->continue_stack_
->empty())
5292 error_at(this->location(), "continue statement not within for");
5295 enclosing
= this->continue_stack_
->back().first
;
5299 enclosing
= this->find_bc_statement(this->continue_stack_
,
5300 token
->identifier());
5301 if (enclosing
== NULL
)
5303 // If there is a label with this name, mark it as used to
5304 // avoid a useless error about an unused label.
5305 this->gogo_
->add_label_reference(token
->identifier(),
5306 Linemap::unknown_location(), false);
5308 error_at(token
->location(), "invalid continue label %qs",
5309 Gogo::message_name(token
->identifier()).c_str());
5310 this->advance_token();
5313 this->advance_token();
5316 Unnamed_label
* label
;
5317 if (enclosing
->classification() == Statement::STATEMENT_FOR
)
5318 label
= enclosing
->for_statement()->continue_label();
5319 else if (enclosing
->classification() == Statement::STATEMENT_FOR_RANGE
)
5320 label
= enclosing
->for_range_statement()->continue_label();
5324 this->gogo_
->add_statement(Statement::make_continue_statement(label
,
5328 // GotoStat = "goto" identifier .
5333 go_assert(this->peek_token()->is_keyword(KEYWORD_GOTO
));
5334 Location location
= this->location();
5335 const Token
* token
= this->advance_token();
5336 if (!token
->is_identifier())
5337 error_at(this->location(), "expected label for goto");
5340 Label
* label
= this->gogo_
->add_label_reference(token
->identifier(),
5342 Statement
* s
= Statement::make_goto_statement(label
, location
);
5343 this->gogo_
->add_statement(s
);
5344 this->advance_token();
5348 // PackageClause = "package" PackageName .
5351 Parse::package_clause()
5353 const Token
* token
= this->peek_token();
5354 Location location
= token
->location();
5356 if (!token
->is_keyword(KEYWORD_PACKAGE
))
5358 error_at(this->location(), "program must start with package clause");
5363 token
= this->advance_token();
5364 if (token
->is_identifier())
5366 name
= token
->identifier();
5369 error_at(this->location(), "invalid package name _");
5372 this->advance_token();
5376 error_at(this->location(), "package name must be an identifier");
5380 this->gogo_
->set_package_name(name
, location
);
5383 // ImportDecl = "import" Decl<ImportSpec> .
5386 Parse::import_decl()
5388 go_assert(this->peek_token()->is_keyword(KEYWORD_IMPORT
));
5389 this->advance_token();
5390 this->decl(&Parse::import_spec
, NULL
);
5393 // ImportSpec = [ "." | PackageName ] PackageFileName .
5396 Parse::import_spec(void*)
5398 const Token
* token
= this->peek_token();
5399 Location location
= token
->location();
5401 std::string local_name
;
5402 bool is_local_name_exported
= false;
5403 if (token
->is_op(OPERATOR_DOT
))
5406 token
= this->advance_token();
5408 else if (token
->is_identifier())
5410 local_name
= token
->identifier();
5411 is_local_name_exported
= token
->is_identifier_exported();
5412 token
= this->advance_token();
5415 if (!token
->is_string())
5417 error_at(this->location(), "import statement not a string");
5418 this->advance_token();
5422 this->gogo_
->import_package(token
->string_value(), local_name
,
5423 is_local_name_exported
, location
);
5425 this->advance_token();
5428 // SourceFile = PackageClause ";" { ImportDecl ";" }
5429 // { TopLevelDecl ";" } .
5434 this->package_clause();
5436 const Token
* token
= this->peek_token();
5437 if (token
->is_op(OPERATOR_SEMICOLON
))
5438 token
= this->advance_token();
5440 error_at(this->location(),
5441 "expected %<;%> or newline after package clause");
5443 while (token
->is_keyword(KEYWORD_IMPORT
))
5445 this->import_decl();
5446 token
= this->peek_token();
5447 if (token
->is_op(OPERATOR_SEMICOLON
))
5448 token
= this->advance_token();
5450 error_at(this->location(),
5451 "expected %<;%> or newline after import declaration");
5454 while (!token
->is_eof())
5456 if (this->declaration_may_start_here())
5457 this->declaration();
5460 error_at(this->location(), "expected declaration");
5461 this->gogo_
->mark_locals_used();
5463 this->advance_token();
5464 while (!this->peek_token()->is_eof()
5465 && !this->peek_token()->is_op(OPERATOR_SEMICOLON
)
5466 && !this->peek_token()->is_op(OPERATOR_RCURLY
));
5467 if (!this->peek_token()->is_eof()
5468 && !this->peek_token()->is_op(OPERATOR_SEMICOLON
))
5469 this->advance_token();
5471 token
= this->peek_token();
5472 if (token
->is_op(OPERATOR_SEMICOLON
))
5473 token
= this->advance_token();
5474 else if (!token
->is_eof() || !saw_errors())
5476 if (token
->is_op(OPERATOR_CHANOP
))
5477 error_at(this->location(),
5478 ("send statement used as value; "
5479 "use select for non-blocking send"));
5481 error_at(this->location(),
5482 "expected %<;%> or newline after top level declaration");
5483 this->skip_past_error(OPERATOR_INVALID
);
5488 // Reset the current iota value.
5496 // Return the current iota value.
5504 // Increment the current iota value.
5507 Parse::increment_iota()
5512 // Skip forward to a semicolon or OP. OP will normally be
5513 // OPERATOR_RPAREN or OPERATOR_RCURLY. If we find a semicolon, move
5514 // past it and return. If we find OP, it will be the next token to
5515 // read. Return true if we are OK, false if we found EOF.
5518 Parse::skip_past_error(Operator op
)
5520 this->gogo_
->mark_locals_used();
5521 const Token
* token
= this->peek_token();
5522 while (!token
->is_op(op
))
5524 if (token
->is_eof())
5526 if (token
->is_op(OPERATOR_SEMICOLON
))
5528 this->advance_token();
5531 token
= this->advance_token();
5536 // Check that an expression is not a sink.
5539 Parse::verify_not_sink(Expression
* expr
)
5541 if (expr
->is_sink_expression())
5543 error_at(expr
->location(), "cannot use _ as value");
5544 expr
= Expression::make_error(expr
->location());
5549 // Mark a variable as used.
5552 Parse::mark_var_used(Named_object
* no
)
5554 if (no
->is_variable())
5556 no
->var_value()->set_is_used();
5558 // When a type switch uses := to define a variable, then for
5559 // each case with a single type we introduce a new variable with
5560 // the appropriate type. When we do, if the newly introduced
5561 // variable is used, then the type switch variable is used.
5562 Type_switch_vars::iterator p
= this->type_switch_vars_
.find(no
);
5563 if (p
!= this->type_switch_vars_
.end())
5564 p
->second
->var_value()->set_is_used();