3 // cs-parser.jay: The Parser for the C# compiler
5 // Authors: Miguel de Icaza (miguel@gnu.org)
6 // Ravi Pratap (ravi@ximian.com)
7 // Marek Safar (marek.safar@gmail.com)
9 // Dual Licensed under the terms of the GNU GPL and the MIT X11 license
11 // (C) 2001 Ximian, Inc (http://www.ximian.com)
12 // (C) 2004 Novell, Inc
15 // (1) Figure out why error productions dont work. `type-declaration' is a
16 // great spot to put an `error' because you can reproduce it with this input:
23 using System.Collections.Generic;
30 public class CSharpParser
33 enum ParameterModifierType
40 DefaultValue = 1 << 6,
42 All = Ref | Out | This | Params | Arglist | DefaultValue
45 NamespaceEntry current_namespace;
46 TypeContainer current_container;
47 DeclSpace current_class;
50 /// Current block is used to add statements as we find
55 Delegate current_delegate;
57 GenericMethod current_generic_method;
58 AnonymousMethodExpression current_anonymous_method;
61 /// This is used by the unary_expression code to resolve
62 /// a name against a parameter.
65 // FIXME: This is very ugly and it's very hard to reset it correctly
66 // on all places, especially when some parameters are autogenerated.
67 ParametersCompiled current_local_parameters;
70 /// Using during property parsing to describe the implicit
71 /// value parameter that is passed to the "set" and "get"accesor
72 /// methods (properties and indexers).
74 FullNamedExpression implicit_value_parameter_type;
75 ParametersCompiled indexer_parameters;
78 /// Used to determine if we are parsing the get/set pair
79 /// of an indexer or a property
83 bool parsing_anonymous_method;
86 /// An out-of-band stack.
88 static Stack<object> oob_stack;
93 Stack<Block> switch_stack;
96 /// Controls the verbosity of the errors produced by the parser
98 static public int yacc_verbose_flag;
101 /// Used by the interactive shell, flags whether EOF was reached
102 /// and an error was produced
104 public bool UnexpectedEOF;
107 /// The current file.
109 CompilationUnit file;
112 /// Temporary Xml documentation cache.
113 /// For enum types, we need one more temporary store.
116 string enumTypeComment;
118 /// Current attribute target
119 string current_attr_target;
121 /// assembly and module attribute definitions are enabled
122 bool global_attrs_enabled = true;
123 bool has_get, has_set;
125 ParameterModifierType valid_param_mod;
127 bool default_parameter_used;
129 /// When using the interactive parser, this holds the
130 /// resulting expression
131 public object InteractiveResult;
134 // Keeps track of global data changes to undo on parser error
138 Stack<Block> linq_clause_blocks;
140 // A counter to create new class names in interactive mode
141 static int class_count;
143 CompilerContext compiler;
146 // Instead of allocating carrier array everytime we
147 // share the bucket for very common constructs which can never
150 static List<Parameter> parameters_bucket = new List<Parameter> (6);
151 static List<object> variables_bucket = new List<object> (6);
155 %token NONE /* This token is never returned by our lexer */
156 %token ERROR // This is used not by the parser, but by the tokenizer.
160 *These are the C# keywords
259 %token INTERR_NULLABLE
262 /* Generics <,> tokens */
263 %token OP_GENERICS_LT
264 %token OP_GENERICS_LT_DECL
265 %token OP_GENERICS_GT
267 /* C# keywords which are not really keywords */
273 /* C# single character operators/punctuation. */
301 /* C# multi-character operators. */
306 %token OP_SHIFT_RIGHT
313 %token OP_MULT_ASSIGN
318 %token OP_SHIFT_LEFT_ASSIGN
319 %token OP_SHIFT_RIGHT_ASSIGN
329 %token OPEN_PARENS_LAMBDA
330 %token OPEN_PARENS_CAST
331 %token GENERIC_DIMENSION
334 // Make the parser go into eval mode parsing (statements and compilation units).
335 %token EVAL_STATEMENT_PARSER
336 %token EVAL_COMPILATION_UNIT_PARSER
337 %token EVAL_USING_DECLARATIONS_UNIT_PARSER
340 // This token is generated to trigger the completion engine at this point
342 %token GENERATE_COMPLETION
345 // This token is return repeatedly after the first GENERATE_COMPLETION
346 // token is produced and before the final EOF
348 %token COMPLETE_COMPLETION
350 /* Add precedence rules to solve dangling else s/r conflict */
354 /* Define the operator tokens and their precedences */
362 %left OP_SHIFT_LEFT OP_SHIFT_RIGHT
364 %left STAR DIV PERCENT
365 %right BANG CARRET UMINUS
366 %nonassoc OP_INC OP_DEC
368 %left OPEN_BRACKET OPEN_BRACE
371 %start compilation_unit
375 : outer_declarations opt_EOF
376 | outer_declarations global_attributes opt_EOF
377 | global_attributes opt_EOF
378 | opt_EOF /* allow empty files */
379 | interactive_parsing { Lexer.CompleteOnEOF = false; } opt_EOF
385 Lexer.check_incorrect_doc_comment ();
389 Lexer.check_incorrect_doc_comment ();
395 | outer_declarations outer_declaration
399 : extern_alias_directive
401 | namespace_member_declaration
404 extern_alias_directives
405 : extern_alias_directive
406 | extern_alias_directives extern_alias_directive
409 extern_alias_directive
410 : EXTERN_ALIAS IDENTIFIER IDENTIFIER SEMICOLON
412 var lt = (Tokenizer.LocatedToken) $2;
415 syntax_error (lt.Location, "`alias' expected");
416 } else if (RootContext.Version == LanguageVersion.ISO_1) {
417 Report.FeatureIsNotAvailable (lt.Location, "external alias");
419 lt = (Tokenizer.LocatedToken) $3;
420 current_namespace.AddUsingExternalAlias (lt.Value, lt.Location, Report);
425 syntax_error (GetLocation ($1), "`alias' expected"); // TODO: better
431 | using_directives using_directive
435 : using_alias_directive
437 if (RootContext.Documentation != null)
438 Lexer.doc_state = XmlCommentState.Allowed;
440 | using_namespace_directive
442 if (RootContext.Documentation != null)
443 Lexer.doc_state = XmlCommentState.Allowed;
447 using_alias_directive
448 : USING IDENTIFIER ASSIGN namespace_or_type_name SEMICOLON
450 var lt = (Tokenizer.LocatedToken) $2;
451 current_namespace.AddUsingAlias (lt.Value, (MemberName) $4, GetLocation ($1));
454 CheckIdentifierToken (yyToken, GetLocation ($2));
459 using_namespace_directive
460 : USING namespace_name SEMICOLON
462 current_namespace.AddUsing ((MemberName) $2, GetLocation ($1));
467 // Strictly speaking, namespaces don't have attributes but
468 // we parse global attributes along with namespace declarations and then
471 namespace_declaration
472 : opt_attributes NAMESPACE qualified_identifier
474 MemberName name = (MemberName) $3;
477 Report.Error(1671, name.Location, "A namespace declaration cannot have modifiers or attributes");
480 current_namespace = new NamespaceEntry (
481 current_namespace, file, name.GetName ());
482 current_class = current_namespace.SlaveDeclSpace;
483 current_container = current_class.PartialContainer;
485 namespace_body opt_semicolon
487 current_namespace = current_namespace.Parent;
488 current_class = current_namespace.SlaveDeclSpace;
489 current_container = current_class.PartialContainer;
496 var lt = (Tokenizer.LocatedToken) $1;
497 $$ = new MemberName (lt.Value, lt.Location);
499 | qualified_identifier DOT IDENTIFIER
501 var lt = (Tokenizer.LocatedToken) $3;
502 $$ = new MemberName ((MemberName) $1, lt.Value, lt.Location);
506 syntax_error (lexer.Location, "`.' expected");
507 $$ = new MemberName ("<invalid>", lexer.Location);
522 : namespace_or_type_name
524 MemberName name = (MemberName) $1;
526 if (name.TypeArguments != null)
527 syntax_error (lexer.Location, "namespace name expected");
536 if (RootContext.Documentation != null)
537 Lexer.doc_state = XmlCommentState.Allowed;
543 : opt_extern_alias_directives
545 opt_namespace_member_declarations
549 Report.Error (1518, lexer.Location, "Expected `class', `delegate', `enum', `interface', or `struct'");
552 | opt_extern_alias_directives
554 opt_namespace_member_declarations
557 Report.Error (1513, lexer.Location, "Expected `}'");
566 opt_extern_alias_directives
568 | extern_alias_directives
571 opt_namespace_member_declarations
573 | namespace_member_declarations
576 namespace_member_declarations
577 : namespace_member_declaration
578 | namespace_member_declarations namespace_member_declaration
581 namespace_member_declaration
585 DeclSpace ds = (DeclSpace)$1;
587 if ((ds.ModFlags & (Modifiers.PRIVATE|Modifiers.PROTECTED)) != 0){
588 Report.Error (1527, ds.Location,
589 "Namespace elements cannot be explicitly declared as private, protected or protected internal");
592 current_namespace.DeclarationFound = true;
594 | namespace_declaration {
595 current_namespace.DeclarationFound = true;
598 | field_declaration {
599 Report.Error (116, ((MemberCore) $1).Location, "A namespace can only contain types and namespace declarations");
601 | method_declaration {
602 Report.Error (116, ((MemberCore) $1).Location, "A namespace can only contain types and namespace declarations");
609 | interface_declaration
611 | delegate_declaration
613 // Enable this when we have handled all errors, because this acts as a generic fallback
616 // Console.WriteLine ("Token=" + yyToken);
617 // Report.Error (1518, GetLocation ($1), "Expected class, struct, interface, enum or delegate");
629 Attributes attrs = (Attributes)$1;
630 if (global_attrs_enabled) {
631 CodeGen.Assembly.AddAttributes (attrs.Attrs, current_namespace);
633 foreach (Attribute a in attrs.Attrs) {
634 Report.Error (1730, a.Location, "Assembly and module attributes must precede all other elements except using clauses and extern alias declarations");
645 global_attrs_enabled = false;
650 global_attrs_enabled = false;
659 if (current_attr_target != String.Empty) {
660 var sect = (List<Attribute>) $1;
662 if (global_attrs_enabled) {
663 if (current_attr_target == "module") {
664 current_container.Module.Compiled.AddAttributes (sect);
666 } else if (current_attr_target != null && current_attr_target.Length > 0) {
667 CodeGen.Assembly.AddAttributes (sect, current_namespace);
670 $$ = new Attributes (sect);
673 if (RootContext.Documentation != null) {
674 Lexer.check_incorrect_doc_comment ();
676 XmlCommentState.Allowed;
680 $$ = new Attributes (sect);
685 current_attr_target = null;
687 | attribute_sections attribute_section
689 if (current_attr_target != String.Empty) {
690 Attributes attrs = $1 as Attributes;
691 var sect = (List<Attribute>) $2;
693 if (global_attrs_enabled) {
694 if (current_attr_target == "module") {
695 current_container.Module.Compiled.AddAttributes (sect);
697 } else if (current_attr_target == "assembly") {
698 CodeGen.Assembly.AddAttributes (sect, current_namespace);
702 attrs = new Attributes (sect);
704 attrs.AddAttributes (sect);
708 attrs = new Attributes (sect);
710 attrs.AddAttributes (sect);
716 current_attr_target = null;
721 : OPEN_BRACKET attribute_target_specifier attribute_list opt_comma CLOSE_BRACKET
725 | OPEN_BRACKET attribute_list opt_comma CLOSE_BRACKET
731 attribute_target_specifier
732 : attribute_target COLON
734 current_attr_target = (string)$1;
742 var lt = (Tokenizer.LocatedToken) $1;
743 $$ = CheckAttributeTarget (lt.Value, lt.Location);
745 | EVENT { $$ = "event"; }
746 | RETURN { $$ = "return"; }
749 string name = GetTokenName (yyToken);
750 $$ = CheckAttributeTarget (name, GetLocation ($1));
757 $$ = new List<Attribute> (4) { (Attribute) $1 };
759 | attribute_list COMMA attribute
761 var attrs = (List<Attribute>) $1;
762 attrs.Add ((Attribute) $3);
771 ++lexer.parsing_block;
773 opt_attribute_arguments
775 --lexer.parsing_block;
776 MemberName mname = (MemberName) $1;
777 if (mname.IsGeneric) {
778 Report.Error (404, lexer.Location,
779 "'<' unexpected: attributes cannot be generic");
782 Arguments [] arguments = (Arguments []) $3;
783 ATypeNameExpression expr = mname.GetTypeExpression ();
785 if (current_attr_target == String.Empty)
787 else if (global_attrs_enabled && (current_attr_target == "assembly" || current_attr_target == "module"))
788 // FIXME: supply "nameEscaped" parameter here.
789 $$ = new GlobalAttribute (current_namespace, current_attr_target,
790 expr, arguments, mname.Location, lexer.IsEscapedIdentifier (mname.Location));
792 $$ = new Attribute (current_attr_target, expr, arguments, mname.Location, lexer.IsEscapedIdentifier (mname.Location));
797 : namespace_or_type_name { /* reserved attribute name or identifier: 17.4 */ }
800 opt_attribute_arguments
801 : /* empty */ { $$ = null; }
802 | OPEN_PARENS attribute_arguments CLOSE_PARENS
810 : /* empty */ { $$ = null; }
811 | positional_or_named_argument
813 Arguments a = new Arguments (4);
814 a.Add ((Argument) $1);
815 $$ = new Arguments [] { a, null };
817 | named_attribute_argument
819 Arguments a = new Arguments (4);
820 a.Add ((Argument) $1);
821 $$ = new Arguments [] { null, a };
823 | attribute_arguments COMMA positional_or_named_argument
825 Arguments[] o = (Arguments[]) $1;
827 Report.Error (1016, ((Argument) $3).Expr.Location, "Named attribute arguments must appear after the positional arguments");
828 o [0] = new Arguments (4);
831 Arguments args = ((Arguments) o [0]);
832 if (args.Count > 0 && !($3 is NamedArgument) && args [args.Count - 1] is NamedArgument)
833 Error_NamedArgumentExpected ((NamedArgument) args [args.Count - 1]);
835 args.Add ((Argument) $3);
837 | attribute_arguments COMMA named_attribute_argument
839 Arguments[] o = (Arguments[]) $1;
841 o [1] = new Arguments (4);
844 ((Arguments) o [1]).Add ((Argument) $3);
848 positional_or_named_argument
851 $$ = new Argument ((Expression) $1);
856 named_attribute_argument
857 : IDENTIFIER ASSIGN expression
859 var lt = (Tokenizer.LocatedToken) $1;
860 $$ = new NamedArgument (lt.Value, lt.Location, (Expression) $3);
865 : IDENTIFIER COLON opt_named_modifier expression
867 if (RootContext.Version <= LanguageVersion.V_3)
868 Report.FeatureIsNotAvailable (GetLocation ($1), "named argument");
870 // Avoid boxing in common case (no modifier)
871 var arg_mod = $3 == null ? Argument.AType.None : (Argument.AType) $3;
873 var lt = (Tokenizer.LocatedToken) $1;
874 $$ = new NamedArgument (lt.Value, lt.Location, (Expression) $4, arg_mod);
879 : /* empty */ { $$ = null; }
882 $$ = Argument.AType.Ref;
886 $$ = Argument.AType.Out;
891 : OPEN_BRACE opt_class_member_declarations CLOSE_BRACE
894 opt_class_member_declarations
896 | class_member_declarations
899 class_member_declarations
900 : class_member_declaration
901 | class_member_declarations
902 class_member_declaration
905 class_member_declaration
906 : constant_declaration // done
907 | field_declaration // done
908 | method_declaration // done
909 | property_declaration // done
910 | event_declaration // done
911 | indexer_declaration // done
912 | operator_declaration // done
913 | constructor_declaration // done
914 | destructor_declaration // done
918 Report.Error (1519, lexer.Location, "Unexpected symbol `{0}' in class, struct, or interface member declaration",
919 GetSymbolName (yyToken));
921 lexer.parsing_generic_declaration = false;
931 lexer.ConstraintsParsing = true;
933 type_declaration_name
935 MemberName name = MakeName ((MemberName) $6);
936 push_current_class (new Struct (current_namespace, current_class, name, (Modifiers) $2, (Attributes) $1), $3);
939 opt_type_parameter_constraints_clauses
941 lexer.ConstraintsParsing = false;
943 current_class.SetParameterInfo ((List<Constraints>) $9);
945 if (RootContext.Documentation != null)
946 current_container.DocComment = Lexer.consume_doc_comment ();
950 --lexer.parsing_declaration;
951 if (RootContext.Documentation != null)
952 Lexer.doc_state = XmlCommentState.Allowed;
956 $$ = pop_current_class ();
958 | opt_attributes opt_modifiers opt_partial STRUCT error {
959 CheckIdentifierToken (yyToken, GetLocation ($5));
966 if (RootContext.Documentation != null)
967 Lexer.doc_state = XmlCommentState.Allowed;
969 opt_struct_member_declarations CLOSE_BRACE
972 opt_struct_member_declarations
974 | struct_member_declarations
977 struct_member_declarations
978 : struct_member_declaration
979 | struct_member_declarations struct_member_declaration
982 struct_member_declaration
983 : constant_declaration
986 | property_declaration
988 | indexer_declaration
989 | operator_declaration
990 | constructor_declaration
994 * This is only included so we can flag error 575:
995 * destructors only allowed on class types
997 | destructor_declaration
1000 constant_declaration
1005 constant_declarators
1008 var modflags = (Modifiers) $2;
1009 foreach (VariableDeclaration constant in (List<object>) $5){
1010 Location l = constant.Location;
1011 if ((modflags & Modifiers.STATIC) != 0) {
1012 Report.Error (504, l, "The constant `{0}' cannot be marked static", current_container.GetSignatureForError () + "." + (string) constant.identifier);
1016 Const c = new Const (
1017 current_class, (FullNamedExpression) $4, (string) constant.identifier,
1018 constant.GetInitializer ((FullNamedExpression) $4), modflags,
1019 (Attributes) $1, l);
1021 if (RootContext.Documentation != null) {
1022 c.DocComment = Lexer.consume_doc_comment ();
1023 Lexer.doc_state = XmlCommentState.Allowed;
1025 current_container.AddConstant (c);
1030 constant_declarators
1031 : constant_declarator
1033 variables_bucket.Clear ();
1035 variables_bucket.Add ($1);
1036 $$ = variables_bucket;
1038 | constant_declarators COMMA constant_declarator
1041 var constants = (List<object>) $1;
1050 ++lexer.parsing_block;
1052 constant_initializer
1054 --lexer.parsing_block;
1055 $$ = new VariableDeclaration ((Tokenizer.LocatedToken) $1, (Expression) $4);
1059 // A const field requires a value to be provided
1060 Report.Error (145, GetLocation ($1), "A const field requires a value to be provided");
1065 constant_initializer
1066 : constant_expression
1074 variable_declarators
1077 FullNamedExpression type = (FullNamedExpression) $3;
1078 if (type == TypeManager.system_void_expr)
1079 Report.Error (670, GetLocation ($3), "Fields cannot have void type");
1081 var mod = (Modifiers) $2;
1083 foreach (VariableMemberDeclaration var in (List<object>) $4){
1084 Field field = new Field (current_class, type, mod, var.MemberName, (Attributes) $1);
1086 field.Initializer = var.GetInitializer (type);
1088 if (RootContext.Documentation != null) {
1089 field.DocComment = Lexer.consume_doc_comment ();
1090 Lexer.doc_state = XmlCommentState.Allowed;
1092 current_container.AddField (field);
1093 $$ = field; // FIXME: might be better if it points to the top item
1100 fixed_variable_declarators
1103 FullNamedExpression type = (FullNamedExpression) $4;
1105 var mod = (Modifiers) $2;
1107 foreach (VariableDeclaration var in (List<VariableDeclaration>) $5) {
1108 FixedField field = new FixedField (current_class, type, mod, var.identifier,
1109 var.GetInitializer (type), (Attributes) $1, var.Location);
1111 if (RootContext.Version < LanguageVersion.ISO_2)
1112 Report.FeatureIsNotAvailable (GetLocation ($3), "fixed size buffers");
1114 if (RootContext.Documentation != null) {
1115 field.DocComment = Lexer.consume_doc_comment ();
1116 Lexer.doc_state = XmlCommentState.Allowed;
1118 current_container.AddField (field);
1119 $$ = field; // FIXME: might be better if it points to the top item
1128 Report.Error (1641, GetLocation ($4), "A fixed size buffer field must have the array size specifier after the field name");
1132 fixed_variable_declarators
1133 : fixed_variable_declarator
1135 var decl = new List<VariableDeclaration> (2);
1136 decl.Add ((VariableDeclaration)$1);
1139 | fixed_variable_declarators COMMA fixed_variable_declarator
1141 var decls = (List<VariableDeclaration>) $1;
1142 decls.Add ((VariableDeclaration)$3);
1147 fixed_variable_declarator
1148 : IDENTIFIER OPEN_BRACKET expression CLOSE_BRACKET
1150 $$ = new VariableDeclaration ((Tokenizer.LocatedToken) $1, (Expression) $3);
1152 | IDENTIFIER OPEN_BRACKET CLOSE_BRACKET
1154 Report.Error (443, lexer.Location, "Value or constant expected");
1155 $$ = new VariableDeclaration ((Tokenizer.LocatedToken) $1, null);
1160 local_variable_declarators
1161 : local_variable_declarator
1163 variables_bucket.Clear ();
1165 variables_bucket.Add ($1);
1166 $$ = variables_bucket;
1168 | local_variable_declarators COMMA local_variable_declarator
1170 var decls = (List<object>) $1;
1176 local_variable_declarator
1177 : IDENTIFIER ASSIGN local_variable_initializer
1179 $$ = new VariableDeclaration ((Tokenizer.LocatedToken) $1, (Expression) $3);
1183 $$ = new VariableDeclaration ((Tokenizer.LocatedToken) $1, null);
1185 | IDENTIFIER variable_bad_array
1191 local_variable_initializer
1194 | STACKALLOC simple_type OPEN_BRACKET expression CLOSE_BRACKET
1196 $$ = new StackAlloc ((Expression) $2, (Expression) $4, GetLocation ($1));
1200 $$ = new ArglistAccess (GetLocation ($1));
1202 | STACKALLOC simple_type
1204 Report.Error (1575, GetLocation ($1), "A stackalloc expression requires [] after type");
1205 $$ = new StackAlloc ((Expression) $2, null, GetLocation ($1));
1209 variable_declarators
1210 : variable_declarator
1212 variables_bucket.Clear ();
1214 variables_bucket.Add ($1);
1215 $$ = variables_bucket;
1217 | variable_declarators COMMA variable_declarator
1219 var decls = (List<object>) $1;
1226 : member_declaration_name ASSIGN
1228 ++lexer.parsing_block;
1229 lexer.parsing_generic_declaration = false;
1231 variable_initializer
1233 --lexer.parsing_block;
1234 $$ = new VariableMemberDeclaration ((MemberName) $1, (Expression) $4);
1236 | member_declaration_name
1238 lexer.parsing_generic_declaration = false;
1239 $$ = new VariableMemberDeclaration ((MemberName) $1, null);
1241 | member_declaration_name variable_bad_array
1243 lexer.parsing_generic_declaration = false;
1249 : OPEN_BRACKET opt_expression CLOSE_BRACKET
1251 Report.Error (650, GetLocation ($1), "Syntax error, bad array declarator. To declare a managed array the rank specifier precedes the variable's identifier. " +
1252 "To declare a fixed size buffer field, use the fixed keyword before the field type");
1256 variable_initializer
1263 if (RootContext.Documentation != null)
1264 Lexer.doc_state = XmlCommentState.NotAllowed;
1268 Method method = (Method) $1;
1269 method.Block = (ToplevelBlock) $3;
1270 current_container.AddMethod (method);
1272 if (current_container.Kind == MemberKind.Interface && method.Block != null) {
1273 Report.Error (531, method.Location, "`{0}': interface members cannot have a definition", method.GetSignatureForError ());
1276 current_generic_method = null;
1277 current_local_parameters = null;
1279 if (RootContext.Documentation != null)
1280 Lexer.doc_state = XmlCommentState.Allowed;
1288 method_declaration_name OPEN_PARENS
1290 valid_param_mod = ParameterModifierType.All;
1292 opt_formal_parameter_list CLOSE_PARENS
1294 lexer.ConstraintsParsing = true;
1296 opt_type_parameter_constraints_clauses
1298 lexer.ConstraintsParsing = false;
1299 valid_param_mod = 0;
1300 MemberName name = (MemberName) $4;
1301 current_local_parameters = (ParametersCompiled) $7;
1303 GenericMethod generic = null;
1304 if (name.TypeArguments != null) {
1305 generic = new GenericMethod (current_namespace, current_class, name,
1306 (FullNamedExpression) $3, current_local_parameters);
1308 generic.SetParameterInfo ((List<Constraints>) $10);
1309 } else if ($10 != null) {
1310 Report.Error (80, GetLocation ($10),
1311 "Constraints are not allowed on non-generic declarations");
1314 Method method = new Method (current_class, generic, (FullNamedExpression) $3, (Modifiers) $2,
1315 name, current_local_parameters, (Attributes) $1);
1317 if ($10 != null && ((method.ModFlags & Modifiers.OVERRIDE) != 0 || method.IsExplicitImpl)) {
1318 Report.Error (460, method.Location,
1319 "`{0}': Cannot specify constraints for overrides and explicit interface implementation methods",
1320 method.GetSignatureForError ());
1323 current_generic_method = generic;
1325 if (RootContext.Documentation != null)
1326 method.DocComment = Lexer.consume_doc_comment ();
1333 VOID method_declaration_name
1336 valid_param_mod = ParameterModifierType.All;
1338 opt_formal_parameter_list CLOSE_PARENS
1340 lexer.ConstraintsParsing = true;
1342 opt_type_parameter_constraints_clauses
1344 lexer.ConstraintsParsing = false;
1345 valid_param_mod = 0;
1347 MemberName name = (MemberName) $5;
1348 current_local_parameters = (ParametersCompiled) $8;
1350 if ($10 != null && name.TypeArguments == null)
1351 Report.Error (80, lexer.Location,
1352 "Constraints are not allowed on non-generic declarations");
1355 GenericMethod generic = null;
1356 if (name.TypeArguments != null) {
1357 generic = new GenericMethod (current_namespace, current_class, name,
1358 TypeManager.system_void_expr, current_local_parameters);
1360 generic.SetParameterInfo ((List<Constraints>) $11);
1363 var modifiers = (Modifiers) $2;
1366 const Modifiers invalid_partial_mod = Modifiers.AccessibilityMask | Modifiers.ABSTRACT | Modifiers.EXTERN |
1367 Modifiers.NEW | Modifiers.OVERRIDE | Modifiers.SEALED | Modifiers.VIRTUAL;
1369 if ((modifiers & invalid_partial_mod) != 0) {
1370 Report.Error (750, name.Location, "A partial method cannot define access modifier or " +
1371 "any of abstract, extern, new, override, sealed, or virtual modifiers");
1372 modifiers &= ~invalid_partial_mod;
1375 if ((current_class.ModFlags & Modifiers.PARTIAL) == 0) {
1376 Report.Error (751, name.Location, "A partial method must be declared within a " +
1377 "partial class or partial struct");
1380 modifiers |= Modifiers.PARTIAL | Modifiers.PRIVATE;
1382 method = new Method (current_class, generic, TypeManager.system_void_expr,
1383 modifiers, name, current_local_parameters, (Attributes) $1);
1385 current_generic_method = generic;
1387 if (RootContext.Documentation != null)
1388 method.DocComment = Lexer.consume_doc_comment ();
1395 modifiers method_declaration_name OPEN_PARENS opt_formal_parameter_list CLOSE_PARENS
1397 MemberName name = (MemberName) $5;
1398 Report.Error (1585, name.Location,
1399 "Member modifier `{0}' must precede the member type and name", ModifiersExtensions.Name ((Modifiers) $4));
1401 Method method = new Method (current_class, null, TypeManager.system_void_expr,
1402 0, name, (ParametersCompiled) $7, (Attributes) $1);
1404 current_local_parameters = (ParametersCompiled) $7;
1406 if (RootContext.Documentation != null)
1407 method.DocComment = Lexer.consume_doc_comment ();
1415 | SEMICOLON { $$ = null; }
1418 opt_formal_parameter_list
1419 : /* empty */ { $$ = ParametersCompiled.EmptyReadOnlyParameters; }
1420 | formal_parameter_list
1423 formal_parameter_list
1426 var pars_list = (List<Parameter>) $1;
1427 $$ = new ParametersCompiled (compiler, pars_list.ToArray ());
1429 | fixed_parameters COMMA parameter_array
1431 var pars_list = (List<Parameter>) $1;
1432 pars_list.Add ((Parameter) $3);
1434 $$ = new ParametersCompiled (compiler, pars_list.ToArray ());
1436 | fixed_parameters COMMA arglist_modifier
1438 var pars_list = (List<Parameter>) $1;
1439 pars_list.Add (new ArglistParameter (GetLocation ($3)));
1440 $$ = new ParametersCompiled (compiler, pars_list.ToArray (), true);
1442 | parameter_array COMMA error
1445 Report.Error (231, ((Parameter) $1).Location, "A params parameter must be the last parameter in a formal parameter list");
1447 $$ = new ParametersCompiled (compiler, new Parameter[] { (Parameter) $1 } );
1449 | fixed_parameters COMMA parameter_array COMMA error
1452 Report.Error (231, ((Parameter) $3).Location, "A params parameter must be the last parameter in a formal parameter list");
1454 var pars_list = (List<Parameter>) $1;
1455 pars_list.Add (new ArglistParameter (GetLocation ($3)));
1457 $$ = new ParametersCompiled (compiler, pars_list.ToArray (), true);
1459 | arglist_modifier COMMA error
1461 Report.Error (257, GetLocation ($1), "An __arglist parameter must be the last parameter in a formal parameter list");
1463 $$ = new ParametersCompiled (compiler, new Parameter [] { new ArglistParameter (GetLocation ($1)) }, true);
1465 | fixed_parameters COMMA ARGLIST COMMA error
1467 Report.Error (257, GetLocation ($3), "An __arglist parameter must be the last parameter in a formal parameter list");
1469 var pars_list = (List<Parameter>) $1;
1470 pars_list.Add (new ArglistParameter (GetLocation ($3)));
1472 $$ = new ParametersCompiled (compiler, pars_list.ToArray (), true);
1476 $$ = new ParametersCompiled (compiler, new Parameter[] { (Parameter) $1 } );
1480 $$ = new ParametersCompiled (compiler, new Parameter [] { new ArglistParameter (GetLocation ($1)) }, true);
1487 parameters_bucket.Clear ();
1488 Parameter p = (Parameter) $1;
1489 parameters_bucket.Add (p);
1491 default_parameter_used = p.HasDefaultValue;
1492 $$ = parameters_bucket;
1494 | fixed_parameters COMMA fixed_parameter
1496 var pars = (List<Parameter>) $1;
1497 Parameter p = (Parameter) $3;
1499 if (p.HasExtensionMethodModifier)
1500 Report.Error (1100, p.Location, "The parameter modifier `this' can only be used on the first parameter");
1501 else if (!p.HasDefaultValue && default_parameter_used)
1502 Report.Error (1737, p.Location, "Optional parameter cannot precede required parameters");
1504 default_parameter_used |= p.HasDefaultValue;
1513 opt_parameter_modifier
1517 var lt = (Tokenizer.LocatedToken) $4;
1518 $$ = new Parameter ((FullNamedExpression) $3, lt.Value, (Parameter.Modifier) $2, (Attributes) $1, lt.Location);
1521 opt_parameter_modifier
1523 IDENTIFIER OPEN_BRACKET CLOSE_BRACKET
1525 var lt = (Tokenizer.LocatedToken) $4;
1526 Report.Error (1552, lt.Location, "Array type specifier, [], must appear before parameter name");
1527 $$ = new Parameter ((FullNamedExpression) $3, lt.Value, (Parameter.Modifier) $2, (Attributes) $1, lt.Location);
1530 opt_parameter_modifier
1534 Location l = GetLocation ($4);
1535 CheckIdentifierToken (yyToken, l);
1536 $$ = new Parameter ((FullNamedExpression) $3, "NeedSomeGeneratorHere", (Parameter.Modifier) $2, (Attributes) $1, l);
1539 opt_parameter_modifier
1545 if (RootContext.Version <= LanguageVersion.V_3) {
1546 Report.FeatureIsNotAvailable (GetLocation ($5), "optional parameter");
1549 Parameter.Modifier mod = (Parameter.Modifier) $2;
1550 if (mod != Parameter.Modifier.NONE) {
1552 case Parameter.Modifier.REF:
1553 case Parameter.Modifier.OUT:
1554 Report.Error (1741, GetLocation ($2), "Cannot specify a default value for the `{0}' parameter",
1555 Parameter.GetModifierSignature (mod));
1558 case Parameter.Modifier.This:
1559 Report.Error (1743, GetLocation ($2), "Cannot specify a default value for the `{0}' parameter",
1560 Parameter.GetModifierSignature (mod));
1563 throw new NotImplementedException (mod.ToString ());
1566 mod = Parameter.Modifier.NONE;
1569 if ((valid_param_mod & ParameterModifierType.DefaultValue) == 0)
1570 Report.Error (1065, GetLocation ($6), "Optional parameter is not valid in this context");
1572 var lt = (Tokenizer.LocatedToken) $4;
1573 $$ = new Parameter ((FullNamedExpression) $3, lt.Value, mod, (Attributes) $1, lt.Location);
1575 ((Parameter) $$).DefaultValue = (Expression) $6;
1579 opt_parameter_modifier
1580 : /* empty */ { $$ = Parameter.Modifier.NONE; }
1581 | parameter_modifiers
1585 : parameter_modifier
1589 | parameter_modifiers parameter_modifier
1591 Parameter.Modifier p2 = (Parameter.Modifier)$2;
1592 Parameter.Modifier mod = (Parameter.Modifier)$1 | p2;
1593 if (((Parameter.Modifier)$1 & p2) == p2) {
1594 Error_DuplicateParameterModifier (lexer.Location, p2);
1596 switch (mod & ~Parameter.Modifier.This) {
1597 case Parameter.Modifier.REF:
1598 Report.Error (1101, lexer.Location, "The parameter modifiers `this' and `ref' cannot be used altogether");
1600 case Parameter.Modifier.OUT:
1601 Report.Error (1102, lexer.Location, "The parameter modifiers `this' and `out' cannot be used altogether");
1604 Report.Error (1108, lexer.Location, "A parameter cannot have specified more than one modifier");
1615 if ((valid_param_mod & ParameterModifierType.Ref) == 0)
1616 Error_ParameterModifierNotValid ("ref", GetLocation ($1));
1618 $$ = Parameter.Modifier.REF;
1622 if ((valid_param_mod & ParameterModifierType.Out) == 0)
1623 Error_ParameterModifierNotValid ("out", GetLocation ($1));
1625 $$ = Parameter.Modifier.OUT;
1629 if ((valid_param_mod & ParameterModifierType.This) == 0)
1630 Error_ParameterModifierNotValid ("this", GetLocation ($1));
1632 if (RootContext.Version <= LanguageVersion.ISO_2)
1633 Report.FeatureIsNotAvailable (GetLocation ($1), "extension methods");
1635 $$ = Parameter.Modifier.This;
1640 : opt_attributes params_modifier type IDENTIFIER
1642 var lt = (Tokenizer.LocatedToken) $4;
1643 $$ = new ParamsParameter ((FullNamedExpression) $3, lt.Value, (Attributes) $1, lt.Location);
1645 | opt_attributes params_modifier type IDENTIFIER ASSIGN constant_expression
1647 Report.Error (1751, GetLocation ($2), "Cannot specify a default value for a parameter array");
1649 var lt = (Tokenizer.LocatedToken) $4;
1650 $$ = new ParamsParameter ((FullNamedExpression) $3, lt.Value, (Attributes) $1, lt.Location);
1652 | opt_attributes params_modifier type error {
1653 CheckIdentifierToken (yyToken, GetLocation ($4));
1661 if ((valid_param_mod & ParameterModifierType.Params) == 0)
1662 Report.Error (1670, (GetLocation ($1)), "The `params' modifier is not allowed in current context");
1664 | PARAMS parameter_modifier
1666 Parameter.Modifier mod = (Parameter.Modifier)$2;
1667 if ((mod & Parameter.Modifier.This) != 0) {
1668 Report.Error (1104, GetLocation ($1), "The parameter modifiers `this' and `params' cannot be used altogether");
1670 Report.Error (1611, GetLocation ($1), "The params parameter cannot be declared as ref or out");
1673 | PARAMS params_modifier
1675 Error_DuplicateParameterModifier (GetLocation ($1), Parameter.Modifier.PARAMS);
1682 if ((valid_param_mod & ParameterModifierType.Arglist) == 0)
1683 Report.Error (1669, GetLocation ($1), "__arglist is not valid in this context");
1687 property_declaration
1691 member_declaration_name
1693 if (RootContext.Documentation != null)
1694 tmpComment = Lexer.consume_doc_comment ();
1698 implicit_value_parameter_type = (FullNamedExpression) $3;
1699 lexer.PropertyParsing = true;
1701 accessor_declarations
1703 lexer.PropertyParsing = false;
1704 has_get = has_set = false;
1709 Accessors accessors = (Accessors) $8;
1710 Accessor get_block = accessors != null ? accessors.get_or_add : null;
1711 Accessor set_block = accessors != null ? accessors.set_or_remove : null;
1712 bool order = accessors != null ? accessors.declared_in_reverse : false;
1714 MemberName name = (MemberName) $4;
1715 FullNamedExpression ptype = (FullNamedExpression) $3;
1717 prop = new Property (current_class, ptype, (Modifiers) $2,
1718 name, (Attributes) $1, get_block, set_block, order, current_block);
1720 if (ptype == TypeManager.system_void_expr)
1721 Report.Error (547, name.Location, "`{0}': property or indexer cannot have void type", prop.GetSignatureForError ());
1723 if (accessors == null)
1724 Report.Error (548, prop.Location, "`{0}': property or indexer must have at least one accessor", prop.GetSignatureForError ());
1726 if (current_container.Kind == MemberKind.Interface) {
1727 if (prop.Get.Block != null)
1728 Report.Error (531, prop.Location, "`{0}.get': interface members cannot have a definition", prop.GetSignatureForError ());
1730 if (prop.Set.Block != null)
1731 Report.Error (531, prop.Location, "`{0}.set': interface members cannot have a definition", prop.GetSignatureForError ());
1734 current_container.AddProperty (prop);
1735 implicit_value_parameter_type = null;
1737 if (RootContext.Documentation != null)
1738 prop.DocComment = ConsumeStoredComment ();
1743 accessor_declarations
1744 : get_accessor_declaration
1746 $$ = new Accessors ((Accessor) $1, null);
1748 | get_accessor_declaration accessor_declarations
1750 Accessors accessors = (Accessors) $2;
1751 accessors.get_or_add = (Accessor) $1;
1754 | set_accessor_declaration
1756 $$ = new Accessors (null, (Accessor) $1);
1758 | set_accessor_declaration accessor_declarations
1760 Accessors accessors = (Accessors) $2;
1761 accessors.set_or_remove = (Accessor) $1;
1762 accessors.declared_in_reverse = true;
1767 if (yyToken == Token.CLOSE_BRACE) {
1770 if (yyToken == Token.SEMICOLON)
1771 Report.Error (1597, lexer.Location, "Semicolon after method or accessor block is not valid");
1773 Report.Error (1014, GetLocation ($1), "A get or set accessor expected");
1775 $$ = new Accessors (null, null);
1780 get_accessor_declaration
1781 : opt_attributes opt_modifiers GET
1783 // If this is not the case, then current_local_parameters has already
1784 // been set in indexer_declaration
1785 if (parsing_indexer == false)
1786 current_local_parameters = ParametersCompiled.EmptyReadOnlyParameters;
1788 current_local_parameters = indexer_parameters;
1789 lexer.PropertyParsing = false;
1794 Report.Error (1007, GetLocation ($3), "Property accessor already defined");
1797 Accessor accessor = new Accessor ((ToplevelBlock) $5, (Modifiers) $2, (Attributes) $1, current_local_parameters, GetLocation ($3));
1799 current_local_parameters = null;
1800 lexer.PropertyParsing = true;
1802 if (RootContext.Documentation != null)
1803 if (Lexer.doc_state == XmlCommentState.Error)
1804 Lexer.doc_state = XmlCommentState.NotAllowed;
1810 set_accessor_declaration
1811 : opt_attributes opt_modifiers SET
1813 Parameter implicit_value_parameter = new Parameter (
1814 implicit_value_parameter_type, "value",
1815 Parameter.Modifier.NONE, null, GetLocation ($3));
1817 if (!parsing_indexer) {
1818 current_local_parameters = new ParametersCompiled (compiler, new Parameter [] { implicit_value_parameter });
1820 current_local_parameters = ParametersCompiled.MergeGenerated (compiler,
1821 indexer_parameters, true, implicit_value_parameter, null);
1824 lexer.PropertyParsing = false;
1829 Report.Error (1007, GetLocation ($3), "Property accessor already defined");
1832 Accessor accessor = new Accessor ((ToplevelBlock) $5, (Modifiers) $2, (Attributes) $1, current_local_parameters, GetLocation ($3));
1834 current_local_parameters = null;
1835 lexer.PropertyParsing = true;
1837 if (RootContext.Documentation != null
1838 && Lexer.doc_state == XmlCommentState.Error)
1839 Lexer.doc_state = XmlCommentState.NotAllowed;
1853 Error_SyntaxError (1043, yyToken, "Invalid accessor body");
1858 interface_declaration
1864 lexer.ConstraintsParsing = true;
1866 type_declaration_name
1868 MemberName name = MakeName ((MemberName) $6);
1869 push_current_class (new Interface (current_namespace, current_class, name, (Modifiers) $2, (Attributes) $1), $3);
1872 opt_type_parameter_constraints_clauses
1874 lexer.ConstraintsParsing = false;
1876 current_class.SetParameterInfo ((List<Constraints>) $9);
1878 if (RootContext.Documentation != null) {
1879 current_container.DocComment = Lexer.consume_doc_comment ();
1880 Lexer.doc_state = XmlCommentState.Allowed;
1885 --lexer.parsing_declaration;
1886 if (RootContext.Documentation != null)
1887 Lexer.doc_state = XmlCommentState.Allowed;
1891 $$ = pop_current_class ();
1893 | opt_attributes opt_modifiers opt_partial INTERFACE error {
1894 CheckIdentifierToken (yyToken, GetLocation ($5));
1900 opt_interface_member_declarations
1904 opt_interface_member_declarations
1906 | interface_member_declarations
1909 interface_member_declarations
1910 : interface_member_declaration
1911 | interface_member_declarations interface_member_declaration
1914 interface_member_declaration
1915 : constant_declaration
1917 Report.Error (525, GetLocation ($1), "Interfaces cannot contain fields or constants");
1921 Report.Error (525, GetLocation ($1), "Interfaces cannot contain fields or constants");
1923 | method_declaration
1924 | property_declaration
1926 | indexer_declaration
1927 | operator_declaration
1929 Report.Error (567, GetLocation ($1), "Interfaces cannot contain operators");
1931 | constructor_declaration
1933 Report.Error (526, GetLocation ($1), "Interfaces cannot contain contructors");
1937 Report.Error (524, GetLocation ($1), "Interfaces cannot declare classes, structs, interfaces, delegates, or enumerations");
1941 operator_declaration
1942 : opt_attributes opt_modifiers operator_declarator
1950 OperatorDeclaration decl = (OperatorDeclaration) $3;
1951 Operator op = new Operator (
1952 current_class, decl.optype, decl.ret_type, (Modifiers) $2,
1953 current_local_parameters,
1954 (ToplevelBlock) $5, (Attributes) $1, decl.location);
1956 if (RootContext.Documentation != null) {
1957 op.DocComment = tmpComment;
1958 Lexer.doc_state = XmlCommentState.Allowed;
1961 // Note again, checking is done in semantic analysis
1962 current_container.AddOperator (op);
1964 current_local_parameters = null;
1970 | SEMICOLON { $$ = null; }
1974 : type_expression_or_array
1977 Report.Error (590, GetLocation ($1), "User-defined operators cannot return void");
1978 $$ = TypeManager.system_void_expr;
1983 : operator_type OPERATOR overloadable_operator OPEN_PARENS
1985 valid_param_mod = ParameterModifierType.DefaultValue;
1987 opt_formal_parameter_list CLOSE_PARENS
1989 valid_param_mod = 0;
1991 Location loc = GetLocation ($2);
1992 Operator.OpType op = (Operator.OpType) $3;
1993 current_local_parameters = (ParametersCompiled)$6;
1995 int p_count = current_local_parameters.Count;
1997 if (op == Operator.OpType.Addition)
1998 op = Operator.OpType.UnaryPlus;
1999 else if (op == Operator.OpType.Subtraction)
2000 op = Operator.OpType.UnaryNegation;
2003 if (IsUnaryOperator (op)) {
2005 Report.Error (1020, loc, "Overloadable binary operator expected");
2006 } else if (p_count != 1) {
2007 Report.Error (1535, loc, "Overloaded unary operator `{0}' takes one parameter",
2008 Operator.GetName (op));
2012 Report.Error (1534, loc, "Overloaded binary operator `{0}' takes two parameters",
2013 Operator.GetName (op));
2014 } else if (p_count != 2) {
2015 Report.Error (1019, loc, "Overloadable unary operator expected");
2019 if (RootContext.Documentation != null) {
2020 tmpComment = Lexer.consume_doc_comment ();
2021 Lexer.doc_state = XmlCommentState.NotAllowed;
2024 $$ = new OperatorDeclaration (op, (FullNamedExpression) $1, loc);
2026 | conversion_operator_declarator
2029 overloadable_operator
2031 : BANG { $$ = Operator.OpType.LogicalNot; }
2032 | TILDE { $$ = Operator.OpType.OnesComplement; }
2033 | OP_INC { $$ = Operator.OpType.Increment; }
2034 | OP_DEC { $$ = Operator.OpType.Decrement; }
2035 | TRUE { $$ = Operator.OpType.True; }
2036 | FALSE { $$ = Operator.OpType.False; }
2037 // Unary and binary:
2038 | PLUS { $$ = Operator.OpType.Addition; }
2039 | MINUS { $$ = Operator.OpType.Subtraction; }
2041 | STAR { $$ = Operator.OpType.Multiply; }
2042 | DIV { $$ = Operator.OpType.Division; }
2043 | PERCENT { $$ = Operator.OpType.Modulus; }
2044 | BITWISE_AND { $$ = Operator.OpType.BitwiseAnd; }
2045 | BITWISE_OR { $$ = Operator.OpType.BitwiseOr; }
2046 | CARRET { $$ = Operator.OpType.ExclusiveOr; }
2047 | OP_SHIFT_LEFT { $$ = Operator.OpType.LeftShift; }
2048 | OP_SHIFT_RIGHT { $$ = Operator.OpType.RightShift; }
2049 | OP_EQ { $$ = Operator.OpType.Equality; }
2050 | OP_NE { $$ = Operator.OpType.Inequality; }
2051 | OP_GT { $$ = Operator.OpType.GreaterThan; }
2052 | OP_LT { $$ = Operator.OpType.LessThan; }
2053 | OP_GE { $$ = Operator.OpType.GreaterThanOrEqual; }
2054 | OP_LE { $$ = Operator.OpType.LessThanOrEqual; }
2057 conversion_operator_declarator
2058 : IMPLICIT OPERATOR type OPEN_PARENS
2060 valid_param_mod = ParameterModifierType.DefaultValue;
2062 opt_formal_parameter_list CLOSE_PARENS
2064 valid_param_mod = 0;
2066 Location loc = GetLocation ($2);
2067 current_local_parameters = (ParametersCompiled)$6;
2069 if (RootContext.Documentation != null) {
2070 tmpComment = Lexer.consume_doc_comment ();
2071 Lexer.doc_state = XmlCommentState.NotAllowed;
2074 $$ = new OperatorDeclaration (Operator.OpType.Implicit, (FullNamedExpression) $3, loc);
2076 | EXPLICIT OPERATOR type OPEN_PARENS
2078 valid_param_mod = ParameterModifierType.DefaultValue;
2080 opt_formal_parameter_list CLOSE_PARENS
2082 valid_param_mod = 0;
2084 Location loc = GetLocation ($2);
2085 current_local_parameters = (ParametersCompiled)$6;
2087 if (RootContext.Documentation != null) {
2088 tmpComment = Lexer.consume_doc_comment ();
2089 Lexer.doc_state = XmlCommentState.NotAllowed;
2092 $$ = new OperatorDeclaration (Operator.OpType.Explicit, (FullNamedExpression) $3, loc);
2096 Error_SyntaxError (yyToken);
2097 current_local_parameters = ParametersCompiled.EmptyReadOnlyParameters;
2098 $$ = new OperatorDeclaration (Operator.OpType.Implicit, null, GetLocation ($1));
2102 Error_SyntaxError (yyToken);
2103 current_local_parameters = ParametersCompiled.EmptyReadOnlyParameters;
2104 $$ = new OperatorDeclaration (Operator.OpType.Explicit, null, GetLocation ($1));
2108 constructor_declaration
2109 : constructor_declarator
2112 Constructor c = (Constructor) $1;
2113 c.Block = (ToplevelBlock) $2;
2115 if (RootContext.Documentation != null)
2116 c.DocComment = ConsumeStoredComment ();
2118 current_container.AddConstructor (c);
2120 current_local_parameters = null;
2121 if (RootContext.Documentation != null)
2122 Lexer.doc_state = XmlCommentState.Allowed;
2126 constructor_declarator
2131 if (RootContext.Documentation != null) {
2132 tmpComment = Lexer.consume_doc_comment ();
2133 Lexer.doc_state = XmlCommentState.Allowed;
2136 valid_param_mod = ParameterModifierType.All;
2138 OPEN_PARENS opt_formal_parameter_list CLOSE_PARENS
2140 valid_param_mod = 0;
2141 current_local_parameters = (ParametersCompiled) $6;
2144 // start block here, so possible anonymous methods inside
2145 // constructor initializer can get correct parent block
2147 start_block (lexer.Location);
2149 opt_constructor_initializer
2151 var lt = (Tokenizer.LocatedToken) $3;
2152 var mods = (Modifiers) $2;
2153 ConstructorInitializer ci = (ConstructorInitializer) $9;
2155 Constructor c = new Constructor (current_class, lt.Value, mods,
2156 (Attributes) $1, current_local_parameters, ci, lt.Location);
2158 if (lt.Value != current_container.MemberName.Name) {
2159 Report.Error (1520, c.Location, "Class, struct, or interface method must have a return type");
2160 } else if ((mods & Modifiers.STATIC) != 0) {
2161 if ((mods & Modifiers.AccessibilityMask) != 0){
2162 Report.Error (515, c.Location,
2163 "`{0}': static constructor cannot have an access modifier",
2164 c.GetSignatureForError ());
2167 Report.Error (514, c.Location,
2168 "`{0}': static constructor cannot have an explicit `this' or `base' constructor call",
2169 c.GetSignatureForError ());
2180 | SEMICOLON { current_block = null; $$ = null; }
2183 opt_constructor_initializer
2185 | constructor_initializer
2188 constructor_initializer
2189 : COLON BASE OPEN_PARENS
2191 ++lexer.parsing_block;
2193 opt_argument_list CLOSE_PARENS
2195 --lexer.parsing_block;
2196 $$ = new ConstructorBaseInitializer ((Arguments) $5, GetLocation ($2));
2198 | COLON THIS OPEN_PARENS
2200 ++lexer.parsing_block;
2202 opt_argument_list CLOSE_PARENS
2204 --lexer.parsing_block;
2205 $$ = new ConstructorThisInitializer ((Arguments) $5, GetLocation ($2));
2208 Report.Error (1018, GetLocation ($1), "Keyword `this' or `base' expected");
2213 destructor_declaration
2214 : opt_attributes opt_modifiers TILDE
2216 if (RootContext.Documentation != null) {
2217 tmpComment = Lexer.consume_doc_comment ();
2218 Lexer.doc_state = XmlCommentState.NotAllowed;
2221 current_local_parameters = ParametersCompiled.EmptyReadOnlyParameters;
2223 IDENTIFIER OPEN_PARENS CLOSE_PARENS method_body
2225 var lt = (Tokenizer.LocatedToken) $5;
2226 if (lt.Value != current_container.MemberName.Name){
2227 Report.Error (574, lt.Location, "Name of destructor must match name of class");
2228 } else if (current_container.Kind != MemberKind.Class){
2229 Report.Error (575, lt.Location, "Only class types can contain destructor");
2231 Destructor d = new Destructor (current_class, (Modifiers) $2,
2232 ParametersCompiled.EmptyReadOnlyParameters, (Attributes) $1, lt.Location);
2233 if (RootContext.Documentation != null)
2234 d.DocComment = ConsumeStoredComment ();
2236 d.Block = (ToplevelBlock) $8;
2237 current_container.AddMethod (d);
2240 current_local_parameters = null;
2247 EVENT type variable_declarators SEMICOLON
2249 foreach (VariableMemberDeclaration var in (List<object>) $5) {
2251 EventField e = new EventField (
2252 current_class, (FullNamedExpression) $4, (Modifiers) $2, var.MemberName, (Attributes) $1);
2254 e.Initializer = var.GetInitializer ((FullNamedExpression) $4);
2255 if (current_container.Kind == MemberKind.Interface && e.Initializer != null) {
2256 Report.Error (68, e.Location, "`{0}': event in interface cannot have initializer", e.GetSignatureForError ());
2259 if (var.MemberName.Left != null) {
2260 Report.Error (71, e.Location,
2261 "`{0}': An explicit interface implementation of an event must use property syntax",
2262 e.GetSignatureForError ());
2265 current_container.AddEvent (e);
2267 if (RootContext.Documentation != null) {
2268 e.DocComment = Lexer.consume_doc_comment ();
2269 Lexer.doc_state = XmlCommentState.Allowed;
2275 EVENT type member_declaration_name
2278 implicit_value_parameter_type = (FullNamedExpression) $4;
2279 current_local_parameters = new ParametersCompiled (compiler,
2280 new Parameter (implicit_value_parameter_type, "value",
2281 Parameter.Modifier.NONE, null, GetLocation ($3)));
2283 lexer.EventParsing = true;
2285 event_accessor_declarations
2287 lexer.EventParsing = false;
2291 MemberName name = (MemberName) $5;
2293 if (current_container.Kind == MemberKind.Interface) {
2294 Report.Error (69, GetLocation ($3), "Event in interface cannot have add or remove accessors");
2295 $8 = new Accessors (null, null);
2296 } else if ($8 == null) {
2297 Report.Error (65, GetLocation ($3), "`{0}.{1}': event property must have both add and remove accessors",
2298 current_container.GetSignatureForError (), name.GetSignatureForError ());
2299 $8 = new Accessors (null, null);
2302 Accessors accessors = (Accessors) $8;
2304 if (accessors.get_or_add == null || accessors.set_or_remove == null)
2305 // CS0073 is already reported, so no CS0065 here.
2308 Event e = new EventProperty (
2309 current_class, (FullNamedExpression) $4, (Modifiers) $2, name,
2310 (Attributes) $1, accessors.get_or_add, accessors.set_or_remove);
2311 if (RootContext.Documentation != null) {
2312 e.DocComment = Lexer.consume_doc_comment ();
2313 Lexer.doc_state = XmlCommentState.Allowed;
2316 current_container.AddEvent (e);
2317 implicit_value_parameter_type = null;
2319 current_local_parameters = null;
2321 | opt_attributes opt_modifiers EVENT type member_declaration_name error
2323 MemberName mn = (MemberName) $5;
2324 if (mn.Left != null)
2325 Report.Error (71, mn.Location, "An explicit interface implementation of an event must use property syntax");
2327 if (RootContext.Documentation != null)
2328 Lexer.doc_state = XmlCommentState.Allowed;
2330 Error_SyntaxError (yyToken);
2335 event_accessor_declarations
2336 : add_accessor_declaration remove_accessor_declaration
2338 $$ = new Accessors ((Accessor) $1, (Accessor) $2);
2340 | remove_accessor_declaration add_accessor_declaration
2342 Accessors accessors = new Accessors ((Accessor) $2, (Accessor) $1);
2343 accessors.declared_in_reverse = true;
2346 | add_accessor_declaration { $$ = null; }
2347 | remove_accessor_declaration { $$ = null; }
2350 Report.Error (1055, GetLocation ($1), "An add or remove accessor expected");
2356 add_accessor_declaration
2357 : opt_attributes ADD
2359 lexer.EventParsing = false;
2363 Accessor accessor = new Accessor ((ToplevelBlock) $4, 0, (Attributes) $1, null, GetLocation ($2));
2364 lexer.EventParsing = true;
2367 | opt_attributes ADD error {
2368 Report.Error (73, GetLocation ($2), "An add or remove accessor must have a body");
2371 | opt_attributes modifiers ADD {
2372 Report.Error (1609, GetLocation ($3), "Modifiers cannot be placed on event accessor declarations");
2377 remove_accessor_declaration
2378 : opt_attributes REMOVE
2380 lexer.EventParsing = false;
2384 $$ = new Accessor ((ToplevelBlock) $4, 0, (Attributes) $1, null, GetLocation ($2));
2385 lexer.EventParsing = true;
2387 | opt_attributes REMOVE error {
2388 Report.Error (73, GetLocation ($2), "An add or remove accessor must have a body");
2391 | opt_attributes modifiers REMOVE {
2392 Report.Error (1609, GetLocation ($3), "Modifiers cannot be placed on event accessor declarations");
2398 : opt_attributes opt_modifiers
2399 member_type indexer_declaration_name OPEN_BRACKET
2401 valid_param_mod = ParameterModifierType.Params | ParameterModifierType.DefaultValue;
2403 opt_formal_parameter_list CLOSE_BRACKET
2406 valid_param_mod = 0;
2407 implicit_value_parameter_type = (FullNamedExpression) $3;
2408 indexer_parameters = (ParametersCompiled) $7;
2410 if (indexer_parameters.IsEmpty) {
2411 Report.Error (1551, GetLocation ($5), "Indexers must have at least one parameter");
2414 if (RootContext.Documentation != null) {
2415 tmpComment = Lexer.consume_doc_comment ();
2416 Lexer.doc_state = XmlCommentState.Allowed;
2419 lexer.PropertyParsing = true;
2420 parsing_indexer = true;
2423 accessor_declarations
2425 lexer.PropertyParsing = false;
2426 has_get = has_set = false;
2427 parsing_indexer = false;
2431 Accessors accessors = (Accessors) $11;
2432 Accessor get_block = accessors != null ? accessors.get_or_add : null;
2433 Accessor set_block = accessors != null ? accessors.set_or_remove : null;
2434 bool order = accessors != null ? accessors.declared_in_reverse : false;
2436 Indexer indexer = new Indexer (current_class, (FullNamedExpression) $3,
2437 (MemberName)$4, (Modifiers) $2, (ParametersCompiled) $7, (Attributes) $1,
2438 get_block, set_block, order);
2440 if ($3 == TypeManager.system_void_expr)
2441 Report.Error (620, GetLocation ($3), "`{0}': indexer return type cannot be `void'", indexer.GetSignatureForError ());
2443 if (accessors == null)
2444 Report.Error (548, indexer.Location, "`{0}': property or indexer must have at least one accessor", indexer.GetSignatureForError ());
2446 if (current_container.Kind == MemberKind.Interface) {
2447 if (indexer.Get.Block != null)
2448 Report.Error (531, indexer.Location, "`{0}.get': interface members cannot have a definition", indexer.GetSignatureForError ());
2450 if (indexer.Set.Block != null)
2451 Report.Error (531, indexer.Location, "`{0}.set': interface members cannot have a definition", indexer.GetSignatureForError ());
2454 if (RootContext.Documentation != null)
2455 indexer.DocComment = ConsumeStoredComment ();
2457 current_container.AddIndexer (indexer);
2459 current_local_parameters = null;
2460 implicit_value_parameter_type = null;
2461 indexer_parameters = null;
2468 ENUM type_declaration_name
2470 if (RootContext.Documentation != null)
2471 enumTypeComment = Lexer.consume_doc_comment ();
2476 MemberName name = (MemberName) $4;
2477 if (name.IsGeneric) {
2478 Report.Error (1675, name.Location, "Enums cannot have type parameters");
2481 name = MakeName (name);
2482 Enum e = new Enum (current_namespace, current_class, (TypeExpr) $5, (Modifiers) $2,
2483 name, (Attributes) $1);
2485 if (RootContext.Documentation != null)
2486 e.DocComment = enumTypeComment;
2489 EnumMember em = null;
2490 foreach (VariableDeclaration ev in (IList<VariableDeclaration>) $7) {
2491 em = new EnumMember (
2492 e, em, ev.identifier, ev.GetInitializer ((FullNamedExpression) $5),
2493 ev.OptAttributes, ev.Location);
2495 // if (RootContext.Documentation != null)
2496 em.DocComment = ev.DocComment;
2498 e.AddEnumMember (em);
2500 if (RootContext.EvalMode)
2501 undo.AddTypeContainer (current_container, e);
2503 current_container.AddTypeContainer (e);
2513 $$ = TypeManager.system_int32_expr;
2517 if ($2 != TypeManager.system_int32_expr && $2 != TypeManager.system_uint32_expr &&
2518 $2 != TypeManager.system_int64_expr && $2 != TypeManager.system_uint64_expr &&
2519 $2 != TypeManager.system_int16_expr && $2 != TypeManager.system_uint16_expr &&
2520 $2 != TypeManager.system_byte_expr && $2 != TypeManager.system_sbyte_expr) {
2521 Enum.Error_1008 (GetLocation ($2), Report);
2522 $2 = TypeManager.system_int32_expr;
2529 Error_TypeExpected (GetLocation ($1));
2530 $$ = TypeManager.system_int32_expr;
2537 if (RootContext.Documentation != null)
2538 Lexer.doc_state = XmlCommentState.Allowed;
2540 opt_enum_member_declarations
2542 // here will be evaluated after CLOSE_BLACE is consumed.
2543 if (RootContext.Documentation != null)
2544 Lexer.doc_state = XmlCommentState.Allowed;
2552 opt_enum_member_declarations
2553 : /* empty */ { $$ = new VariableDeclaration [0]; }
2554 | enum_member_declarations opt_comma { $$ = $1; }
2557 enum_member_declarations
2558 : enum_member_declaration
2560 var l = new List<VariableDeclaration> (4);
2561 l.Add ((VariableDeclaration) $1);
2564 | enum_member_declarations COMMA enum_member_declaration
2566 var l = (List<VariableDeclaration>) $1;
2567 l.Add ((VariableDeclaration) $3);
2572 enum_member_declaration
2573 : opt_attributes IDENTIFIER
2575 VariableDeclaration vd = new VariableDeclaration (
2576 (Tokenizer.LocatedToken) $2, null, (Attributes) $1);
2578 if (RootContext.Documentation != null) {
2579 vd.DocComment = Lexer.consume_doc_comment ();
2580 Lexer.doc_state = XmlCommentState.Allowed;
2585 | opt_attributes IDENTIFIER
2587 ++lexer.parsing_block;
2588 if (RootContext.Documentation != null) {
2589 tmpComment = Lexer.consume_doc_comment ();
2590 Lexer.doc_state = XmlCommentState.NotAllowed;
2593 ASSIGN constant_expression
2595 --lexer.parsing_block;
2596 VariableDeclaration vd = new VariableDeclaration (
2597 (Tokenizer.LocatedToken) $2, (Expression) $5, (Attributes) $1);
2599 if (RootContext.Documentation != null)
2600 vd.DocComment = ConsumeStoredComment ();
2606 delegate_declaration
2610 member_type type_declaration_name
2613 valid_param_mod = ParameterModifierType.Ref | ParameterModifierType.Out | ParameterModifierType.Params | ParameterModifierType.DefaultValue;
2615 opt_formal_parameter_list CLOSE_PARENS
2617 valid_param_mod = 0;
2619 MemberName name = MakeName ((MemberName) $5);
2620 ParametersCompiled p = (ParametersCompiled) $8;
2622 Delegate del = new Delegate (current_namespace, current_class, (FullNamedExpression) $4,
2623 (Modifiers) $2, name, p, (Attributes) $1);
2625 if (RootContext.Documentation != null) {
2626 del.DocComment = Lexer.consume_doc_comment ();
2627 Lexer.doc_state = XmlCommentState.Allowed;
2630 current_container.AddDelegate (del);
2631 current_delegate = del;
2632 lexer.ConstraintsParsing = true;
2634 opt_type_parameter_constraints_clauses
2636 lexer.ConstraintsParsing = false;
2640 current_delegate.SetParameterInfo ((List<Constraints>) $11);
2641 $$ = current_delegate;
2643 current_delegate = null;
2654 if (RootContext.MetadataCompatibilityVersion < MetadataVersion.v2)
2655 Report.FeatureIsNotSupported (GetLocation ($1), "nullable types");
2656 else if (RootContext.Version < LanguageVersion.ISO_2)
2657 Report.FeatureIsNotAvailable (GetLocation ($1), "nullable types");
2663 namespace_or_type_name
2665 | qualified_alias_member IDENTIFIER opt_type_argument_list
2667 var lt1 = (Tokenizer.LocatedToken) $1;
2668 var lt2 = (Tokenizer.LocatedToken) $2;
2670 $$ = new MemberName (lt1.Value, lt2.Value, (TypeArguments) $3, lt1.Location);
2676 | namespace_or_type_name DOT IDENTIFIER opt_type_argument_list
2678 var lt = (Tokenizer.LocatedToken) $3;
2679 $$ = new MemberName ((MemberName) $1, lt.Value, (TypeArguments) $4, lt.Location);
2684 : IDENTIFIER opt_type_argument_list
2686 var lt = (Tokenizer.LocatedToken) $1;
2687 $$ = new MemberName (lt.Value, (TypeArguments)$2, lt.Location);
2692 // Generics arguments (any type, without attributes)
2694 opt_type_argument_list
2695 : /* empty */ { $$ = null; }
2696 | OP_GENERICS_LT type_arguments OP_GENERICS_GT
2698 if (RootContext.MetadataCompatibilityVersion < MetadataVersion.v2)
2699 Report.FeatureIsNotSupported (GetLocation ($1), "generics");
2700 else if (RootContext.Version < LanguageVersion.ISO_2)
2701 Report.FeatureIsNotAvailable (GetLocation ($1), "generics");
2705 | OP_GENERICS_LT error
2707 Error_TypeExpected (lexer.Location);
2708 $$ = new TypeArguments ();
2715 TypeArguments type_args = new TypeArguments ();
2716 type_args.Add ((FullNamedExpression) $1);
2719 | type_arguments COMMA type
2721 TypeArguments type_args = (TypeArguments) $1;
2722 type_args.Add ((FullNamedExpression) $3);
2728 // Generics parameters (identifiers only, with attributes), used in type or method declarations
2730 type_declaration_name
2733 lexer.parsing_generic_declaration = true;
2735 opt_type_parameter_list
2737 lexer.parsing_generic_declaration = false;
2738 var lt = (Tokenizer.LocatedToken) $1;
2739 $$ = new MemberName (lt.Value, (TypeArguments)$3, lt.Location);
2743 member_declaration_name
2744 : method_declaration_name
2746 MemberName mn = (MemberName)$1;
2747 if (mn.TypeArguments != null)
2748 syntax_error (mn.Location, string.Format ("Member `{0}' cannot declare type arguments",
2749 mn.GetSignatureForError ()));
2753 method_declaration_name
2754 : type_declaration_name
2755 | explicit_interface IDENTIFIER opt_type_parameter_list
2757 lexer.parsing_generic_declaration = false;
2758 var lt = (Tokenizer.LocatedToken) $2;
2759 $$ = new MemberName ((MemberName) $1, lt.Value, (TypeArguments) $3, lt.Location);
2763 indexer_declaration_name
2766 lexer.parsing_generic_declaration = false;
2767 $$ = new MemberName (TypeContainer.DefaultIndexerName, GetLocation ($1));
2769 | explicit_interface THIS
2771 lexer.parsing_generic_declaration = false;
2772 $$ = new MemberName ((MemberName) $1, TypeContainer.DefaultIndexerName, null, GetLocation ($1));
2777 : IDENTIFIER opt_type_argument_list DOT
2779 var lt = (Tokenizer.LocatedToken) $1;
2780 $$ = new MemberName (lt.Value, (TypeArguments) $2, lt.Location);
2782 | qualified_alias_member IDENTIFIER opt_type_argument_list DOT
2784 var lt1 = (Tokenizer.LocatedToken) $1;
2785 var lt2 = (Tokenizer.LocatedToken) $2;
2787 $$ = new MemberName (lt1.Value, lt2.Value, (TypeArguments) $3, lt1.Location);
2789 | explicit_interface IDENTIFIER opt_type_argument_list DOT
2791 var lt = (Tokenizer.LocatedToken) $2;
2792 $$ = new MemberName ((MemberName) $1, lt.Value, (TypeArguments) $3, lt.Location);
2796 opt_type_parameter_list
2797 : /* empty */ { $$ = null; }
2798 | OP_GENERICS_LT_DECL type_parameters OP_GENERICS_GT
2800 if (RootContext.MetadataCompatibilityVersion < MetadataVersion.v2)
2801 Report.FeatureIsNotSupported (GetLocation ($1), "generics");
2802 else if (RootContext.Version < LanguageVersion.ISO_2)
2803 Report.FeatureIsNotAvailable (GetLocation ($1), "generics");
2812 TypeArguments type_args = new TypeArguments ();
2813 type_args.Add ((FullNamedExpression)$1);
2816 | type_parameters COMMA type_parameter
2818 TypeArguments type_args = (TypeArguments) $1;
2819 type_args.Add ((FullNamedExpression)$3);
2825 : opt_attributes opt_type_parameter_variance IDENTIFIER
2827 var lt = (Tokenizer.LocatedToken)$3;
2828 $$ = new TypeParameterName (lt.Value, (Attributes)$1, (Variance) $2, lt.Location);
2832 if (GetTokenName (yyToken) == "type")
2833 Report.Error (81, GetLocation ($1), "Type parameter declaration must be an identifier not a type");
2835 Error_SyntaxError (yyToken);
2837 $$ = new TypeParameterName ("", null, lexer.Location);
2842 // All types where void is allowed
2845 : type_expression_or_array
2848 $$ = TypeManager.system_void_expr;
2855 lexer.parsing_generic_declaration = true;
2860 // A type which does not allow `void' to be used
2863 : type_expression_or_array
2866 Expression.Error_VoidInvalidInTheContext (GetLocation ($1), Report);
2867 $$ = TypeManager.system_void_expr;
2875 Expression.Error_VoidInvalidInTheContext (GetLocation ($1), Report);
2876 $$ = TypeManager.system_void_expr;
2881 : type_expression_or_array
2884 Report.Error (1536, GetLocation ($1), "Invalid parameter type `void'");
2885 $$ = TypeManager.system_void_expr;
2889 type_expression_or_array
2891 | type_expression rank_specifiers
2893 string rank_specifiers = (string) $2;
2894 $$ = new ComposedCast ((FullNamedExpression) $1, rank_specifiers);
2899 : namespace_or_type_name opt_nullable
2901 MemberName name = (MemberName) $1;
2904 $$ = new ComposedCast (name.GetTypeExpression (), "?", lexer.Location);
2906 if (name.Left == null && name.Name == "var")
2907 $$ = new VarExpr (name.Location);
2909 $$ = name.GetTypeExpression ();
2912 | builtin_types opt_nullable
2915 $$ = new ComposedCast ((FullNamedExpression) $1, "?", lexer.Location);
2917 | type_expression STAR
2920 // Note that here only unmanaged types are allowed but we
2921 // can't perform checks during this phase - we do it during
2922 // semantic analysis.
2924 $$ = new ComposedCast ((FullNamedExpression) $1, "*", Lexer.Location);
2928 $$ = new ComposedCast (TypeManager.system_void_expr, "*", GetLocation ($1));
2935 var types = new List<FullNamedExpression> (2);
2936 types.Add ((FullNamedExpression) $1);
2939 | type_list COMMA base_type_name
2941 var types = (List<FullNamedExpression>) $1;
2942 types.Add ((FullNamedExpression) $3);
2950 if ($1 is ComposedCast) {
2951 Report.Error (1521, GetLocation ($1), "Invalid base type `{0}'", ((ComposedCast)$1).GetSignatureForError ());
2957 Error_TypeExpected (lexer.Location);
2963 * replaces all the productions for isolating the various
2964 * simple types, but we need this to reuse it easily in variable_type
2967 : OBJECT { $$ = TypeManager.system_object_expr; }
2968 | STRING { $$ = TypeManager.system_string_expr; }
2969 | BOOL { $$ = TypeManager.system_boolean_expr; }
2970 | DECIMAL { $$ = TypeManager.system_decimal_expr; }
2971 | FLOAT { $$ = TypeManager.system_single_expr; }
2972 | DOUBLE { $$ = TypeManager.system_double_expr; }
2977 : SBYTE { $$ = TypeManager.system_sbyte_expr; }
2978 | BYTE { $$ = TypeManager.system_byte_expr; }
2979 | SHORT { $$ = TypeManager.system_int16_expr; }
2980 | USHORT { $$ = TypeManager.system_uint16_expr; }
2981 | INT { $$ = TypeManager.system_int32_expr; }
2982 | UINT { $$ = TypeManager.system_uint32_expr; }
2983 | LONG { $$ = TypeManager.system_int64_expr; }
2984 | ULONG { $$ = TypeManager.system_uint64_expr; }
2985 | CHAR { $$ = TypeManager.system_char_expr; }
2992 $$ = TypeManager.system_void_expr;
2997 // Expressions, section 7.5
3002 : primary_expression_no_array_creation
3003 | array_creation_expression
3006 primary_expression_no_array_creation
3008 | IDENTIFIER opt_type_argument_list
3010 var lt = (Tokenizer.LocatedToken) $1;
3011 $$ = new SimpleName (MemberName.MakeName (lt.Value, (TypeArguments)$2), (TypeArguments)$2, lt.Location);
3013 | IDENTIFIER GENERATE_COMPLETION {
3014 var lt = (Tokenizer.LocatedToken) $1;
3015 $$ = new CompletionSimpleName (MemberName.MakeName (lt.Value, null), lt.Location);
3017 | parenthesized_expression
3018 | default_value_expression
3020 | invocation_expression
3024 | post_increment_expression
3025 | post_decrement_expression
3026 | object_or_delegate_creation_expression
3027 | anonymous_type_expression
3030 | checked_expression
3031 | unchecked_expression
3032 | pointer_member_access
3033 | anonymous_method_expression
3039 | NULL { $$ = new NullLiteral (GetLocation ($1)); }
3043 : TRUE { $$ = new BoolLiteral (true, GetLocation ($1)); }
3044 | FALSE { $$ = new BoolLiteral (false, GetLocation ($1)); }
3049 // Here is the trick, tokenizer may think that parens is a special but
3050 // parser is interested in open parens only, so we merge them.
3051 // Consider: if (a)foo ();
3059 // Use this production to accept closing parenthesis or
3060 // performing completion
3064 | COMPLETE_COMPLETION
3068 parenthesized_expression
3069 : OPEN_PARENS expression CLOSE_PARENS
3071 $$ = new ParenthesizedExpression ((Expression) $2);
3073 | OPEN_PARENS expression COMPLETE_COMPLETION
3075 $$ = new ParenthesizedExpression ((Expression) $2);
3080 : primary_expression DOT IDENTIFIER opt_type_argument_list
3082 var lt = (Tokenizer.LocatedToken) $3;
3083 $$ = new MemberAccess ((Expression) $1, lt.Value, (TypeArguments) $4, lt.Location);
3085 | predefined_type DOT IDENTIFIER opt_type_argument_list
3087 var lt = (Tokenizer.LocatedToken) $3;
3088 // TODO: Location is wrong as some predefined types doesn't hold a location
3089 $$ = new MemberAccess ((Expression) $1, lt.Value, (TypeArguments) $4, lt.Location);
3091 | qualified_alias_member IDENTIFIER opt_type_argument_list
3093 var lt1 = (Tokenizer.LocatedToken) $1;
3094 var lt2 = (Tokenizer.LocatedToken) $2;
3096 $$ = new QualifiedAliasMember (lt1.Value, lt2.Value, (TypeArguments) $3, lt1.Location);
3098 | primary_expression DOT GENERATE_COMPLETION {
3099 $$ = new CompletionMemberAccess ((Expression) $1, null,GetLocation ($3));
3101 | primary_expression DOT IDENTIFIER GENERATE_COMPLETION {
3102 var lt = (Tokenizer.LocatedToken) $3;
3103 $$ = new CompletionMemberAccess ((Expression) $1, lt.Value, lt.Location);
3105 | predefined_type DOT GENERATE_COMPLETION
3107 // TODO: Location is wrong as some predefined types doesn't hold a location
3108 $$ = new CompletionMemberAccess ((Expression) $1, null, lexer.Location);
3110 | predefined_type DOT IDENTIFIER GENERATE_COMPLETION {
3111 var lt = (Tokenizer.LocatedToken) $3;
3112 $$ = new CompletionMemberAccess ((Expression) $1, lt.Value, lt.Location);
3116 invocation_expression
3117 : primary_expression open_parens_any opt_argument_list close_parens
3119 $$ = new Invocation ((Expression) $1, (Arguments) $3);
3123 opt_object_or_collection_initializer
3124 : /* empty */ { $$ = null; }
3125 | object_or_collection_initializer
3128 object_or_collection_initializer
3129 : OPEN_BRACE opt_member_initializer_list close_brace_or_complete_completion
3132 $$ = CollectionOrObjectInitializers.Empty;
3134 $$ = new CollectionOrObjectInitializers ((List<Expression>) $2, GetLocation ($1));
3136 | OPEN_BRACE member_initializer_list COMMA CLOSE_BRACE
3138 $$ = new CollectionOrObjectInitializers ((List<Expression>) $2, GetLocation ($1));
3142 opt_member_initializer_list
3143 : /* empty */ { $$ = null; }
3144 | member_initializer_list
3150 member_initializer_list
3151 : member_initializer
3153 var a = new List<Expression> ();
3154 a.Add ((Expression) $1);
3157 | member_initializer_list COMMA member_initializer
3159 var a = (List<Expression>)$1;
3160 a.Add ((Expression) $3);
3166 : IDENTIFIER ASSIGN initializer_value
3168 var lt = (Tokenizer.LocatedToken) $1;
3169 $$ = new ElementInitializer (lt.Value, (Expression)$3, lt.Location);
3171 | GENERATE_COMPLETION
3173 $$ = new CompletionElementInitializer (null, GetLocation ($1));
3175 | non_assignment_expression opt_COMPLETE_COMPLETION {
3176 CompletionSimpleName csn = $1 as CompletionSimpleName;
3178 $$ = new CollectionElementInitializer ((Expression)$1);
3180 $$ = new CompletionElementInitializer (csn.Prefix, csn.Location);
3182 | OPEN_BRACE expression_list CLOSE_BRACE
3184 $$ = new CollectionElementInitializer ((List<Expression>)$2, GetLocation ($1));
3186 | OPEN_BRACE CLOSE_BRACE
3188 Report.Error (1920, GetLocation ($1), "An element initializer cannot be empty");
3195 | object_or_collection_initializer
3199 : /* empty */ { $$ = null; }
3204 : argument_or_named_argument
3206 Arguments list = new Arguments (4);
3207 list.Add ((Argument) $1);
3210 | argument_list COMMA argument
3212 Arguments list = (Arguments) $1;
3213 if (list [list.Count - 1] is NamedArgument)
3214 Error_NamedArgumentExpected ((NamedArgument) list [list.Count - 1]);
3216 list.Add ((Argument) $3);
3219 | argument_list COMMA named_argument
3221 Arguments list = (Arguments) $1;
3222 NamedArgument a = (NamedArgument) $3;
3223 for (int i = 0; i < list.Count; ++i) {
3224 NamedArgument na = list [i] as NamedArgument;
3225 if (na != null && na.Name == a.Name)
3226 Report.Error (1740, na.Location, "Named argument `{0}' specified multiple times",
3233 | argument_list COMMA
3235 Report.Error (839, GetLocation ($2), "An argument is missing");
3238 | COMMA argument_or_named_argument
3240 Report.Error (839, GetLocation ($1), "An argument is missing");
3248 $$ = new Argument ((Expression) $1);
3250 | non_simple_argument
3253 argument_or_named_argument
3259 : REF variable_reference
3261 $$ = new Argument ((Expression) $2, Argument.AType.Ref);
3263 | OUT variable_reference
3265 $$ = new Argument ((Expression) $2, Argument.AType.Out);
3267 | ARGLIST OPEN_PARENS argument_list CLOSE_PARENS
3269 $$ = new Argument (new Arglist ((Arguments) $3, GetLocation ($1)));
3271 | ARGLIST OPEN_PARENS CLOSE_PARENS
3273 $$ = new Argument (new Arglist (GetLocation ($1)));
3277 $$ = new Argument (new ArglistAccess (GetLocation ($1)));
3286 : primary_expression_no_array_creation OPEN_BRACKET expression_list_arguments CLOSE_BRACKET
3288 $$ = new ElementAccess ((Expression) $1, (Arguments) $3);
3290 | array_creation_expression OPEN_BRACKET expression_list_arguments CLOSE_BRACKET
3292 // LAMESPEC: Not allowed according to specification
3293 $$ = new ElementAccess ((Expression) $1, (Arguments) $3);
3295 | primary_expression_no_array_creation rank_specifiers
3297 // So the super-trick is that primary_expression
3298 // can only be either a SimpleName or a MemberAccess.
3299 // The MemberAccess case arises when you have a fully qualified type-name like :
3301 // SimpleName is when you have
3304 Expression expr = (Expression) $1;
3305 if (expr is ComposedCast){
3306 $$ = new ComposedCast ((ComposedCast)expr, (string) $2);
3307 } else if (expr is ATypeNameExpression){
3309 // So we extract the string corresponding to the SimpleName
3312 $$ = new ComposedCast ((ATypeNameExpression)expr, (string) $2);
3314 Error_ExpectingTypeName (expr);
3315 $$ = TypeManager.system_object_expr;
3323 var list = new List<Expression> (4);
3324 list.Add ((Expression) $1);
3327 | expression_list COMMA expression
3329 var list = (List<Expression>) $1;
3330 list.Add ((Expression) $3);
3335 expression_list_arguments
3336 : expression_list_argument
3338 Arguments args = new Arguments (4);
3339 args.Add ((Argument) $1);
3342 | expression_list_arguments COMMA expression_list_argument
3344 Arguments args = (Arguments) $1;
3345 args.Add ((Argument) $3);
3350 expression_list_argument
3353 $$ = new Argument ((Expression) $1);
3361 $$ = new This (current_block, GetLocation ($1));
3366 : BASE DOT IDENTIFIER opt_type_argument_list
3368 var lt = (Tokenizer.LocatedToken) $3;
3369 $$ = new BaseAccess (lt.Value, (TypeArguments) $4, lt.Location);
3371 | BASE OPEN_BRACKET expression_list_arguments CLOSE_BRACKET
3373 $$ = new BaseIndexerAccess ((Arguments) $3, GetLocation ($1));
3377 Error_SyntaxError (yyToken);
3378 $$ = new BaseAccess (null, GetLocation ($2));
3382 post_increment_expression
3383 : primary_expression OP_INC
3385 $$ = new UnaryMutator (UnaryMutator.Mode.PostIncrement, (Expression) $1, GetLocation ($2));
3389 post_decrement_expression
3390 : primary_expression OP_DEC
3392 $$ = new UnaryMutator (UnaryMutator.Mode.PostDecrement, (Expression) $1, GetLocation ($2));
3396 object_or_delegate_creation_expression
3397 : new_expr_start open_parens_any opt_argument_list CLOSE_PARENS opt_object_or_collection_initializer
3400 if (RootContext.Version <= LanguageVersion.ISO_2)
3401 Report.FeatureIsNotAvailable (GetLocation ($1), "object initializers");
3403 $$ = new NewInitialize ((Expression) $1, (Arguments) $3, (CollectionOrObjectInitializers) $5, GetLocation ($1));
3406 $$ = new New ((Expression) $1, (Arguments) $3, GetLocation ($1));
3408 | new_expr_start object_or_collection_initializer
3410 if (RootContext.Version <= LanguageVersion.ISO_2)
3411 Report.FeatureIsNotAvailable (GetLocation ($1), "collection initializers");
3413 $$ = new NewInitialize ((Expression) $1, null, (CollectionOrObjectInitializers) $2, GetLocation ($1));
3417 array_creation_expression
3418 : new_expr_start OPEN_BRACKET expression_list CLOSE_BRACKET
3419 opt_rank_specifier // shift/reduce on OPEN_BRACE
3420 opt_array_initializer
3422 $$ = new ArrayCreation ((FullNamedExpression) $1, (List<Expression>) $3, (string) $5, (ArrayInitializer) $6, GetLocation ($1));
3424 | new_expr_start rank_specifiers opt_array_initializer
3427 Report.Error (1586, GetLocation ($1), "Array creation must have array size or array initializer");
3429 $$ = new ArrayCreation ((FullNamedExpression) $1, (string) $2, (ArrayInitializer) $3, GetLocation ($1));
3431 | NEW rank_specifiers array_initializer
3433 if (RootContext.Version <= LanguageVersion.ISO_2)
3434 Report.FeatureIsNotAvailable (GetLocation ($1), "implicitly typed arrays");
3436 $$ = new ImplicitlyTypedArrayCreation ((string) $2, (ArrayInitializer) $3, GetLocation ($1));
3438 | new_expr_start error
3440 Report.Error (1526, GetLocation ($1), "A new expression requires () or [] after type");
3441 $$ = new ArrayCreation ((FullNamedExpression) $1, "[]", null, GetLocation ($1));
3448 ++lexer.parsing_type;
3452 --lexer.parsing_type;
3457 anonymous_type_expression
3458 : NEW OPEN_BRACE anonymous_type_parameters_opt_comma CLOSE_BRACE
3460 if (RootContext.MetadataCompatibilityVersion < MetadataVersion.v2)
3461 Report.FeatureIsNotSupported (GetLocation ($1), "anonymous types");
3462 else if (RootContext.Version <= LanguageVersion.ISO_2)
3463 Report.FeatureIsNotAvailable (GetLocation ($1), "anonymous types");
3465 $$ = new NewAnonymousType ((List<AnonymousTypeParameter>) $3, current_container, GetLocation ($1));
3469 anonymous_type_parameters_opt_comma
3470 : anonymous_type_parameters_opt
3471 | anonymous_type_parameters COMMA
3474 anonymous_type_parameters_opt
3476 | anonymous_type_parameters
3479 anonymous_type_parameters
3480 : anonymous_type_parameter
3482 var a = new List<AnonymousTypeParameter> (4);
3483 a.Add ((AnonymousTypeParameter) $1);
3486 | anonymous_type_parameters COMMA anonymous_type_parameter
3488 var a = (List<AnonymousTypeParameter>) $1;
3489 a.Add ((AnonymousTypeParameter) $3);
3494 anonymous_type_parameter
3495 : IDENTIFIER ASSIGN variable_initializer
3497 var lt = (Tokenizer.LocatedToken)$1;
3498 $$ = new AnonymousTypeParameter ((Expression)$3, lt.Value, lt.Location);
3502 var lt = (Tokenizer.LocatedToken)$1;
3503 $$ = new AnonymousTypeParameter (new SimpleName (lt.Value, lt.Location),
3504 lt.Value, lt.Location);
3506 | BASE DOT IDENTIFIER opt_type_argument_list
3508 var lt = (Tokenizer.LocatedToken) $3;
3509 BaseAccess ba = new BaseAccess (lt.Value, (TypeArguments) $4, lt.Location);
3510 $$ = new AnonymousTypeParameter (ba, lt.Value, lt.Location);
3514 MemberAccess ma = (MemberAccess) $1;
3515 $$ = new AnonymousTypeParameter (ma, ma.Name, ma.Location);
3519 Report.Error (746, lexer.Location,
3520 "Invalid anonymous type member declarator. Anonymous type members must be a member assignment, simple name or member access expression");
3536 opt_rank_specifier_or_nullable
3544 | opt_nullable rank_specifiers
3547 $$ = "?" + (string) $2;
3555 | rank_specifier rank_specifiers
3557 $$ = (string) $2 + (string) $1;
3562 : OPEN_BRACKET CLOSE_BRACKET
3566 | OPEN_BRACKET dim_separators CLOSE_BRACKET
3568 $$ = "[" + (string) $2 + "]";
3570 | OPEN_BRACKET error
3572 Error_SyntaxError (178, yyToken, "Invalid rank specifier");
3582 | dim_separators COMMA
3584 $$ = (string) $1 + ",";
3588 opt_array_initializer
3600 : OPEN_BRACE CLOSE_BRACE
3602 $$ = new ArrayInitializer (0, GetLocation ($1));
3604 | OPEN_BRACE variable_initializer_list opt_comma CLOSE_BRACE
3606 $$ = new ArrayInitializer ((List<Expression>) $2, GetLocation ($1));
3610 variable_initializer_list
3611 : variable_initializer
3613 var list = new List<Expression> (4);
3614 list.Add ((Expression) $1);
3617 | variable_initializer_list COMMA variable_initializer
3619 var list = (List<Expression>) $1;
3620 list.Add ((Expression) $3);
3625 Error_SyntaxError (yyToken);
3626 $$ = new List<Expression> ();
3633 lexer.TypeOfParsing = true;
3635 open_parens_any typeof_type_expression CLOSE_PARENS
3637 lexer.TypeOfParsing = false;
3638 Expression type = (Expression)$4;
3639 if (type == TypeManager.system_void_expr)
3640 $$ = new TypeOfVoid (GetLocation ($1));
3642 $$ = new TypeOf (type, GetLocation ($1));
3646 typeof_type_expression
3651 Error_TypeExpected (lexer.Location);
3657 : IDENTIFIER generic_dimension
3659 var lt = (Tokenizer.LocatedToken) $1;
3661 $$ = new SimpleName (MemberName.MakeName (lt.Value, (int)$2), lt.Location);
3663 | qualified_alias_member IDENTIFIER generic_dimension
3665 var lt1 = (Tokenizer.LocatedToken) $1;
3666 var lt2 = (Tokenizer.LocatedToken) $2;
3668 $$ = new QualifiedAliasMember (lt1.Value, MemberName.MakeName (lt2.Value, (int) $3), lt1.Location);
3670 | unbound_type_name DOT IDENTIFIER
3672 var lt = (Tokenizer.LocatedToken) $3;
3674 $$ = new MemberAccess ((Expression) $1, lt.Value, lt.Location);
3676 | unbound_type_name DOT IDENTIFIER generic_dimension
3678 var lt = (Tokenizer.LocatedToken) $3;
3680 $$ = new MemberAccess ((Expression) $1, MemberName.MakeName (lt.Value, (int) $4), lt.Location);
3682 | namespace_or_type_name DOT IDENTIFIER generic_dimension
3684 var lt = (Tokenizer.LocatedToken) $3;
3685 MemberName name = (MemberName) $1;
3687 $$ = new MemberAccess (name.GetTypeExpression (), MemberName.MakeName (lt.Value, (int) $4), lt.Location);
3694 if (RootContext.MetadataCompatibilityVersion < MetadataVersion.v2)
3695 Report.FeatureIsNotSupported (GetLocation ($1), "generics");
3696 else if (RootContext.Version < LanguageVersion.ISO_2)
3697 Report.FeatureIsNotAvailable (GetLocation ($1), "generics");
3703 qualified_alias_member
3704 : IDENTIFIER DOUBLE_COLON
3706 var lt = (Tokenizer.LocatedToken) $1;
3707 if (RootContext.Version == LanguageVersion.ISO_1)
3708 Report.FeatureIsNotAvailable (lt.Location, "namespace alias qualifier");
3715 : SIZEOF open_parens_any type CLOSE_PARENS {
3716 $$ = new SizeOf ((Expression) $3, GetLocation ($1));
3721 : CHECKED open_parens_any expression CLOSE_PARENS
3723 $$ = new CheckedExpr ((Expression) $3, GetLocation ($1));
3727 unchecked_expression
3728 : UNCHECKED open_parens_any expression CLOSE_PARENS
3730 $$ = new UnCheckedExpr ((Expression) $3, GetLocation ($1));
3734 pointer_member_access
3735 : primary_expression OP_PTR IDENTIFIER
3738 var lt = (Tokenizer.LocatedToken) $3;
3740 deref = new Indirection ((Expression) $1, lt.Location);
3741 $$ = new MemberAccess (deref, lt.Value);
3745 anonymous_method_expression
3746 : DELEGATE opt_anonymous_method_signature
3748 start_anonymous (false, (ParametersCompiled) $2, GetLocation ($1));
3752 $$ = end_anonymous ((ToplevelBlock) $4);
3756 opt_anonymous_method_signature
3759 $$ = ParametersCompiled.Undefined;
3761 | anonymous_method_signature
3764 anonymous_method_signature
3767 valid_param_mod = ParameterModifierType.Ref | ParameterModifierType.Out;
3769 opt_formal_parameter_list CLOSE_PARENS
3771 valid_param_mod = 0;
3776 default_value_expression
3777 : DEFAULT open_parens_any type CLOSE_PARENS
3779 if (RootContext.Version < LanguageVersion.ISO_2)
3780 Report.FeatureIsNotAvailable (GetLocation ($1), "default value expression");
3782 $$ = new DefaultValueExpression ((Expression) $3, GetLocation ($1));
3787 : primary_expression
3788 | BANG prefixed_unary_expression
3790 $$ = new Unary (Unary.Operator.LogicalNot, (Expression) $2, GetLocation ($1));
3792 | TILDE prefixed_unary_expression
3794 $$ = new Unary (Unary.Operator.OnesComplement, (Expression) $2, GetLocation ($1));
3800 : OPEN_PARENS_CAST type CLOSE_PARENS prefixed_unary_expression
3802 $$ = new Cast ((FullNamedExpression) $2, (Expression) $4, GetLocation ($1));
3804 | OPEN_PARENS predefined_type CLOSE_PARENS prefixed_unary_expression
3806 $$ = new Cast ((FullNamedExpression) $2, (Expression) $4, GetLocation ($1));
3811 // The idea to split this out is from Rhys' grammar
3812 // to solve the problem with casts.
3814 prefixed_unary_expression
3816 | PLUS prefixed_unary_expression
3818 $$ = new Unary (Unary.Operator.UnaryPlus, (Expression) $2, GetLocation ($1));
3820 | MINUS prefixed_unary_expression
3822 $$ = new Unary (Unary.Operator.UnaryNegation, (Expression) $2, GetLocation ($1));
3824 | OP_INC prefixed_unary_expression
3826 $$ = new UnaryMutator (UnaryMutator.Mode.PreIncrement, (Expression) $2, GetLocation ($1));
3828 | OP_DEC prefixed_unary_expression
3830 $$ = new UnaryMutator (UnaryMutator.Mode.PreDecrement, (Expression) $2, GetLocation ($1));
3832 | STAR prefixed_unary_expression
3834 $$ = new Indirection ((Expression) $2, GetLocation ($1));
3836 | BITWISE_AND prefixed_unary_expression
3838 $$ = new Unary (Unary.Operator.AddressOf, (Expression) $2, GetLocation ($1));
3842 multiplicative_expression
3843 : prefixed_unary_expression
3844 | multiplicative_expression STAR prefixed_unary_expression
3846 $$ = new Binary (Binary.Operator.Multiply,
3847 (Expression) $1, (Expression) $3, GetLocation ($2));
3849 | multiplicative_expression DIV prefixed_unary_expression
3851 $$ = new Binary (Binary.Operator.Division,
3852 (Expression) $1, (Expression) $3, GetLocation ($2));
3854 | multiplicative_expression PERCENT prefixed_unary_expression
3856 $$ = new Binary (Binary.Operator.Modulus,
3857 (Expression) $1, (Expression) $3, GetLocation ($2));
3862 : multiplicative_expression
3863 | additive_expression PLUS multiplicative_expression
3865 $$ = new Binary (Binary.Operator.Addition,
3866 (Expression) $1, (Expression) $3, GetLocation ($2));
3868 | additive_expression MINUS multiplicative_expression
3870 $$ = new Binary (Binary.Operator.Subtraction, (Expression) $1, (Expression) $3, GetLocation ($2));
3872 | parenthesized_expression MINUS multiplicative_expression
3874 // Shift/Reduce conflict
3875 $$ = new Binary (Binary.Operator.Subtraction, (Expression) $1, (Expression) $3, GetLocation ($2));
3877 | additive_expression AS type
3879 $$ = new As ((Expression) $1, (Expression) $3, GetLocation ($2));
3881 | additive_expression IS type
3883 $$ = new Is ((Expression) $1, (Expression) $3, GetLocation ($2));
3888 : additive_expression
3889 | shift_expression OP_SHIFT_LEFT additive_expression
3891 $$ = new Binary (Binary.Operator.LeftShift,
3892 (Expression) $1, (Expression) $3, GetLocation ($2));
3894 | shift_expression OP_SHIFT_RIGHT additive_expression
3896 $$ = new Binary (Binary.Operator.RightShift,
3897 (Expression) $1, (Expression) $3, GetLocation ($2));
3901 relational_expression
3903 | relational_expression OP_LT shift_expression
3905 $$ = new Binary (Binary.Operator.LessThan,
3906 (Expression) $1, (Expression) $3, GetLocation ($2));
3908 | relational_expression OP_GT shift_expression
3910 $$ = new Binary (Binary.Operator.GreaterThan,
3911 (Expression) $1, (Expression) $3, GetLocation ($2));
3913 | relational_expression OP_LE shift_expression
3915 $$ = new Binary (Binary.Operator.LessThanOrEqual,
3916 (Expression) $1, (Expression) $3, GetLocation ($2));
3918 | relational_expression OP_GE shift_expression
3920 $$ = new Binary (Binary.Operator.GreaterThanOrEqual,
3921 (Expression) $1, (Expression) $3, GetLocation ($2));
3926 : relational_expression
3927 | equality_expression OP_EQ relational_expression
3929 $$ = new Binary (Binary.Operator.Equality,
3930 (Expression) $1, (Expression) $3, GetLocation ($2));
3932 | equality_expression OP_NE relational_expression
3934 $$ = new Binary (Binary.Operator.Inequality,
3935 (Expression) $1, (Expression) $3, GetLocation ($2));
3940 : equality_expression
3941 | and_expression BITWISE_AND equality_expression
3943 $$ = new Binary (Binary.Operator.BitwiseAnd,
3944 (Expression) $1, (Expression) $3, GetLocation ($2));
3948 exclusive_or_expression
3950 | exclusive_or_expression CARRET and_expression
3952 $$ = new Binary (Binary.Operator.ExclusiveOr,
3953 (Expression) $1, (Expression) $3, GetLocation ($2));
3957 inclusive_or_expression
3958 : exclusive_or_expression
3959 | inclusive_or_expression BITWISE_OR exclusive_or_expression
3961 $$ = new Binary (Binary.Operator.BitwiseOr,
3962 (Expression) $1, (Expression) $3, GetLocation ($2));
3966 conditional_and_expression
3967 : inclusive_or_expression
3968 | conditional_and_expression OP_AND inclusive_or_expression
3970 $$ = new Binary (Binary.Operator.LogicalAnd,
3971 (Expression) $1, (Expression) $3, GetLocation ($2));
3975 conditional_or_expression
3976 : conditional_and_expression
3977 | conditional_or_expression OP_OR conditional_and_expression
3979 $$ = new Binary (Binary.Operator.LogicalOr,
3980 (Expression) $1, (Expression) $3, GetLocation ($2));
3984 null_coalescing_expression
3985 : conditional_or_expression
3986 | conditional_or_expression OP_COALESCING null_coalescing_expression
3988 if (RootContext.Version < LanguageVersion.ISO_2)
3989 Report.FeatureIsNotAvailable (GetLocation ($2), "null coalescing operator");
3991 $$ = new Nullable.NullCoalescingOperator ((Expression) $1, (Expression) $3, GetLocation ($2));
3995 conditional_expression
3996 : null_coalescing_expression
3997 | null_coalescing_expression INTERR expression COLON expression
3999 $$ = new Conditional (new BooleanExpression ((Expression) $1), (Expression) $3, (Expression) $5);
4003 assignment_expression
4004 : prefixed_unary_expression ASSIGN expression
4006 $$ = new SimpleAssign ((Expression) $1, (Expression) $3);
4008 | prefixed_unary_expression OP_MULT_ASSIGN expression
4010 $$ = new CompoundAssign (
4011 Binary.Operator.Multiply, (Expression) $1, (Expression) $3);
4013 | prefixed_unary_expression OP_DIV_ASSIGN expression
4015 $$ = new CompoundAssign (
4016 Binary.Operator.Division, (Expression) $1, (Expression) $3);
4018 | prefixed_unary_expression OP_MOD_ASSIGN expression
4020 $$ = new CompoundAssign (
4021 Binary.Operator.Modulus, (Expression) $1, (Expression) $3);
4023 | prefixed_unary_expression OP_ADD_ASSIGN expression
4025 $$ = new CompoundAssign (
4026 Binary.Operator.Addition, (Expression) $1, (Expression) $3);
4028 | prefixed_unary_expression OP_SUB_ASSIGN expression
4030 $$ = new CompoundAssign (
4031 Binary.Operator.Subtraction, (Expression) $1, (Expression) $3);
4033 | prefixed_unary_expression OP_SHIFT_LEFT_ASSIGN expression
4035 $$ = new CompoundAssign (
4036 Binary.Operator.LeftShift, (Expression) $1, (Expression) $3);
4038 | prefixed_unary_expression OP_SHIFT_RIGHT_ASSIGN expression
4040 $$ = new CompoundAssign (
4041 Binary.Operator.RightShift, (Expression) $1, (Expression) $3);
4043 | prefixed_unary_expression OP_AND_ASSIGN expression
4045 $$ = new CompoundAssign (
4046 Binary.Operator.BitwiseAnd, (Expression) $1, (Expression) $3);
4048 | prefixed_unary_expression OP_OR_ASSIGN expression
4050 $$ = new CompoundAssign (
4051 Binary.Operator.BitwiseOr, (Expression) $1, (Expression) $3);
4053 | prefixed_unary_expression OP_XOR_ASSIGN expression
4055 $$ = new CompoundAssign (
4056 Binary.Operator.ExclusiveOr, (Expression) $1, (Expression) $3);
4060 lambda_parameter_list
4063 var pars = new List<Parameter> (4);
4064 pars.Add ((Parameter) $1);
4068 | lambda_parameter_list COMMA lambda_parameter
4070 var pars = (List<Parameter>) $1;
4071 Parameter p = (Parameter)$3;
4072 if (pars[0].GetType () != p.GetType ()) {
4073 Report.Error (748, p.Location, "All lambda parameters must be typed either explicitly or implicitly");
4082 : parameter_modifier parameter_type IDENTIFIER
4084 var lt = (Tokenizer.LocatedToken) $3;
4086 $$ = new Parameter ((FullNamedExpression) $2, lt.Value, (Parameter.Modifier) $1, null, lt.Location);
4088 | parameter_type IDENTIFIER
4090 var lt = (Tokenizer.LocatedToken) $2;
4092 $$ = new Parameter ((FullNamedExpression) $1, lt.Value, Parameter.Modifier.NONE, null, lt.Location);
4096 var lt = (Tokenizer.LocatedToken) $1;
4097 $$ = new ImplicitLambdaParameter (lt.Value, lt.Location);
4101 opt_lambda_parameter_list
4102 : /* empty */ { $$ = ParametersCompiled.EmptyReadOnlyParameters; }
4103 | lambda_parameter_list {
4104 var pars_list = (List<Parameter>) $1;
4105 $$ = new ParametersCompiled (compiler, pars_list.ToArray ());
4109 lambda_expression_body
4111 start_block (lexer.Location);
4115 Block b = end_block (lexer.Location);
4116 b.AddStatement (new ContextualReturn ((Expression) $2));
4127 var lt = (Tokenizer.LocatedToken) $1;
4128 Parameter p = new ImplicitLambdaParameter (lt.Value, lt.Location);
4129 start_anonymous (true, new ParametersCompiled (compiler, p), GetLocation ($1));
4131 lambda_expression_body
4133 $$ = end_anonymous ((ToplevelBlock) $4);
4135 | OPEN_PARENS_LAMBDA
4137 if (RootContext.Version <= LanguageVersion.ISO_2)
4138 Report.FeatureIsNotAvailable (GetLocation ($1), "lambda expressions");
4140 valid_param_mod = ParameterModifierType.Ref | ParameterModifierType.Out;
4142 opt_lambda_parameter_list CLOSE_PARENS ARROW
4144 valid_param_mod = 0;
4145 start_anonymous (true, (ParametersCompiled) $3, GetLocation ($1));
4147 lambda_expression_body
4149 $$ = end_anonymous ((ToplevelBlock) $7);
4154 : assignment_expression
4155 | non_assignment_expression
4158 non_assignment_expression
4159 : conditional_expression
4171 $$ = new BooleanExpression ((Expression) $1);
4184 lexer.ConstraintsParsing = true;
4186 type_declaration_name
4188 MemberName name = MakeName ((MemberName) $6);
4189 push_current_class (new Class (current_namespace, current_class, name, (Modifiers) $2, (Attributes) $1), $3);
4192 opt_type_parameter_constraints_clauses
4194 lexer.ConstraintsParsing = false;
4196 current_class.SetParameterInfo ((List<Constraints>) $9);
4198 if (RootContext.Documentation != null) {
4199 current_container.DocComment = Lexer.consume_doc_comment ();
4200 Lexer.doc_state = XmlCommentState.Allowed;
4205 --lexer.parsing_declaration;
4206 if (RootContext.Documentation != null)
4207 Lexer.doc_state = XmlCommentState.Allowed;
4211 $$ = pop_current_class ();
4219 { $$ = $1; } // location
4223 : /* empty */ { $$ = (int) 0; }
4229 | modifiers modifier
4231 var m1 = (Modifiers) $1;
4232 var m2 = (Modifiers) $2;
4234 if ((m1 & m2) != 0) {
4235 Location l = lexer.Location;
4236 Report.Error (1004, l, "Duplicate `{0}' modifier", ModifiersExtensions.Name (m2));
4246 if (current_container == RootContext.ToplevelTypes)
4247 Report.Error (1530, GetLocation ($1), "Keyword `new' is not allowed on namespace elements");
4249 | PUBLIC { $$ = Modifiers.PUBLIC; }
4250 | PROTECTED { $$ = Modifiers.PROTECTED; }
4251 | INTERNAL { $$ = Modifiers.INTERNAL; }
4252 | PRIVATE { $$ = Modifiers.PRIVATE; }
4253 | ABSTRACT { $$ = Modifiers.ABSTRACT; }
4254 | SEALED { $$ = Modifiers.SEALED; }
4255 | STATIC { $$ = Modifiers.STATIC; }
4256 | READONLY { $$ = Modifiers.READONLY; }
4257 | VIRTUAL { $$ = Modifiers.VIRTUAL; }
4258 | OVERRIDE { $$ = Modifiers.OVERRIDE; }
4259 | EXTERN { $$ = Modifiers.EXTERN; }
4260 | VOLATILE { $$ = Modifiers.VOLATILE; }
4261 | UNSAFE { $$ = Modifiers.UNSAFE; }
4272 current_container.AddBasesForPart (current_class, (List<FullNamedExpression>) $2);
4276 opt_type_parameter_constraints_clauses
4277 : /* empty */ { $$ = null; }
4278 | type_parameter_constraints_clauses
4284 type_parameter_constraints_clauses
4285 : type_parameter_constraints_clause
4287 var constraints = new List<Constraints> (1);
4288 constraints.Add ((Constraints) $1);
4291 | type_parameter_constraints_clauses type_parameter_constraints_clause
4293 var constraints = (List<Constraints>) $1;
4294 Constraints new_constraint = (Constraints)$2;
4296 foreach (Constraints c in constraints) {
4297 if (new_constraint.TypeParameter.Value == c.TypeParameter.Value) {
4298 Report.Error (409, new_constraint.Location,
4299 "A constraint clause has already been specified for type parameter `{0}'",
4300 new_constraint.TypeParameter.Value);
4304 constraints.Add (new_constraint);
4309 type_parameter_constraints_clause
4310 : WHERE IDENTIFIER COLON type_parameter_constraints
4312 var lt = (Tokenizer.LocatedToken) $2;
4313 $$ = new Constraints (new SimpleMemberName (lt.Value, lt.Location), (List<FullNamedExpression>) $4, GetLocation ($1));
4317 type_parameter_constraints
4318 : type_parameter_constraint
4320 var constraints = new List<FullNamedExpression> (1);
4321 constraints.Add ((FullNamedExpression) $1);
4324 | type_parameter_constraints COMMA type_parameter_constraint
4326 var constraints = (List<FullNamedExpression>) $1;
4327 var prev = constraints [constraints.Count - 1] as SpecialContraintExpr;
4328 if (prev != null && (prev.Constraint & SpecialConstraint.Constructor) != 0) {
4329 Report.Error (401, GetLocation ($2), "The `new()' constraint must be the last constraint specified");
4332 prev = $3 as SpecialContraintExpr;
4334 if ((prev.Constraint & (SpecialConstraint.Class | SpecialConstraint.Struct)) != 0) {
4335 Report.Error (449, prev.Location, "The `class' or `struct' constraint must be the first constraint specified");
4337 prev = constraints [0] as SpecialContraintExpr;
4338 if (prev != null && (prev.Constraint & SpecialConstraint.Struct) != 0) {
4339 Report.Error (451, GetLocation ($3), "The `new()' constraint cannot be used with the `struct' constraint");
4344 constraints.Add ((FullNamedExpression) $3);
4349 type_parameter_constraint
4352 if ($1 is ComposedCast)
4353 Report.Error (706, GetLocation ($1), "Invalid constraint type `{0}'", ((ComposedCast)$1).GetSignatureForError ());
4357 | NEW OPEN_PARENS CLOSE_PARENS
4359 $$ = new SpecialContraintExpr (SpecialConstraint.Constructor, GetLocation ($1));
4363 $$ = new SpecialContraintExpr (SpecialConstraint.Class, GetLocation ($1));
4367 $$ = new SpecialContraintExpr (SpecialConstraint.Struct, GetLocation ($1));
4371 opt_type_parameter_variance
4376 | type_parameter_variance
4378 if (RootContext.MetadataCompatibilityVersion < MetadataVersion.v2)
4379 Report.FeatureIsNotSupported (lexer.Location, "generic type variance");
4380 else if (RootContext.Version <= LanguageVersion.V_3)
4381 Report.FeatureIsNotAvailable (lexer.Location, "generic type variance");
4387 type_parameter_variance
4390 $$ = Variance.Covariant;
4394 $$ = Variance.Contravariant;
4403 // A block is "contained" on the following places:
4405 // property_declaration as part of the accessor body (get/set)
4406 // operator_declaration
4407 // constructor_declaration
4408 // destructor_declaration
4409 // event_declaration as part of add_accessor_declaration or remove_accessor_declaration
4414 ++lexer.parsing_block;
4415 start_block (GetLocation ($1));
4417 opt_statement_list block_end
4426 --lexer.parsing_block;
4427 $$ = end_block (GetLocation ($1));
4429 | COMPLETE_COMPLETION
4431 --lexer.parsing_block;
4432 $$ = end_block (lexer.Location);
4440 ++lexer.parsing_block;
4441 current_block.StartLocation = GetLocation ($1);
4443 opt_statement_list CLOSE_BRACE
4445 --lexer.parsing_block;
4446 $$ = end_block (GetLocation ($4));
4457 | statement_list statement
4461 : declaration_statement
4463 if ($1 != null && (Block) $1 != current_block){
4464 current_block.AddStatement ((Statement) $1);
4465 current_block = (Block) $1;
4468 | valid_declaration_statement
4470 current_block.AddStatement ((Statement) $1);
4476 // The interactive_statement and its derivatives are only
4477 // used to provide a special version of `expression_statement'
4478 // that has a side effect of assigning the expression to
4481 interactive_statement_list
4482 : interactive_statement
4483 | interactive_statement_list interactive_statement
4486 interactive_statement
4487 : declaration_statement
4489 if ($1 != null && (Block) $1 != current_block){
4490 current_block.AddStatement ((Statement) $1);
4491 current_block = (Block) $1;
4494 | interactive_valid_declaration_statement
4496 current_block.AddStatement ((Statement) $1);
4501 valid_declaration_statement
4504 | expression_statement
4505 | selection_statement
4506 | iteration_statement
4510 | unchecked_statement
4517 interactive_valid_declaration_statement
4520 | interactive_expression_statement
4521 | selection_statement
4522 | iteration_statement
4526 | unchecked_statement
4534 : valid_declaration_statement
4535 | declaration_statement
4537 Report.Error (1023, GetLocation ($1), "An embedded statement may not be a declaration or labeled statement");
4542 Report.Error (1023, GetLocation ($1), "An embedded statement may not be a declaration or labeled statement");
4550 $$ = new EmptyStatement (GetLocation ($1));
4557 var lt = (Tokenizer.LocatedToken) $1;
4558 LabeledStatement labeled = new LabeledStatement (lt.Value, lt.Location);
4560 if (current_block.AddLabel (labeled))
4561 current_block.AddStatement (labeled);
4566 declaration_statement
4567 : local_variable_declaration SEMICOLON
4570 var de = (Tuple<FullNamedExpression, List<object>>) $1;
4571 $$ = declare_local_variables (de.Item1, de.Item2, de.Item1.Location);
4575 | local_constant_declaration SEMICOLON
4578 var de = (Tuple<FullNamedExpression, List<object>>) $1;
4580 $$ = declare_local_constants (de.Item1, de.Item2);
4586 * The following is from Rhys' grammar:
4587 * > Types in local variable declarations must be recognized as
4588 * > expressions to prevent reduce/reduce errors in the grammar.
4589 * > The expressions are converted into types during semantic analysis.
4592 : primary_expression_no_array_creation opt_rank_specifier_or_nullable
4594 // FIXME: Do something smart here regarding the composition of the type.
4596 // Ok, the above "primary_expression" is there to get rid of
4597 // both reduce/reduce and shift/reduces in the grammar, it should
4598 // really just be "type_name". If you use type_name, a reduce/reduce
4599 // creeps up. If you use namespace_or_type_name (which is all we need
4600 // really) two shift/reduces appear.
4603 // So the super-trick is that primary_expression
4604 // can only be either a SimpleName or a MemberAccess.
4605 // The MemberAccess case arises when you have a fully qualified type-name like :
4607 // SimpleName is when you have
4610 Expression expr = (Expression) $1;
4611 string rank_or_nullable = (string) $2;
4613 if (expr is ComposedCast){
4614 $$ = new ComposedCast ((ComposedCast)expr, rank_or_nullable);
4615 } else if (expr is ATypeNameExpression){
4617 // So we extract the string corresponding to the SimpleName
4620 if (rank_or_nullable.Length == 0) {
4621 SimpleName sn = expr as SimpleName;
4622 if (sn != null && sn.Name == "var")
4623 $$ = new VarExpr (sn.Location);
4627 $$ = new ComposedCast ((ATypeNameExpression)expr, rank_or_nullable);
4630 Error_ExpectingTypeName (expr);
4631 $$ = TypeManager.system_object_expr;
4634 | builtin_types opt_rank_specifier_or_nullable
4636 if ((string) $2 == "")
4639 $$ = new ComposedCast ((FullNamedExpression) $1, (string) $2, lexer.Location);
4641 | VOID opt_rank_specifier
4643 Expression.Error_VoidInvalidInTheContext (GetLocation ($1), Report);
4644 $$ = TypeManager.system_void_expr;
4648 local_variable_pointer_type
4649 : primary_expression_no_array_creation STAR
4651 ATypeNameExpression expr = $1 as ATypeNameExpression;
4654 $$ = new ComposedCast (expr, "*");
4656 Error_ExpectingTypeName ((Expression)$1);
4660 | builtin_types STAR
4662 $$ = new ComposedCast ((FullNamedExpression) $1, "*", GetLocation ($1));
4666 $$ = new ComposedCast (TypeManager.system_void_expr, "*", GetLocation ($1));
4668 | local_variable_pointer_type STAR
4670 $$ = new ComposedCast ((FullNamedExpression) $1, "*");
4676 | local_variable_pointer_type opt_rank_specifier
4679 string rank = (string)$2;
4684 $$ = new ComposedCast ((FullNamedExpression) $1, rank);
4691 local_variable_declaration
4692 : local_variable_type local_variable_declarators
4695 VarExpr ve = $1 as VarExpr;
4697 if (!((VariableDeclaration) ((List<object>)$2) [0]).HasInitializer)
4698 ve.VariableInitializersCount = 0;
4700 ve.VariableInitializersCount = ((List<object>)$2).Count;
4703 $$ = new Tuple<FullNamedExpression, List<object>> ((FullNamedExpression) $1, (List<object>) $2);
4709 local_constant_declaration
4710 : CONST variable_type constant_declarators
4713 $$ = new Tuple<FullNamedExpression, List<object>> ((FullNamedExpression) $2, (List<object>) $3);
4719 expression_statement
4720 : statement_expression SEMICOLON { $$ = $1; }
4721 | statement_expression COMPLETE_COMPLETION { $$ = $1; }
4724 interactive_expression_statement
4725 : interactive_statement_expression SEMICOLON { $$ = $1; }
4726 | interactive_statement_expression COMPLETE_COMPLETION { $$ = $1; }
4730 // We have to do the wrapping here and not in the case above,
4731 // because statement_expression is used for example in for_statement
4733 statement_expression
4736 ExpressionStatement s = $1 as ExpressionStatement;
4738 Expression.Error_InvalidExpressionStatement (Report, GetLocation ($1));
4739 s = EmptyExpressionStatement.Instance;
4742 $$ = new StatementExpression (s);
4746 Error_SyntaxError (yyToken);
4751 interactive_statement_expression
4754 Expression expr = (Expression) $1;
4755 ExpressionStatement s;
4757 s = new OptionalAssign (new SimpleName ("$retval", lexer.Location), expr, lexer.Location);
4758 $$ = new StatementExpression (s);
4762 Error_SyntaxError (yyToken);
4763 $$ = new EmptyStatement (GetLocation ($1));
4773 : IF open_parens_any boolean_expression CLOSE_PARENS
4776 if ($5 is EmptyStatement)
4777 Report.Warning (642, 3, GetLocation ($5), "Possible mistaken empty statement");
4779 $$ = new If ((BooleanExpression) $3, (Statement) $5, GetLocation ($1));
4781 | IF open_parens_any boolean_expression CLOSE_PARENS
4782 embedded_statement ELSE embedded_statement
4784 $$ = new If ((BooleanExpression) $3, (Statement) $5, (Statement) $7, GetLocation ($1));
4786 if ($5 is EmptyStatement)
4787 Report.Warning (642, 3, GetLocation ($5), "Possible mistaken empty statement");
4788 if ($7 is EmptyStatement)
4789 Report.Warning (642, 3, GetLocation ($7), "Possible mistaken empty statement");
4794 : SWITCH open_parens_any
4796 if (switch_stack == null)
4797 switch_stack = new Stack<Block> (2);
4798 switch_stack.Push (current_block);
4800 expression CLOSE_PARENS
4803 $$ = new Switch ((Expression) $4, (List<SwitchSection>) $6, GetLocation ($1));
4804 current_block = (Block) switch_stack.Pop ();
4820 Report.Warning (1522, 1, lexer.Location, "Empty switch block");
4821 $$ = new List<SwitchSection> ();
4829 var sections = new List<SwitchSection> (4);
4831 sections.Add ((SwitchSection) $1);
4834 | switch_sections switch_section
4836 var sections = (List<SwitchSection>) $1;
4838 sections.Add ((SwitchSection) $2);
4846 current_block = current_block.CreateSwitchBlock (lexer.Location);
4850 $$ = new SwitchSection ((List<SwitchLabel>) $1, current_block.Explicit);
4857 var labels = new List<SwitchLabel> (4);
4859 labels.Add ((SwitchLabel) $1);
4862 | switch_labels switch_label
4864 var labels = (List<SwitchLabel>) ($1);
4865 labels.Add ((SwitchLabel) $2);
4872 : CASE constant_expression COLON
4874 $$ = new SwitchLabel ((Expression) $2, GetLocation ($1));
4878 $$ = new SwitchLabel (null, GetLocation ($1));
4890 : WHILE open_parens_any boolean_expression CLOSE_PARENS embedded_statement
4892 Location l = GetLocation ($1);
4893 $$ = new While ((BooleanExpression) $3, (Statement) $5, l);
4898 : DO embedded_statement
4899 WHILE open_parens_any boolean_expression CLOSE_PARENS SEMICOLON
4901 Location l = GetLocation ($1);
4903 $$ = new Do ((Statement) $2, (BooleanExpression) $5, l);
4908 : FOR open_parens_any opt_for_initializer SEMICOLON
4910 Location l = lexer.Location;
4912 Block assign_block = current_block;
4914 if ($3 is Tuple<FullNamedExpression, List<object>>){
4915 var de = (Tuple<FullNamedExpression, List<object>>) $3;
4917 var type = de.Item1;
4919 foreach (VariableDeclaration decl in de.Item2){
4923 vi = current_block.AddVariable (type, decl.identifier, decl.Location);
4927 Expression expr = decl.GetInitializer (type);
4929 LocalVariableReference var;
4930 var = new LocalVariableReference (assign_block, decl.identifier, l);
4933 Assign a = new SimpleAssign (var, expr, decl.Location);
4935 assign_block.AddStatement (new StatementExpression (a));
4939 // Note: the $$ below refers to the value of this code block, not of the LHS non-terminal.
4940 // This can be referred to as $5 below.
4946 opt_for_condition SEMICOLON
4947 opt_for_iterator CLOSE_PARENS
4950 Location l = GetLocation ($1);
4952 For f = new For ((Statement) $5, (BooleanExpression) $6, (Statement) $8, (Statement) $10, l);
4954 current_block.AddStatement (f);
4956 $$ = end_block (lexer.Location);
4961 : /* empty */ { $$ = new EmptyStatement (lexer.Location); }
4966 : local_variable_declaration
4967 | statement_expression_list
4971 : /* empty */ { $$ = null; }
4972 | boolean_expression
4976 : /* empty */ { $$ = new EmptyStatement (lexer.Location); }
4981 : statement_expression_list
4984 statement_expression_list
4985 : statement_expression
4987 // CHANGE: was `null'
4988 Statement s = (Statement) $1;
4989 Block b = new Block (current_block, s.loc, lexer.Location);
4994 | statement_expression_list COMMA statement_expression
4996 Block b = (Block) $1;
4998 b.AddStatement ((Statement) $3);
5004 : FOREACH open_parens_any type IN expression CLOSE_PARENS
5006 Report.Error (230, GetLocation ($1), "Type and identifier are both required in a foreach statement");
5009 | FOREACH open_parens_any type IDENTIFIER IN
5010 expression CLOSE_PARENS
5012 start_block (lexer.Location);
5013 Block foreach_block = current_block;
5015 var lt = (Tokenizer.LocatedToken) $4;
5016 Location l = lt.Location;
5017 LocalInfo vi = foreach_block.AddVariable ((Expression) $3, lt.Value, l);
5019 vi.SetReadOnlyContext (LocalInfo.ReadOnlyContext.Foreach);
5021 // Get a writable reference to this read-only variable.
5023 // Note that the $$ here refers to the value of _this_ code block,
5024 // not the value of the LHS non-terminal. This can be referred to as $8 below.
5025 $$ = new LocalVariableReference (foreach_block, lt.Value, l, vi, false);
5032 LocalVariableReference v = (LocalVariableReference) $8;
5033 Location l = GetLocation ($1);
5036 Foreach f = new Foreach ((Expression) $3, v, (Expression) $6, (Statement) $9, l);
5037 current_block.AddStatement (f);
5040 $$ = end_block (lexer.Location);
5046 | continue_statement
5056 $$ = new Break (GetLocation ($1));
5061 : CONTINUE SEMICOLON
5063 $$ = new Continue (GetLocation ($1));
5068 : GOTO IDENTIFIER SEMICOLON
5070 var lt = (Tokenizer.LocatedToken) $2;
5071 $$ = new Goto (lt.Value, lt.Location);
5073 | GOTO CASE constant_expression SEMICOLON
5075 $$ = new GotoCase ((Expression) $3, GetLocation ($1));
5077 | GOTO DEFAULT SEMICOLON
5079 $$ = new GotoDefault (GetLocation ($1));
5084 : RETURN opt_expression SEMICOLON
5086 $$ = new Return ((Expression) $2, GetLocation ($1));
5091 : THROW opt_expression SEMICOLON
5093 $$ = new Throw ((Expression) $2, GetLocation ($1));
5098 : IDENTIFIER RETURN expression SEMICOLON
5100 var lt = (Tokenizer.LocatedToken) $1;
5101 string s = lt.Value;
5103 Report.Error (1003, lt.Location, "; expected");
5106 if (RootContext.Version == LanguageVersion.ISO_1){
5107 Report.FeatureIsNotAvailable (lt.Location, "yield statement");
5110 current_block.Toplevel.IsIterator = true;
5111 $$ = new Yield ((Expression) $3, lt.Location);
5113 | IDENTIFIER RETURN SEMICOLON
5115 Report.Error (1627, GetLocation ($2), "Expression expected after yield return");
5118 | IDENTIFIER BREAK SEMICOLON
5120 var lt = (Tokenizer.LocatedToken) $1;
5121 string s = lt.Value;
5123 Report.Error (1003, lt.Location, "; expected");
5126 if (RootContext.Version == LanguageVersion.ISO_1){
5127 Report.FeatureIsNotAvailable (lt.Location, "yield statement");
5131 current_block.Toplevel.IsIterator = true;
5132 $$ = new YieldBreak (lt.Location);
5142 : TRY block catch_clauses
5144 $$ = new TryCatch ((Block) $2, (List<Catch>) $3, GetLocation ($1), false);
5146 | TRY block FINALLY block
5148 $$ = new TryFinally ((Statement) $2, (Block) $4, GetLocation ($1));
5150 | TRY block catch_clauses FINALLY block
5152 $$ = new TryFinally (new TryCatch ((Block) $2, (List<Catch>) $3, GetLocation ($1), true), (Block) $5, GetLocation ($1));
5156 Report.Error (1524, GetLocation ($1), "Expected catch or finally");
5164 var l = new List<Catch> (2);
5169 | catch_clauses catch_clause
5171 var l = (List<Catch>) $1;
5173 Catch c = (Catch) $2;
5174 if (l [0].IsGeneral) {
5175 Report.Error (1017, c.loc, "Try statement already has an empty catch block");
5188 : /* empty */ { $$ = null; }
5193 : CATCH opt_catch_args
5196 var cc = (Tuple<FullNamedExpression, Tokenizer.LocatedToken>) $2;
5200 List<object> one = new List<object> (1);
5202 one.Add (new VariableDeclaration (lt, null));
5204 start_block (lexer.Location);
5205 current_block = declare_local_variables (cc.Item1, one, lt.Location);
5209 Expression type = null;
5211 Block var_block = null;
5214 var cc = (Tuple<FullNamedExpression, Tokenizer.LocatedToken>) $2;
5220 var_block = end_block (lexer.Location);
5224 $$ = new Catch (type, id, (Block) $4, var_block, ((Block) $4).loc);
5229 : /* empty */ { $$ = null; }
5234 : open_parens_any type opt_identifier CLOSE_PARENS
5236 $$ = new Tuple<FullNamedExpression, Tokenizer.LocatedToken> ((FullNamedExpression)$2, (Tokenizer.LocatedToken) $3);
5238 | open_parens_any CLOSE_PARENS
5240 Report.Error (1015, GetLocation ($1), "A type that derives from `System.Exception', `object', or `string' expected");
5248 $$ = new Checked ((Block) $2);
5255 $$ = new Unchecked ((Block) $2);
5262 RootContext.CheckUnsafeOption (GetLocation ($1), Report);
5264 $$ = new Unsafe ((Block) $3);
5269 : FIXED open_parens_any
5270 type_and_void fixed_pointer_declarators
5273 start_block (lexer.Location);
5277 Expression type = (Expression) $3;
5278 var list = (List<KeyValuePair<Tokenizer.LocatedToken, Expression>>) $4;
5279 Fixed f = new Fixed (type,
5280 list.ConvertAll (i => {
5281 var v = new KeyValuePair<LocalInfo, Expression> (current_block.AddVariable (type, i.Key.Value, i.Key.Location), i.Value);
5282 if (v.Key != null) {
5283 v.Key.SetReadOnlyContext (LocalInfo.ReadOnlyContext.Fixed);
5284 v.Key.Pinned = true;
5287 }), (Statement) $7, GetLocation ($1));
5289 current_block.AddStatement (f);
5291 $$ = end_block (lexer.Location);
5295 fixed_pointer_declarators
5296 : fixed_pointer_declarator {
5297 var declarators = new List<KeyValuePair<Tokenizer.LocatedToken, Expression>> (2);
5299 declarators.Add ((KeyValuePair<Tokenizer.LocatedToken, Expression>)$1);
5302 | fixed_pointer_declarators COMMA fixed_pointer_declarator
5304 var declarators = (List<KeyValuePair<Tokenizer.LocatedToken, Expression>>) $1;
5306 declarators.Add ((KeyValuePair<Tokenizer.LocatedToken, Expression>)$3);
5311 fixed_pointer_declarator
5312 : IDENTIFIER ASSIGN expression
5314 var lt = (Tokenizer.LocatedToken) $1;
5315 $$ = new KeyValuePair<Tokenizer.LocatedToken, Expression> (lt, (Expression) $3);
5319 Report.Error (210, ((Tokenizer.LocatedToken) $1).Location, "You must provide an initializer in a fixed or using statement declaration");
5325 : LOCK open_parens_any expression CLOSE_PARENS
5331 $$ = new Lock ((Expression) $3, (Statement) $6, GetLocation ($1));
5336 : USING open_parens_any local_variable_declaration CLOSE_PARENS
5338 start_block (lexer.Location);
5339 Block assign_block = current_block;
5341 var de = (Tuple<FullNamedExpression, List<object>>) $3;
5342 Location l = GetLocation ($1);
5344 var vars = new Stack<Tuple<LocalVariableReference, Expression>> ();
5346 foreach (VariableDeclaration decl in de.Item2) {
5347 LocalInfo vi = current_block.AddVariable (de.Item1, decl.identifier, decl.Location);
5350 vi.SetReadOnlyContext (LocalInfo.ReadOnlyContext.Using);
5352 Expression expr = decl.GetInitializer (de.Item1);
5354 Report.Error (210, l, "You must provide an initializer in a fixed or using statement declaration");
5357 LocalVariableReference var;
5359 // Get a writable reference to this read-only variable.
5360 var = new LocalVariableReference (assign_block, decl.identifier, l, vi, false);
5362 // This is so that it is not a warning on using variables
5365 vars.Push (new Tuple<LocalVariableReference, Expression> (var, expr));
5367 // Assign a = new SimpleAssign (var, expr, decl.Location);
5368 // assign_block.AddStatement (new StatementExpression (a));
5371 // Note: the $$ here refers to the value of this code block and not of the LHS non-terminal.
5372 // It can be referred to as $5 below.
5377 Statement stmt = (Statement) $6;
5378 var vars = (Stack<Tuple<LocalVariableReference, Expression>>) $5;
5379 Location l = GetLocation ($1);
5381 while (vars.Count > 0) {
5382 var de = vars.Pop ();
5383 stmt = new Using (de.Item1, de.Item2, stmt, l);
5385 current_block.AddStatement (stmt);
5386 $$ = end_block (lexer.Location);
5388 | USING open_parens_any expression CLOSE_PARENS
5390 start_block (lexer.Location);
5394 current_block.AddStatement (new UsingTemporary ((Expression) $3, (Statement) $6, GetLocation ($1)));
5395 $$ = end_block (lexer.Location);
5403 : first_from_clause query_body
5405 lexer.query_parsing = false;
5407 Linq.AQueryClause from = $1 as Linq.AQueryClause;
5409 from.Tail.Next = (Linq.AQueryClause)$2;
5412 current_block.SetEndLocation (lexer.Location);
5413 current_block = current_block.Parent;
5415 | nested_from_clause query_body
5417 Linq.AQueryClause from = $1 as Linq.AQueryClause;
5419 from.Tail.Next = (Linq.AQueryClause)$2;
5422 current_block.SetEndLocation (lexer.Location);
5423 current_block = current_block.Parent;
5426 // Bubble up COMPLETE_COMPLETION productions
5427 | first_from_clause COMPLETE_COMPLETION {
5428 lexer.query_parsing = false;
5431 current_block.SetEndLocation (lexer.Location);
5432 current_block = current_block.Parent;
5434 | nested_from_clause COMPLETE_COMPLETION {
5436 current_block.SetEndLocation (lexer.Location);
5437 current_block = current_block.Parent;
5442 : FROM_FIRST IDENTIFIER IN expression
5444 $$ = new Linq.QueryExpression (current_block, new Linq.QueryStartClause ((Expression)$4));
5445 var lt = (Tokenizer.LocatedToken) $2;
5446 current_block = new Linq.QueryBlock (compiler, current_block, new SimpleMemberName (lt.Value, lt.Location), GetLocation ($1));
5448 | FROM_FIRST type IDENTIFIER IN expression
5450 var lt = (Tokenizer.LocatedToken) $3;
5451 $$ = new Linq.QueryExpression (current_block, new Linq.Cast ((FullNamedExpression)$2, (Expression)$5));
5452 current_block = new Linq.QueryBlock (compiler, current_block, new SimpleMemberName (lt.Value, lt.Location), GetLocation ($1));
5457 : FROM IDENTIFIER IN expression
5459 $$ = new Linq.QueryExpression (current_block, new Linq.QueryStartClause ((Expression)$4));
5460 var lt = (Tokenizer.LocatedToken) $2;
5461 current_block = new Linq.QueryBlock (compiler, current_block, new SimpleMemberName (lt.Value, lt.Location), GetLocation ($1));
5463 | FROM type IDENTIFIER IN expression
5465 $$ = new Linq.QueryExpression (current_block, new Linq.Cast ((FullNamedExpression)$2, (Expression)$5));
5466 var lt = (Tokenizer.LocatedToken) $3;
5467 current_block = new Linq.QueryBlock (compiler, current_block, new SimpleMemberName (lt.Value, lt.Location), GetLocation ($1));
5472 : FROM IDENTIFIER IN
5474 current_block = new Linq.QueryBlock (compiler, current_block, GetLocation ($1));
5478 var lt = (Tokenizer.LocatedToken) $2;
5479 var sn = new SimpleMemberName (lt.Value, lt.Location);
5480 $$ = new Linq.SelectMany (current_block.Toplevel, sn, (Expression)$5);
5482 current_block.SetEndLocation (lexer.Location);
5483 current_block = current_block.Parent;
5485 ((Linq.QueryBlock)current_block).AddTransparentParameter (compiler, sn);
5487 | FROM type IDENTIFIER IN
5489 current_block = new Linq.QueryBlock (compiler, current_block, GetLocation ($1));
5493 var lt = (Tokenizer.LocatedToken) $3;
5494 var sn = new SimpleMemberName (lt.Value, lt.Location);
5496 FullNamedExpression type = (FullNamedExpression)$2;
5498 $$ = new Linq.SelectMany (current_block.Toplevel, sn, new Linq.Cast (type, (FullNamedExpression)$6));
5500 current_block.SetEndLocation (lexer.Location);
5501 current_block = current_block.Parent;
5503 ((Linq.QueryBlock)current_block).AddTransparentParameter (compiler, sn);
5508 : opt_query_body_clauses select_or_group_clause opt_query_continuation
5510 Linq.AQueryClause head = (Linq.AQueryClause)$2;
5513 head.Next = (Linq.AQueryClause)$3;
5516 Linq.AQueryClause clause = (Linq.AQueryClause)$1;
5517 clause.Tail.Next = head;
5523 | opt_query_body_clauses COMPLETE_COMPLETION
5526 select_or_group_clause
5529 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5533 $$ = new Linq.Select (current_block.Toplevel, (Expression)$3, GetLocation ($1));
5535 current_block.SetEndLocation (lexer.Location);
5536 current_block = current_block.Parent;
5540 if (linq_clause_blocks == null)
5541 linq_clause_blocks = new Stack<Block> ();
5543 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5544 linq_clause_blocks.Push (current_block);
5548 current_block.SetEndLocation (lexer.Location);
5549 current_block = current_block.Parent;
5551 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5555 $$ = new Linq.GroupBy (current_block.Toplevel, (Expression)$3, (ToplevelBlock) linq_clause_blocks.Pop (), (Expression)$6, GetLocation ($1));
5557 current_block.SetEndLocation (lexer.Location);
5558 current_block = current_block.Parent;
5562 opt_query_body_clauses
5564 | query_body_clauses
5569 | query_body_clauses query_body_clause
5571 ((Linq.AQueryClause)$1).Tail.Next = (Linq.AQueryClause)$2;
5585 : LET IDENTIFIER ASSIGN
5587 current_block = new Linq.QueryBlock (compiler, current_block, GetLocation ($1));
5591 var lt = (Tokenizer.LocatedToken) $2;
5592 var sn = new SimpleMemberName (lt.Value, lt.Location);
5593 $$ = new Linq.Let (current_block.Toplevel, current_container, sn, (Expression)$5);
5595 current_block.SetEndLocation (lexer.Location);
5596 current_block = current_block.Parent;
5598 ((Linq.QueryBlock)current_block).AddTransparentParameter (compiler, sn);
5605 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5609 $$ = new Linq.Where (current_block.Toplevel, (BooleanExpression)$3, GetLocation ($1));
5611 current_block.SetEndLocation (lexer.Location);
5612 current_block = current_block.Parent;
5617 : JOIN IDENTIFIER IN
5619 if (linq_clause_blocks == null)
5620 linq_clause_blocks = new Stack<Block> ();
5622 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5623 linq_clause_blocks.Push (current_block);
5627 current_block.SetEndLocation (lexer.Location);
5628 current_block = current_block.Parent;
5630 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5631 linq_clause_blocks.Push (current_block);
5635 current_block.AddStatement (new ContextualReturn ((Expression) $8));
5636 current_block.SetEndLocation (lexer.Location);
5637 current_block = current_block.Parent;
5639 var lt = (Tokenizer.LocatedToken) $2;
5640 current_block = new Linq.QueryBlock (compiler, current_block, new SimpleMemberName (lt.Value, lt.Location), lexer.Location);
5642 expression opt_join_into
5644 var lt = (Tokenizer.LocatedToken) $2;
5645 var sn = new SimpleMemberName (lt.Value, lt.Location);
5646 SimpleMemberName sn2 = null;
5648 ToplevelBlock outer_selector = (ToplevelBlock) linq_clause_blocks.Pop ();
5649 ToplevelBlock block = (ToplevelBlock) linq_clause_blocks.Pop ();
5652 $$ = new Linq.Join (block, sn, (Expression)$5, outer_selector, current_block.Toplevel, GetLocation ($1));
5654 var lt2 = (Tokenizer.LocatedToken) $12;
5655 sn2 = new SimpleMemberName (lt2.Value, lt2.Location);
5656 $$ = new Linq.GroupJoin (block, sn, (Expression)$5, outer_selector, current_block.Toplevel,
5657 sn2, GetLocation ($1));
5660 current_block.AddStatement (new ContextualReturn ((Expression) $11));
5661 current_block.SetEndLocation (lexer.Location);
5662 current_block = current_block.Parent;
5665 ((Linq.QueryBlock)current_block).AddTransparentParameter (compiler, sn);
5667 ((Linq.QueryBlock)current_block).AddTransparentParameter (compiler, sn2);
5669 | JOIN type IDENTIFIER IN
5671 if (linq_clause_blocks == null)
5672 linq_clause_blocks = new Stack<Block> ();
5674 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5675 linq_clause_blocks.Push (current_block);
5679 current_block.SetEndLocation (lexer.Location);
5680 current_block = current_block.Parent;
5682 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5683 linq_clause_blocks.Push (current_block);
5687 current_block.AddStatement (new ContextualReturn ((Expression) $9));
5688 current_block.SetEndLocation (lexer.Location);
5689 current_block = current_block.Parent;
5691 var lt = (Tokenizer.LocatedToken) $3;
5692 current_block = new Linq.QueryBlock (compiler, current_block, new SimpleMemberName (lt.Value, lt.Location), lexer.Location);
5694 expression opt_join_into
5696 var lt = (Tokenizer.LocatedToken) $3;
5697 var sn = new SimpleMemberName (lt.Value, lt.Location);
5698 SimpleMemberName sn2 = null;
5699 ToplevelBlock outer_selector = (ToplevelBlock) linq_clause_blocks.Pop ();
5700 ToplevelBlock block = (ToplevelBlock) linq_clause_blocks.Pop ();
5702 Linq.Cast cast = new Linq.Cast ((FullNamedExpression)$2, (Expression)$6);
5704 $$ = new Linq.Join (block, sn, cast, outer_selector, current_block.Toplevel, GetLocation ($1));
5706 var lt2 = (Tokenizer.LocatedToken) $13;
5707 sn2 = new SimpleMemberName (lt2.Value, lt2.Location);
5708 $$ = new Linq.GroupJoin (block, sn, cast, outer_selector, current_block.Toplevel,
5709 sn2, GetLocation ($1));
5712 current_block.AddStatement (new ContextualReturn ((Expression) $12));
5713 current_block.SetEndLocation (lexer.Location);
5714 current_block = current_block.Parent;
5717 ((Linq.QueryBlock)current_block).AddTransparentParameter (compiler, sn);
5719 ((Linq.QueryBlock)current_block).AddTransparentParameter (compiler, sn2);
5734 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5738 current_block.SetEndLocation (lexer.Location);
5739 current_block = current_block.Parent;
5749 current_block.SetEndLocation (lexer.Location);
5750 current_block = current_block.Parent;
5752 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5756 ((Linq.AQueryClause)$1).Next = (Linq.AQueryClause)$4;
5763 | orderings_then_by COMMA
5765 current_block.SetEndLocation (lexer.Location);
5766 current_block = current_block.Parent;
5768 current_block = new Linq.QueryBlock (compiler, current_block, lexer.Location);
5772 ((Linq.AQueryClause)$1).Tail.Next = (Linq.AQueryClause)$3;
5780 $$ = new Linq.OrderByAscending (current_block.Toplevel, (Expression)$1);
5782 | expression ASCENDING
5784 $$ = new Linq.OrderByAscending (current_block.Toplevel, (Expression)$1);
5786 | expression DESCENDING
5788 $$ = new Linq.OrderByDescending (current_block.Toplevel, (Expression)$1);
5795 $$ = new Linq.ThenByAscending (current_block.Toplevel, (Expression)$1);
5797 | expression ASCENDING
5799 $$ = new Linq.ThenByAscending (current_block.Toplevel, (Expression)$1);
5801 | expression DESCENDING
5803 $$ = new Linq.ThenByDescending (current_block.Toplevel, (Expression)$1);
5808 opt_query_continuation
5812 // query continuation block is not linked with query block but with block
5813 // before. This means each query can use same range variable names for
5814 // different identifiers.
5816 current_block.SetEndLocation (GetLocation ($1));
5817 current_block = current_block.Parent;
5819 var lt = (Tokenizer.LocatedToken) $2;
5821 current_block = new Linq.QueryBlock (compiler, current_block, new SimpleMemberName (lt.Value, lt.Location), GetLocation ($1));
5825 $$ = new Linq.QueryExpression (current_block, (Linq.AQueryClause)$4);
5830 // Support for using the compiler as an interactive parser
5832 // The INTERACTIVE_PARSER token is first sent to parse our
5833 // productions; If the result is a Statement, the parsing
5834 // is repeated, this time with INTERACTIVE_PARSE_WITH_BLOCK
5835 // to setup the blocks in advance.
5837 // This setup is here so that in the future we can add
5838 // support for other constructs (type parsing, namespaces, etc)
5839 // that do not require a block to be setup in advance
5843 : EVAL_STATEMENT_PARSER EOF
5844 | EVAL_USING_DECLARATIONS_UNIT_PARSER using_directives
5845 | EVAL_STATEMENT_PARSER {
5846 Evaluator.LoadAliases (current_namespace);
5848 push_current_class (new Class (current_namespace, current_class, new MemberName ("Class" + class_count++),
5849 Modifiers.PUBLIC, null), null);
5851 var baseclass_list = new List<FullNamedExpression> ();
5852 baseclass_list.Add (new TypeExpression (Evaluator.InteractiveBaseClass, lexer.Location));
5853 current_container.AddBasesForPart (current_class, baseclass_list);
5855 // (ref object retval)
5856 Parameter [] mpar = new Parameter [1];
5857 mpar [0] = new Parameter (TypeManager.system_object_expr, "$retval", Parameter.Modifier.REF, null, Location.Null);
5859 ParametersCompiled pars = new ParametersCompiled (compiler, mpar);
5860 current_local_parameters = pars;
5861 Method method = new Method (
5864 TypeManager.system_void_expr,
5865 Modifiers.PUBLIC | Modifiers.STATIC,
5866 new MemberName ("Host"),
5868 null /* attributes */);
5870 oob_stack.Push (method);
5871 ++lexer.parsing_block;
5872 start_block (lexer.Location);
5874 interactive_statement_list opt_COMPLETE_COMPLETION
5876 --lexer.parsing_block;
5877 Method method = (Method) oob_stack.Pop ();
5879 method.Block = (ToplevelBlock) end_block(lexer.Location);
5880 current_container.AddMethod (method);
5882 --lexer.parsing_declaration;
5883 InteractiveResult = pop_current_class ();
5884 current_local_parameters = null;
5886 | EVAL_COMPILATION_UNIT_PARSER {
5887 Evaluator.LoadAliases (current_namespace);
5889 interactive_compilation_unit
5892 interactive_compilation_unit
5893 : outer_declarations
5894 | outer_declarations global_attributes
5899 opt_COMPLETE_COMPLETION
5901 | COMPLETE_COMPLETION
5904 close_brace_or_complete_completion
5906 | COMPLETE_COMPLETION
5911 // A class used to pass around variable declarations and constants
5913 class VariableDeclaration {
5914 public string identifier;
5915 Expression initializer;
5916 public Location Location;
5917 public Attributes OptAttributes;
5918 public string DocComment;
5920 public VariableDeclaration (Tokenizer.LocatedToken lt, Expression initializer, Attributes opt_attrs)
5922 this.identifier = lt.Value;
5923 this.initializer = initializer;
5924 this.Location = lt.Location;
5925 this.OptAttributes = opt_attrs;
5928 public VariableDeclaration (Tokenizer.LocatedToken lt, Expression initializer)
5929 : this (lt, initializer, null)
5933 public Expression GetInitializer (FullNamedExpression type)
5935 if (initializer is ArrayInitializer)
5936 return new ArrayCreation (type, "", (ArrayInitializer)initializer, Location);
5941 public bool HasInitializer {
5942 get { return initializer != null; }
5946 class VariableMemberDeclaration
5948 public readonly MemberName MemberName;
5949 Expression initializer;
5951 public VariableMemberDeclaration (MemberName mn, Expression initializer)
5954 this.initializer = initializer;
5957 public Expression GetInitializer (FullNamedExpression type)
5959 if (initializer is ArrayInitializer)
5960 return new ArrayCreation (type, "", (ArrayInitializer)initializer, MemberName.Location);
5968 // A class used to hold info about an operator declarator
5970 struct OperatorDeclaration {
5971 public readonly Operator.OpType optype;
5972 public readonly FullNamedExpression ret_type;
5973 public readonly Location location;
5975 public OperatorDeclaration (Operator.OpType op, FullNamedExpression ret_type, Location location)
5978 this.ret_type = ret_type;
5979 this.location = location;
5983 void Error_ExpectingTypeName (Expression expr)
5985 if (expr is Invocation){
5986 Report.Error (1002, expr.Location, "Expecting `;'");
5988 Expression.Error_InvalidExpressionStatement (Report, expr.Location);
5992 void Error_ParameterModifierNotValid (string modifier, Location loc)
5994 Report.Error (631, loc, "The parameter modifier `{0}' is not valid in this context",
5998 void Error_DuplicateParameterModifier (Location loc, Parameter.Modifier mod)
6000 Report.Error (1107, loc, "Duplicate parameter modifier `{0}'",
6001 Parameter.GetModifierSignature (mod));
6004 void Error_TypeExpected (Location loc)
6006 Report.Error (1031, loc, "Type expected");
6009 void Error_NamedArgumentExpected (NamedArgument a)
6011 Report.Error (1738, a.Location, "Named arguments must appear after the positional arguments");
6014 void push_current_class (TypeContainer tc, object partial_token)
6016 if (RootContext.EvalMode){
6017 tc.ModFlags = (tc.ModFlags & ~(Modifiers.PRIVATE|Modifiers.INTERNAL)) | Modifiers.PUBLIC;
6018 undo.AddTypeContainer (current_container, tc);
6021 if (partial_token != null)
6022 current_container = current_container.AddPartial (tc);
6024 current_container = current_container.AddTypeContainer (tc);
6026 ++lexer.parsing_declaration;
6030 DeclSpace pop_current_class ()
6032 DeclSpace retval = current_class;
6034 current_class = current_class.Parent;
6035 current_container = current_class.PartialContainer;
6041 // Given the @class_name name, it creates a fully qualified name
6042 // based on the containing declaration space
6045 MakeName (MemberName class_name)
6047 Namespace ns = current_namespace.NS;
6049 if (current_container == RootContext.ToplevelTypes) {
6050 if (ns.Name.Length != 0)
6051 return new MemberName (ns.MemberName, class_name);
6055 return new MemberName (current_container.MemberName, class_name);
6059 Block declare_local_variables (FullNamedExpression type, List<object> variable_declarators, Location loc)
6061 Block implicit_block;
6064 // If we are doing interactive editing, we want variable declarations
6065 // that are in the top block to be added instead to the class as
6068 if (RootContext.StatementMode){
6071 for (Block b = current_block; b != null; b = b.Parent){
6072 if (b is ExplicitBlock && !(b is ToplevelBlock)){
6073 // There has been an explicit block, we cant add to the class
6080 // We can use "current_block" since we know there are no explicit blocks
6082 foreach (VariableDeclaration decl in variable_declarators){
6083 // We can not use the super-handy f.Initializer, because
6084 // multiple lines would force code to be executed out of sync
6085 var init = decl.GetInitializer (type);
6087 string id = "$" + decl.identifier;
6088 LocalInfo vi = current_block.AddVariable (type, id, decl.Location);
6090 // Avoid warning about this variable not being used.
6093 LocalVariableReference var;
6094 var = new LocalVariableReferenceWithClassSideEffect (current_container, decl.identifier, current_block, id, vi, decl.Location);
6095 Assign assign = new SimpleAssign (var, init, decl.Location);
6096 current_block.AddStatement (new StatementExpression (assign));
6097 assign = new SimpleAssign (new SimpleName (decl.identifier, decl.Location), var);
6098 current_block.AddStatement (new StatementExpression (assign));
6100 Field f = new Field (current_container, (FullNamedExpression) type, Modifiers.PUBLIC | Modifiers.STATIC,
6101 new MemberName (decl.identifier, loc), null);
6102 current_container.AddField (f);
6104 // Register the field to be visible later as a global variable
6105 Evaluator.QueueField (f);
6109 return current_block;
6114 // We use the `Used' property to check whether statements
6115 // have been added to the current block. If so, we need
6116 // to create another block to contain the new declaration
6117 // otherwise, as an optimization, we use the same block to
6118 // add the declaration.
6120 // FIXME: A further optimization is to check if the statements
6121 // that were added were added as part of the initialization
6122 // below. In which case, no other statements have been executed
6123 // and we might be able to reduce the number of blocks for
6124 // situations like this:
6126 // int j = 1; int k = j + 1;
6128 if (current_block.Used)
6129 implicit_block = new Block (current_block, loc, lexer.Location);
6131 implicit_block = current_block;
6133 foreach (VariableDeclaration decl in variable_declarators){
6135 if (implicit_block.AddVariable (type, decl.identifier, decl.Location) != null) {
6136 if (decl.HasInitializer){
6139 var lvr = new LocalVariableReference (implicit_block, decl.identifier, loc);
6141 assign = new SimpleAssign (lvr, decl.GetInitializer (type), decl.Location);
6143 implicit_block.AddStatement (new StatementExpression (assign));
6148 return implicit_block;
6151 Block declare_local_constants (FullNamedExpression type, List<object> declarators)
6153 Block implicit_block;
6155 if (current_block.Used)
6156 implicit_block = new Block (current_block);
6158 implicit_block = current_block;
6160 foreach (VariableDeclaration decl in declarators){
6161 implicit_block.AddConstant (type, decl.identifier, decl.GetInitializer (type), decl.Location);
6164 return implicit_block;
6167 string CheckAttributeTarget (string a, Location l)
6170 case "assembly" : case "module" : case "field" : case "method" : case "param" : case "property" : case "type" :
6174 Report.Warning (658, 1, l,
6175 "`{0}' is invalid attribute target. All attributes in this attribute section will be ignored", a);
6176 return string.Empty;
6179 static bool IsUnaryOperator (Operator.OpType op)
6183 case Operator.OpType.LogicalNot:
6184 case Operator.OpType.OnesComplement:
6185 case Operator.OpType.Increment:
6186 case Operator.OpType.Decrement:
6187 case Operator.OpType.True:
6188 case Operator.OpType.False:
6189 case Operator.OpType.UnaryPlus:
6190 case Operator.OpType.UnaryNegation:
6196 void syntax_error (Location l, string msg)
6198 Report.Error (1003, l, "Syntax error, " + msg);
6203 public Tokenizer Lexer {
6209 static CSharpParser ()
6211 oob_stack = new Stack<object> ();
6214 public CSharpParser (SeekableStreamReader reader, CompilationUnit file, CompilerContext ctx)
6216 if (RootContext.EvalMode)
6220 this.compiler = ctx;
6221 current_namespace = new NamespaceEntry (null, file, null);
6222 current_class = current_namespace.SlaveDeclSpace;
6223 current_container = current_class.PartialContainer; // == RootContest.ToplevelTypes
6225 lexer = new Tokenizer (reader, file, ctx);
6227 use_global_stacks = true;
6230 public void parse ()
6232 eof_token = Token.EOF;
6233 Tokenizer.LocatedToken.Initialize ();
6236 if (yacc_verbose_flag > 1)
6237 yyparse (lexer, new yydebug.yyDebugSimple ());
6241 Tokenizer tokenizer = lexer as Tokenizer;
6242 tokenizer.cleanup ();
6243 } catch (Exception e){
6244 if (e is yyParser.yyUnexpectedEof)
6245 UnexpectedEOF = true;
6247 if (e is yyParser.yyException)
6248 Report.Error (-25, lexer.Location, "Parsing error");
6249 else if (yacc_verbose_flag > 0)
6250 throw; // Used by compiler-tester to test internal errors
6252 Report.Error (589, lexer.Location, "Internal compiler error during parsing");
6255 if (RootContext.ToplevelTypes.NamespaceEntry != null)
6256 throw new InternalErrorException ("who set it?");
6259 void CheckToken (int error, int yyToken, string msg, Location loc)
6261 if (yyToken >= Token.FIRST_KEYWORD && yyToken <= Token.LAST_KEYWORD)
6262 Report.Error (error, loc, "{0}: `{1}' is a keyword", msg, GetTokenName (yyToken));
6264 Report.Error (error, loc, msg);
6267 void CheckIdentifierToken (int yyToken, Location loc)
6269 CheckToken (1041, yyToken, "Identifier expected", loc);
6272 string ConsumeStoredComment ()
6274 string s = tmpComment;
6276 Lexer.doc_state = XmlCommentState.Allowed;
6280 Location GetLocation (object obj)
6282 if (obj is Tokenizer.LocatedToken)
6283 return ((Tokenizer.LocatedToken) obj).Location;
6284 if (obj is MemberName)
6285 return ((MemberName) obj).Location;
6287 // if (obj is Expression)
6288 // return ((Expression) obj).Location;
6290 return lexer.Location;
6294 get { return compiler.Report; }
6297 void start_block (Location loc)
6299 if (current_block == null || parsing_anonymous_method) {
6300 current_block = new ToplevelBlock (compiler, current_block, current_local_parameters, current_generic_method, loc);
6301 parsing_anonymous_method = false;
6303 current_block = new ExplicitBlock (current_block, loc, Location.Null);
6308 end_block (Location loc)
6310 Block retval = current_block.Explicit;
6311 retval.SetEndLocation (loc);
6312 current_block = retval.Parent;
6317 start_anonymous (bool lambda, ParametersCompiled parameters, Location loc)
6319 if (RootContext.Version == LanguageVersion.ISO_1){
6320 Report.FeatureIsNotAvailable (loc, "anonymous methods");
6323 oob_stack.Push (current_anonymous_method);
6324 oob_stack.Push (current_local_parameters);
6326 current_local_parameters = parameters;
6328 current_anonymous_method = lambda
6329 ? new LambdaExpression (loc)
6330 : new AnonymousMethodExpression (loc);
6332 // Force the next block to be created as a ToplevelBlock
6333 parsing_anonymous_method = true;
6337 * Completes the anonymous method processing, if lambda_expr is null, this
6338 * means that we have a Statement instead of an Expression embedded
6340 AnonymousMethodExpression end_anonymous (ToplevelBlock anon_block)
6342 AnonymousMethodExpression retval;
6344 current_anonymous_method.Block = anon_block;
6345 retval = current_anonymous_method;
6347 current_local_parameters = (ParametersCompiled) oob_stack.Pop ();
6348 current_anonymous_method = (AnonymousMethodExpression) oob_stack.Pop ();
6353 public NamespaceEntry CurrentNamespace {
6355 return current_namespace;
6360 void Error_SyntaxError (int token)
6362 Error_SyntaxError (0, token, "Unexpected symbol");
6365 void Error_SyntaxError (int error_code, int token, string msg)
6367 string symbol = GetSymbolName (token);
6368 string expecting = GetExpecting ();
6370 if (error_code == 0) {
6371 if (expecting == "`)'")
6377 if (expecting != null)
6378 Report.Error (error_code, lexer.Location, "{2} `{0}', expecting {1}",
6379 symbol, expecting, msg);
6381 Report.Error (error_code, lexer.Location, "{1} `{0}'", symbol, msg);
6384 string GetExpecting ()
6386 int [] tokens = yyExpectingTokens (yyExpectingState);
6387 var names = new List<string> (tokens.Length);
6388 bool has_type = false;
6389 bool has_identifier = false;
6390 for (int i = 0; i < tokens.Length; i++){
6391 int token = tokens [i];
6392 has_identifier |= token == Token.IDENTIFIER;
6394 string name = GetTokenName (token);
6395 if (name == "<internal>")
6398 has_type |= name == "type";
6399 if (names.Contains (name))
6406 // Too many tokens to enumerate
6408 if (names.Count > 8)
6411 if (has_type && has_identifier)
6412 names.Remove ("identifier");
6414 if (names.Count == 1)
6415 return "`" + GetTokenName (tokens [0]) + "'";
6417 StringBuilder sb = new StringBuilder ();
6419 int count = names.Count;
6420 for (int i = 0; i < count; i++){
6421 bool last = i + 1 == count;
6425 sb.Append (names [i]);
6426 sb.Append (last ? "'" : count < 3 ? "' " : "', ");
6428 return sb.ToString ();
6432 string GetSymbolName (int token)
6436 return ((Constant)lexer.Value).GetValue ().ToString ();
6437 case Token.IDENTIFIER:
6438 return ((Tokenizer.LocatedToken)lexer.Value).Value;
6480 case Token.BITWISE_AND:
6482 case Token.BITWISE_OR:
6496 case Token.OP_SHIFT_LEFT:
6498 case Token.OP_SHIFT_RIGHT:
6518 case Token.OP_COALESCING:
6520 case Token.OP_MULT_ASSIGN:
6522 case Token.OP_DIV_ASSIGN:
6524 case Token.OP_MOD_ASSIGN:
6526 case Token.OP_ADD_ASSIGN:
6528 case Token.OP_SUB_ASSIGN:
6530 case Token.OP_SHIFT_LEFT_ASSIGN:
6532 case Token.OP_SHIFT_RIGHT_ASSIGN:
6534 case Token.OP_AND_ASSIGN:
6536 case Token.OP_XOR_ASSIGN:
6538 case Token.OP_OR_ASSIGN:
6542 return GetTokenName (token);
6545 static string GetTokenName (int token)
6548 case Token.ABSTRACT:
6568 case Token.CONTINUE:
6572 case Token.DELEGATE:
6582 case Token.EXPLICIT:
6600 case Token.IMPLICIT:
6604 case Token.INTERFACE:
6606 case Token.INTERNAL:
6612 case Token.NAMESPACE:
6618 case Token.OPERATOR:
6622 case Token.OVERRIDE:
6628 case Token.PROTECTED:
6632 case Token.READONLY:
6644 case Token.STACKALLOC:
6645 return "stackalloc";
6662 case Token.UNCHECKED:
6670 case Token.VOLATILE:
6683 case Token.FROM_FIRST:
6701 case Token.ASCENDING:
6703 case Token.DESCENDING:
6704 return "descending";
6711 case Token.OPEN_BRACE:
6713 case Token.CLOSE_BRACE:
6715 case Token.OPEN_BRACKET:
6717 case Token.CLOSE_BRACKET:
6719 case Token.OPEN_PARENS_CAST:
6720 case Token.OPEN_PARENS_LAMBDA:
6721 case Token.OPEN_PARENS:
6723 case Token.CLOSE_PARENS:
6729 case Token.DEFAULT_COLON:
6733 case Token.SEMICOLON:
6744 case Token.BITWISE_AND:
6745 case Token.BITWISE_OR:
6752 case Token.OP_SHIFT_LEFT:
6753 case Token.OP_SHIFT_RIGHT:
6761 case Token.OP_COALESCING:
6762 case Token.OP_MULT_ASSIGN:
6763 case Token.OP_DIV_ASSIGN:
6764 case Token.OP_MOD_ASSIGN:
6765 case Token.OP_ADD_ASSIGN:
6766 case Token.OP_SUB_ASSIGN:
6767 case Token.OP_SHIFT_LEFT_ASSIGN:
6768 case Token.OP_SHIFT_RIGHT_ASSIGN:
6769 case Token.OP_AND_ASSIGN:
6770 case Token.OP_XOR_ASSIGN:
6771 case Token.OP_OR_ASSIGN:
6772 return "<operator>";
6794 case Token.OP_GENERICS_LT:
6795 case Token.GENERIC_DIMENSION:
6797 case Token.OP_GENERICS_GT:
6800 case Token.INTERR_NULLABLE:
6802 case Token.DOUBLE_COLON:
6806 case Token.IDENTIFIER:
6807 return "identifier";
6809 // All of these are internal.
6812 case Token.FIRST_KEYWORD:
6814 case Token.EVAL_COMPILATION_UNIT_PARSER:
6815 case Token.EVAL_USING_DECLARATIONS_UNIT_PARSER:
6816 case Token.EVAL_STATEMENT_PARSER:
6817 case Token.LAST_KEYWORD:
6818 case Token.GENERATE_COMPLETION:
6819 case Token.COMPLETE_COMPLETION:
6820 return "<internal>";
6822 // A bit more robust.
6824 return yyNames [token];