mcs/ilasm/parser/ILParser.jay

   1 %{\r
   2 //\r
   3 // Mono::ILASM::ILParser\r
   4 // \r
   5 // (C) Sergey Chaban (serge@wildwestsoftware.com)\r
   6 // (C) 2003 Jackson Harper, All rights reserved\r
   7 //\r
   8 \r
   9 using PEAPI;\r
  10 using System;\r
  11 using System.IO;\r
  12 using System.Collections;\r
  13 using System.Collections.Generic;\r
  14 using System.Globalization;\r
  15 using System.Reflection;\r
  16 using System.Security;\r
  17 using System.Security.Permissions;\r
  18 \r
  19 using MIPermission = Mono.ILASM.Permission;\r
  20 using MIPermissionSet = Mono.ILASM.PermissionSet;\r
  21 \r
  22 namespace Mono.ILASM {\r
  23 \r
  24         public class ILParser {\r
  25 \r
  26                 private CodeGen codegen;\r
  27 \r
  28                 private bool is_value_class;\r
  29                 private bool is_enum_class;\r
  30                 private bool pinvoke_info;\r
  31                 private string pinvoke_mod;\r
  32                 private string pinvoke_meth;\r
  33                 private PEAPI.PInvokeAttr pinvoke_attr;\r
  34                 private ILTokenizer tokenizer;\r
  35                 const int yacc_verbose_flag = 0;\r
  36                 KeyValuePair<string, TypeAttr> current_extern;\r
  37 \r
  38                 class NameValuePair {\r
  39                         public string Name;\r
  40                         public object Value;\r
  41 \r
  42                         public NameValuePair (string name, object value)\r
  43                         {\r
  44                                 this.Name = name;\r
  45                                 this.Value = value;\r
  46                         }\r
  47                 }\r
  48 \r
  49                 class PermPair {\r
  50                         public PEAPI.SecurityAction sec_action;\r
  51                         public object perm;\r
  52 \r
  53                         public PermPair (PEAPI.SecurityAction sec_action, object perm)\r
  54                         {\r
  55                                 this.sec_action = sec_action;\r
  56                                 this.perm = perm;\r
  57                         }\r
  58                 }\r
  59 \r
  60                 public bool CheckSecurityActionValidity (System.Security.Permissions.SecurityAction action, bool for_assembly)\r
  61                 {\r
  62 #pragma warning disable 618\r
  63                         if ((action == System.Security.Permissions.SecurityAction.RequestMinimum || \r
  64                                 action == System.Security.Permissions.SecurityAction.RequestOptional || \r
  65                                 action == System.Security.Permissions.SecurityAction.RequestRefuse) && !for_assembly) {\r
  66                                 Report.Warning (String.Format ("System.Security.Permissions.SecurityAction '{0}' is not valid for this declaration", action));\r
  67                                 return false;\r
  68                         }\r
  69 #pragma warning restore 618\r
  70                         return true;\r
  71                 }\r
  72 \r
  73                 public void AddSecDecl (object perm, bool for_assembly)\r
  74                 {\r
  75                         PermPair pp = perm as PermPair;\r
  76 \r
  77                         if (pp == null) {\r
  78                                 MIPermissionSet ps_20 = (MIPermissionSet) perm;\r
  79                                 codegen.AddPermission (ps_20.SecurityAction, ps_20);\r
  80                                 return;\r
  81                         }\r
  82 \r
  83                         if (!CheckSecurityActionValidity ((System.Security.Permissions.SecurityAction) pp.sec_action, for_assembly))\r
  84                                 Report.Error (String.Format ("Invalid security action : {0}", pp.sec_action));\r
  85 \r
  86                         codegen.AddPermission (pp.sec_action, pp.perm);\r
  87                 }\r
  88 \r
  89                 public object ClassRefToObject (object class_ref, object val)\r
  90                 {\r
  91                         ExternTypeRef etr = class_ref as ExternTypeRef;\r
  92                         if (etr == null)\r
  93                                 /* FIXME: report error? can be PrimitiveTypeRef or TypeRef */\r
  94                                 return null;\r
  95                                 \r
  96                         System.Type t = etr.GetReflectedType ();\r
  97                         return (t.IsEnum ? Enum.Parse (t, String.Format ("{0}", val)) : val);\r
  98                 }\r
  99 \r
 100                 /* Converts a type_spec to a corresponding PermPair */\r
 101                 PermPair TypeSpecToPermPair (object action, object type_spec, ArrayList pairs)\r
 102                 {\r
 103                         ExternTypeRef etr = type_spec as ExternTypeRef;\r
 104                         if (etr == null)\r
 105                                 /* FIXME: could be PrimitiveTypeRef or TypeRef \r
 106                                           Report what error? */\r
 107                                 return null;\r
 108 \r
 109                         System.Type t = etr.GetReflectedType ();\r
 110                         object obj = Activator.CreateInstance (t, \r
 111                                                 new object [] {(System.Security.Permissions.SecurityAction) (short) action});\r
 112 \r
 113                         if (pairs != null)\r
 114                                 foreach (NameValuePair pair in pairs) {\r
 115                                         PropertyInfo pi = t.GetProperty (pair.Name);\r
 116                                         pi.SetValue (obj, pair.Value, null);\r
 117                                 }\r
 118 \r
 119                         IPermission iper = (IPermission) t.GetMethod ("CreatePermission").Invoke (obj, null);\r
 120                         return new PermPair ((PEAPI.SecurityAction) action, iper);\r
 121                 }\r
 122 \r
 123                 public ILParser (CodeGen codegen, ILTokenizer tokenizer)\r
 124                 {\r
 125                         this.codegen = codegen;\r
 126                         this.tokenizer = tokenizer;\r
 127                 }\r
 128 \r
 129                 public CodeGen CodeGen {\r
 130                         get { return codegen; }\r
 131                 }\r
 132 \r
 133                 private BaseTypeRef GetTypeRef (BaseTypeRef b)\r
 134                 {\r
 135                         //FIXME: Caching required.. \r
 136                         return b.Clone ();\r
 137                 }\r
 138 \r
 139 %}\r
 140 \r
 141 %token EOF\r
 142 \r
 143 /* ID - alpha-numeric identifier */\r
 144 %token ID\r
 145 \r
 146 /* QSTRING - quoted string */\r
 147 %token QSTRING\r
 148 \r
 149 /* SQSTRING - single quoted string */\r
 150 %token SQSTRING\r
 151 \r
 152 /* COMP_NAME - A name with dots */\r
 153 %token COMP_NAME\r
 154 \r
 155 /* INT32 - 32 bit integer */\r
 156 %token INT32\r
 157 \r
 158 /* INT64 - 64 bit integer */\r
 159 %token INT64\r
 160 \r
 161 /* FLOAT64 - floating point number */\r
 162 %token FLOAT64\r
 163 \r
 164 /* HEXBYTE - two digit hex number */\r
 165 %token HEXBYTE\r
 166 \r
 167 \r
 168 /* Punctuation */\r
 169 %token DOT           "."\r
 170 %token OPEN_BRACE    "{"\r
 171 %token CLOSE_BRACE   "}"\r
 172 %token OPEN_BRACKET  "["\r
 173 %token CLOSE_BRACKET "]"\r
 174 %token OPEN_PARENS   "("\r
 175 %token CLOSE_PARENS  ")"\r
 176 %token COMMA         ","\r
 177 %token COLON         ":"\r
 178 %token DOUBLE_COLON  "::"\r
 179 %token SEMICOLON     ";"\r
 180 %token ASSIGN        "="\r
 181 %token STAR          "*"\r
 182 %token AMPERSAND     "&"\r
 183 %token PLUS          "+"\r
 184 %token SLASH         "/"\r
 185 %token BANG          "!"\r
 186 %token ELLIPSIS      "..."\r
 187 %token DASH          "-"\r
 188 %token OPEN_ANGLE_BRACKET   "<"\r
 189 %token CLOSE_ANGLE_BRACKET  ">"\r
 190 \r
 191 \r
 192 \r
 193 %token UNKNOWN\r
 194 \r
 195 \r
 196 /* INSTR_* instruction types */\r
 197 %token INSTR_NONE\r
 198 %token INSTR_VAR\r
 199 %token INSTR_I\r
 200 %token INSTR_I8\r
 201 %token INSTR_R\r
 202 %token INSTR_BRTARGET\r
 203 %token INSTR_METHOD\r
 204 %token INSTR_NEWOBJ\r
 205 %token INSTR_FIELD\r
 206 %token INSTR_TYPE\r
 207 %token INSTR_STRING\r
 208 %token INSTR_SIG\r
 209 %token INSTR_RVA\r
 210 %token INSTR_TOK\r
 211 %token INSTR_SWITCH\r
 212 %token INSTR_PHI\r
 213 %token INSTR_LOCAL\r
 214 %token INSTR_PARAM\r
 215 \r
 216 \r
 217 \r
 218 \r
 219 \r
 220 /* Mechanically generated  - DO NOT EDIT! */\r
 221 \r
 222 \r
 223 /* Directives */\r
 224 %token D_ADDON\r
 225 %token D_ALGORITHM\r
 226 %token D_ASSEMBLY\r
 227 %token D_BACKING\r
 228 %token D_BLOB\r
 229 %token D_CAPABILITY\r
 230 %token D_CCTOR\r
 231 %token D_CLASS\r
 232 %token D_COMTYPE\r
 233 %token D_CONFIG\r
 234 %token D_IMAGEBASE\r
 235 %token D_CORFLAGS\r
 236 %token D_CTOR\r
 237 %token D_CUSTOM\r
 238 %token D_DATA\r
 239 %token D_EMITBYTE\r
 240 %token D_ENTRYPOINT\r
 241 %token D_EVENT\r
 242 %token D_EXELOC\r
 243 %token D_EXPORT\r
 244 %token D_FIELD\r
 245 %token D_FILE\r
 246 %token D_FIRE\r
 247 %token D_GET\r
 248 %token D_HASH\r
 249 %token D_IMPLICITCOM\r
 250 %token D_LANGUAGE\r
 251 %token D_LINE\r
 252 %token D_XLINE\r
 253 %token D_LOCALE\r
 254 %token D_LOCALS\r
 255 %token D_MANIFESTRES\r
 256 %token D_MAXSTACK\r
 257 %token D_METHOD\r
 258 %token D_MIME\r
 259 %token D_MODULE\r
 260 %token D_MRESOURCE\r
 261 %token D_NAMESPACE\r
 262 %token D_ORIGINATOR\r
 263 %token D_OS\r
 264 %token D_OTHER\r
 265 %token D_OVERRIDE\r
 266 %token D_PACK\r
 267 %token D_PARAM\r
 268 %token D_PERMISSION\r
 269 %token D_PERMISSIONSET\r
 270 %token D_PROCESSOR\r
 271 %token D_PROPERTY\r
 272 %token D_PUBLICKEY\r
 273 %token D_PUBLICKEYTOKEN\r
 274 %token D_REMOVEON\r
 275 %token D_SET\r
 276 %token D_SIZE\r
 277 %token D_STACKRESERVE\r
 278 %token D_SUBSYSTEM\r
 279 %token D_TITLE\r
 280 %token D_TRY\r
 281 %token D_VER\r
 282 %token D_VTABLE\r
 283 %token D_VTENTRY\r
 284 %token D_VTFIXUP\r
 285 %token D_ZEROINIT\r
 286 \r
 287 \r
 288 /* Keywords */\r
 289 %token K_AT\r
 290 %token K_AS\r
 291 %token K_IMPLICITCOM\r
 292 %token K_IMPLICITRES\r
 293 %token K_NOAPPDOMAIN\r
 294 %token K_NOPROCESS\r
 295 %token K_NOMACHINE\r
 296 %token K_EXTERN\r
 297 %token K_INSTANCE\r
 298 %token K_EXPLICIT\r
 299 %token K_DEFAULT\r
 300 %token K_VARARG\r
 301 %token K_UNMANAGED\r
 302 %token K_CDECL\r
 303 %token K_STDCALL\r
 304 %token K_THISCALL\r
 305 %token K_FASTCALL\r
 306 %token K_MARSHAL\r
 307 %token K_IN\r
 308 %token K_OUT\r
 309 %token K_OPT\r
 310 // %token K_LCID\r
 311 //%token K_RETVAL\r
 312 %token K_STATIC\r
 313 %token K_PUBLIC\r
 314 %token K_PRIVATE\r
 315 %token K_FAMILY\r
 316 %token K_INITONLY\r
 317 %token K_RTSPECIALNAME\r
 318 %token K_STRICT\r
 319 %token K_SPECIALNAME\r
 320 %token K_ASSEMBLY\r
 321 %token K_FAMANDASSEM\r
 322 %token K_FAMORASSEM\r
 323 %token K_PRIVATESCOPE\r
 324 %token K_LITERAL\r
 325 %token K_NOTSERIALIZED\r
 326 %token K_VALUE\r
 327 %token K_NOT_IN_GC_HEAP\r
 328 %token K_INTERFACE\r
 329 %token K_SEALED\r
 330 %token K_ABSTRACT\r
 331 %token K_AUTO\r
 332 %token K_SEQUENTIAL\r
 333 %token K_ANSI\r
 334 %token K_UNICODE\r
 335 %token K_AUTOCHAR\r
 336 %token K_BESTFIT\r
 337 %token K_IMPORT\r
 338 %token K_SERIALIZABLE\r
 339 %token K_NESTED\r
 340 %token K_LATEINIT\r
 341 %token K_EXTENDS\r
 342 %token K_IMPLEMENTS\r
 343 %token K_FINAL\r
 344 %token K_VIRTUAL\r
 345 %token K_HIDEBYSIG\r
 346 %token K_NEWSLOT\r
 347 %token K_UNMANAGEDEXP\r
 348 %token K_PINVOKEIMPL\r
 349 %token K_NOMANGLE\r
 350 %token K_OLE\r
 351 %token K_LASTERR\r
 352 %token K_WINAPI\r
 353 %token K_NATIVE\r
 354 %token K_IL\r
 355 %token K_CIL\r
 356 %token K_OPTIL\r
 357 %token K_MANAGED\r
 358 %token K_FORWARDREF\r
 359 %token K_RUNTIME\r
 360 %token K_INTERNALCALL\r
 361 %token K_SYNCHRONIZED\r
 362 %token K_NOINLINING\r
 363 %token K_NOOPTIMIZATION\r
 364 %token K_CUSTOM\r
 365 %token K_FIXED\r
 366 %token K_SYSSTRING\r
 367 %token K_ARRAY\r
 368 %token K_VARIANT\r
 369 %token K_CURRENCY\r
 370 %token K_SYSCHAR\r
 371 %token K_VOID\r
 372 %token K_BOOL\r
 373 %token K_INT8\r
 374 %token K_INT16\r
 375 %token K_INT32\r
 376 %token K_INT64\r
 377 %token K_FLOAT32\r
 378 %token K_FLOAT64\r
 379 %token K_ERROR\r
 380 %token K_UNSIGNED\r
 381 %token K_UINT\r
 382 %token K_UINT8\r
 383 %token K_UINT16\r
 384 %token K_UINT32\r
 385 %token K_UINT64\r
 386 %token K_DECIMAL\r
 387 %token K_DATE\r
 388 %token K_BSTR\r
 389 %token K_LPSTR\r
 390 %token K_LPWSTR\r
 391 %token K_LPTSTR\r
 392 %token K_OBJECTREF\r
 393 %token K_IUNKNOWN\r
 394 %token K_IDISPATCH\r
 395 %token K_STRUCT\r
 396 %token K_SAFEARRAY\r
 397 %token K_INT\r
 398 %token K_BYVALSTR\r
 399 %token K_TBSTR\r
 400 %token K_LPVOID\r
 401 %token K_ANY\r
 402 %token K_FLOAT\r
 403 %token K_LPSTRUCT\r
 404 %token K_NULL\r
 405 %token K_PTR\r
 406 %token K_VECTOR\r
 407 %token K_HRESULT\r
 408 %token K_CARRAY\r
 409 %token K_USERDEFINED\r
 410 %token K_RECORD\r
 411 %token K_FILETIME\r
 412 %token K_BLOB\r
 413 %token K_STREAM\r
 414 %token K_STORAGE\r
 415 %token K_STREAMED_OBJECT\r
 416 %token K_STORED_OBJECT\r
 417 %token K_BLOB_OBJECT\r
 418 %token K_CF\r
 419 %token K_CLSID\r
 420 %token K_METHOD\r
 421 %token K_CLASS\r
 422 %token K_PINNED\r
 423 %token K_MODREQ\r
 424 %token K_MODOPT\r
 425 %token K_TYPEDREF\r
 426 %token K_TYPE\r
 427 %token K_WCHAR\r
 428 %token K_CHAR\r
 429 %token K_FROMUNMANAGED\r
 430 %token K_CALLMOSTDERIVED\r
 431 %token K_BYTEARRAY\r
 432 %token K_WITH\r
 433 %token K_INIT\r
 434 %token K_TO\r
 435 %token K_CATCH\r
 436 %token K_FILTER\r
 437 %token K_FINALLY\r
 438 %token K_FAULT\r
 439 %token K_HANDLER\r
 440 %token K_TLS\r
 441 %token K_FIELD\r
 442 %token K_PROPERTY\r
 443 %token K_REQUEST\r
 444 %token K_DEMAND\r
 445 %token K_ASSERT\r
 446 %token K_DENY\r
 447 %token K_PERMITONLY\r
 448 %token K_LINKCHECK\r
 449 %token K_INHERITCHECK\r
 450 %token K_REQMIN\r
 451 %token K_REQOPT\r
 452 %token K_REQREFUSE\r
 453 %token K_PREJITGRANT\r
 454 %token K_PREJITDENY\r
 455 %token K_NONCASDEMAND\r
 456 %token K_NONCASLINKDEMAND\r
 457 %token K_NONCASINHERITANCE\r
 458 %token K_READONLY\r
 459 %token K_NOMETADATA\r
 460 %token K_ALGORITHM\r
 461 %token K_FULLORIGIN\r
 462 // %token K_NAN\r
 463 // %token K_INF\r
 464 // %token K_PUBLICKEY\r
 465 %token K_ENABLEJITTRACKING\r
 466 %token K_DISABLEJITOPTIMIZER\r
 467 %token K_RETARGETABLE\r
 468 %token K_PRESERVESIG\r
 469 %token K_BEFOREFIELDINIT\r
 470 %token K_ALIGNMENT\r
 471 %token K_NULLREF\r
 472 %token K_VALUETYPE\r
 473 %token K_COMPILERCONTROLLED\r
 474 %token K_REQSECOBJ\r
 475 %token K_ENUM\r
 476 %token K_OBJECT\r
 477 %token K_STRING\r
 478 %token K_TRUE\r
 479 %token K_FALSE\r
 480 %token K_IS\r
 481 %token K_ON\r
 482 %token K_OFF\r
 483 %token K_FORWARDER\r
 484 %token K_CHARMAPERROR\r
 485 %token K_LEGACY\r
 486 %token K_LIBRARY\r
 487 %token K_AUTO\r
 488 \r
 489 /* end generated */\r
 490 \r
 491 \r
 492 \r
 493 \r
 494 \r
 495 %start il_file\r
 496 \r
 497 %%\r
 498 \r
 499 il_file                 : decls\r
 500                         ;\r
 501 \r
 502 decls                   : /* EMPTY */\r
 503                         | decls decl\r
 504                         ;\r
 505 \r
 506 decl                    : class_all\r
 507                         | namespace_all\r
 508                         | method_all\r
 509                         | field_decl\r
 510                         | data_decl\r
 511                         | vtfixup_decl\r
 512                         | file_decl\r
 513                         | assembly_all\r
 514                         | assemblyref_all\r
 515                         | exptype_all\r
 516                         | manifestres_all\r
 517                         | module_head\r
 518                         | sec_decl\r
 519                         | customattr_decl\r
 520                           {\r
 521                                 if (codegen.CurrentCustomAttrTarget != null)\r
 522                                         codegen.CurrentCustomAttrTarget.AddCustomAttribute ((CustomAttr) $1);\r
 523                           }\r
 524                         | D_SUBSYSTEM int32\r
 525                           {\r
 526                                 codegen.SetSubSystem ((int) $2);\r
 527                           }\r
 528                         | D_CORFLAGS int32\r
 529                           {\r
 530                                 codegen.SetCorFlags ((int) $2);\r
 531                           }\r
 532                         | D_FILE K_ALIGNMENT int32\r
 533                         | D_IMAGEBASE int64\r
 534                           {\r
 535                                 codegen.SetImageBase ((long) $2);\r
 536                           }\r
 537                         | D_STACKRESERVE int64\r
 538                           {\r
 539                                 codegen.SetStackReserve ((long) $2);\r
 540                           }\r
 541                         | extsource_spec\r
 542                         | language_decl\r
 543                         ;\r
 544 \r
 545 extsource_spec          : D_LINE int32 SQSTRING\r
 546                         | D_LINE int32\r
 547                         | D_LINE int32 COLON int32 SQSTRING\r
 548                         | D_LINE int32 COLON int32\r
 549                         ;\r
 550 \r
 551 language_decl           : D_LANGUAGE SQSTRING\r
 552                         | D_LANGUAGE SQSTRING COMMA SQSTRING\r
 553                         | D_LANGUAGE SQSTRING COMMA SQSTRING COMMA SQSTRING\r
 554                         ;\r
 555 \r
 556                         \r
 557 vtfixup_decl            : D_VTFIXUP OPEN_BRACKET int32 CLOSE_BRACKET \r
 558                           vtfixup_attr K_AT id\r
 559                         ;\r
 560 \r
 561 vtfixup_attr            : /* EMPTY */\r
 562                         | vtfixup_attr K_INT32\r
 563                         | vtfixup_attr K_INT64\r
 564                         | vtfixup_attr K_FROMUNMANAGED\r
 565                         | vtfixup_attr K_CALLMOSTDERIVED\r
 566                         ;\r
 567 \r
 568 namespace_all           : namespace_head OPEN_BRACE decls CLOSE_BRACE\r
 569                           {\r
 570                                 codegen.CurrentNameSpace = null;\r
 571                           }\r
 572                         ;\r
 573 \r
 574 namespace_head          : D_NAMESPACE comp_name\r
 575                           {\r
 576                                 codegen.CurrentNameSpace = (string) $2;\r
 577                           }\r
 578                         ;\r
 579 \r
 580 class_all               : class_head OPEN_BRACE class_decls CLOSE_BRACE\r
 581                           {\r
 582                                 codegen.EndTypeDef ();\r
 583                           }\r
 584                         ;\r
 585 \r
 586 class_head              : D_CLASS class_attr comp_name formal_typars_clause extends_clause\r
 587                           impl_clause\r
 588                           {\r
 589                                 codegen.BeginTypeDef ((TypeAttr) $2, (string) $3, \r
 590                                                 $5 as BaseClassRef, $6 as ArrayList, null, (GenericParameters) $4);\r
 591                                 \r
 592                                 if (is_value_class)\r
 593                                         codegen.CurrentTypeDef.MakeValueClass ();\r
 594                                 if (is_enum_class)\r
 595                                         codegen.CurrentTypeDef.MakeEnumClass ();\r
 596                           }\r
 597                         ;\r
 598 \r
 599 class_attr              : /* EMPTY */                           \r
 600                           { \r
 601                                 // Reset some flags\r
 602                                 is_value_class = false;\r
 603                                 is_enum_class = false;\r
 604                                 $$ = new TypeAttr ();\r
 605                           }\r
 606                         | class_attr K_PUBLIC                   { $$ = (TypeAttr)$1 | TypeAttr.Public; }        \r
 607                         | class_attr K_PRIVATE                  { $$ = (TypeAttr)$1 | TypeAttr.Private; }\r
 608                         | class_attr K_NESTED K_PRIVATE         { $$ = (TypeAttr)$1 | TypeAttr.NestedPrivate; }\r
 609                         | class_attr K_NESTED K_PUBLIC          { $$ = (TypeAttr)$1 | TypeAttr.NestedPublic; }\r
 610                         | class_attr K_NESTED K_FAMILY          { $$ = (TypeAttr)$1 | TypeAttr.NestedFamily; }\r
 611                         | class_attr K_NESTED K_ASSEMBLY        { $$ = (TypeAttr)$1 | TypeAttr.NestedAssembly;}\r
 612                         | class_attr K_NESTED K_FAMANDASSEM     { $$ = (TypeAttr)$1 | TypeAttr.NestedFamAndAssem; }\r
 613                         | class_attr K_NESTED K_FAMORASSEM      { $$ = (TypeAttr)$1 | TypeAttr.NestedFamOrAssem; }\r
 614                         | class_attr K_VALUE                    { is_value_class = true; }\r
 615                         | class_attr K_ENUM                     { is_enum_class = true; }\r
 616                         | class_attr K_INTERFACE                { $$ = (TypeAttr)$1 | TypeAttr.Interface; }\r
 617                         | class_attr K_SEALED                   { $$ = (TypeAttr)$1 | TypeAttr.Sealed; }\r
 618                         | class_attr K_ABSTRACT                 { $$ = (TypeAttr)$1 | TypeAttr.Abstract; }\r
 619                         | class_attr K_AUTO                     {  }\r
 620                         | class_attr K_SEQUENTIAL               { $$ = (TypeAttr)$1 | TypeAttr.SequentialLayout; }\r
 621                         | class_attr K_EXPLICIT                 { $$ = (TypeAttr)$1 | TypeAttr.ExplicitLayout; }\r
 622                         | class_attr K_ANSI                     {  }\r
 623                         | class_attr K_UNICODE                  { $$ = (TypeAttr)$1 | TypeAttr.UnicodeClass; }\r
 624                         | class_attr K_AUTOCHAR                 { $$ = (TypeAttr)$1 | TypeAttr.AutoClass; }\r
 625                         | class_attr K_IMPORT                   { $$ = (TypeAttr)$1 | TypeAttr.Import; }\r
 626                         | class_attr K_SERIALIZABLE             { $$ = (TypeAttr)$1 | TypeAttr.Serializable; }\r
 627                         | class_attr K_BEFOREFIELDINIT          { $$ = (TypeAttr)$1 | TypeAttr.BeforeFieldInit; }\r
 628                         | class_attr K_SPECIALNAME              { $$ = (TypeAttr)$1 | TypeAttr.SpecialName; }\r
 629                         | class_attr K_RTSPECIALNAME            { $$ = (TypeAttr)$1 | TypeAttr.RTSpecialName; }\r
 630                         ;\r
 631 \r
 632 extends_clause          : /* EMPTY */\r
 633                         | K_EXTENDS generic_class_ref\r
 634                           {\r
 635                                 $$ = $2;\r
 636                           }\r
 637                         ;\r
 638 \r
 639 impl_clause             : /* EMPTY */\r
 640                         | impl_class_refs\r
 641                         ;\r
 642 \r
 643 impl_class_refs         : K_IMPLEMENTS generic_class_ref\r
 644                           {\r
 645                                 ArrayList al = new ArrayList ();\r
 646                                 al.Add ($2);\r
 647                                 $$ = al;\r
 648                           }\r
 649                         | impl_class_refs COMMA generic_class_ref\r
 650                           {\r
 651                                 ArrayList al = (ArrayList) $1;\r
 652 \r
 653                                 al.Insert (0, $3);\r
 654                                 $$ = al;\r
 655                           }\r
 656                         ;\r
 657 \r
 658 formal_typars_clause           : /* EMPTY */\r
 659                         | OPEN_ANGLE_BRACKET formal_typars CLOSE_ANGLE_BRACKET\r
 660                           {\r
 661                                 $$ = $2;\r
 662                           }\r
 663                         ;\r
 664 \r
 665 typars_clause           : /* EMPTY */\r
 666                         | OPEN_ANGLE_BRACKET typars CLOSE_ANGLE_BRACKET\r
 667                           {\r
 668                                 $$ = $2;\r
 669                           }\r
 670                         ;\r
 671 \r
 672 typars                  : type\r
 673                           {\r
 674                                 GenericArguments ga = new GenericArguments ();\r
 675                                 ga.Add ((BaseTypeRef) $1);\r
 676                                 $$ = ga;\r
 677                           }\r
 678                         | typars COMMA type\r
 679                           {\r
 680                                 ((GenericArguments) $1).Add ((BaseTypeRef) $3);\r
 681                                 $$ = $1;\r
 682                           }\r
 683                         ;\r
 684 \r
 685 constraints_clause      : /* EMTPY */\r
 686                         | OPEN_PARENS constraints CLOSE_PARENS\r
 687                           {\r
 688                                 $$ = $2;\r
 689                           }\r
 690                        ;\r
 691 \r
 692 \r
 693 constraints             : type\r
 694                           {\r
 695                                 ArrayList al = new ArrayList ();\r
 696                                 al.Add ($1);\r
 697                                 $$ = al;\r
 698                            }\r
 699                         | constraints COMMA type\r
 700                           {\r
 701                                 ArrayList al = (ArrayList) $1;\r
 702                                 al.Add ($3);\r
 703                                 $$ = al;\r
 704                           }\r
 705                         ;\r
 706 \r
 707 generic_class_ref       : class_ref\r
 708                           {\r
 709                                 $$ = $1;\r
 710                           }\r
 711                         | K_OBJECT\r
 712                           {\r
 713                                 $$ = new PrimitiveTypeRef (PrimitiveType.Object, "System.Object");\r
 714                           }\r
 715                         | K_CLASS class_ref typars_clause\r
 716                           {\r
 717                                 if ($3 != null)\r
 718                                         $$ = ((BaseClassRef) $2).GetGenericTypeInst ((GenericArguments) $3);\r
 719                                 else\r
 720                                         $$ = $2;\r
 721                           }\r
 722                         | BANG int32\r
 723                           {\r
 724                                 GenParam gpar = new GenParam ((int) $2, "", GenParamType.Var);\r
 725                                 $$ = new GenericParamRef (gpar, $2.ToString ());\r
 726                           }\r
 727                         | BANG BANG int32\r
 728                           {\r
 729                                 GenParam gpar = new GenParam ((int) $3, "", GenParamType.MVar);\r
 730                                 $$ = new GenericParamRef (gpar, $3.ToString ());\r
 731                           }\r
 732                         | BANG id\r
 733                           {\r
 734                                 int num = -1;\r
 735                                 string name = (string) $2;\r
 736                                 if (codegen.CurrentTypeDef != null)\r
 737                                         num = codegen.CurrentTypeDef.GetGenericParamNum (name);\r
 738                                 GenParam gpar = new GenParam (num, name, GenParamType.Var);\r
 739                                 $$ = new GenericParamRef (gpar, name);\r
 740                           }\r
 741                         | BANG BANG id\r
 742                           {\r
 743                                 int num = -1;\r
 744                                 string name = (string) $3;\r
 745                                 if (codegen.CurrentMethodDef != null)\r
 746                                         num = codegen.CurrentMethodDef.GetGenericParamNum (name);\r
 747                                 GenParam gpar = new GenParam (num, name, GenParamType.MVar);\r
 748                                 $$ = new GenericParamRef (gpar, name);\r
 749                           }\r
 750                         ; \r
 751 \r
 752 formal_typars           : formal_typar_attr constraints_clause formal_typar\r
 753                           {\r
 754                                 GenericParameter gp = new GenericParameter ((string) $3, (PEAPI.GenericParamAttributes) $1, (ArrayList) $2);\r
 755 \r
 756                                 GenericParameters colln = new GenericParameters ();\r
 757                                 colln.Add (gp);\r
 758                                 $$ = colln;\r
 759                           }\r
 760                         | formal_typars COMMA formal_typar_attr constraints_clause formal_typar\r
 761                           {\r
 762                                 GenericParameters colln = (GenericParameters) $1;\r
 763                                 colln.Add (new GenericParameter ((string) $5, (PEAPI.GenericParamAttributes) $3, (ArrayList) $4));\r
 764                                 $$ = colln;\r
 765                           }\r
 766                          ;\r
 767  \r
 768 formal_typar_attr       : /* EMPTY */\r
 769                           {\r
 770                                 $$ = new PEAPI.GenericParamAttributes ();\r
 771                           }\r
 772                         | formal_typar_attr PLUS\r
 773                           {\r
 774                                $$ = (PEAPI.GenericParamAttributes) $1 | PEAPI.GenericParamAttributes.Covariant; \r
 775                           }\r
 776                         | formal_typar_attr DASH\r
 777                           {\r
 778                                $$ = (PEAPI.GenericParamAttributes) $1 | PEAPI.GenericParamAttributes.Contravariant; \r
 779                           }\r
 780                         | formal_typar_attr D_CTOR\r
 781                           {\r
 782                                $$ = (PEAPI.GenericParamAttributes) $1 | PEAPI.GenericParamAttributes.DefaultConstructorConstrait; \r
 783                           }\r
 784                         | formal_typar_attr K_VALUETYPE\r
 785                           {\r
 786                                $$ = (PEAPI.GenericParamAttributes) $1 | PEAPI.GenericParamAttributes.NotNullableValueTypeConstraint; \r
 787                           }\r
 788                         | formal_typar_attr K_CLASS\r
 789                           {\r
 790                                $$ = (PEAPI.GenericParamAttributes) $1 | PEAPI.GenericParamAttributes.ReferenceTypeConstraint; \r
 791                           }\r
 792                         ;\r
 793 \r
 794 formal_typar            : id\r
 795                           {\r
 796                                 $$ = $1;\r
 797                           }\r
 798                         ;\r
 799 \r
 800 param_type_decl         : D_PARAM K_TYPE id\r
 801                           {\r
 802                                   if (codegen.CurrentMethodDef != null)\r
 803                                           codegen.CurrentCustomAttrTarget = codegen.CurrentMethodDef.GetGenericParam ((string) $3);\r
 804                                   else\r
 805                                           codegen.CurrentCustomAttrTarget = codegen.CurrentTypeDef.GetGenericParam ((string) $3);\r
 806                                   if (codegen.CurrentCustomAttrTarget == null)\r
 807                                           Report.Error (String.Format ("Type parameter '{0}' undefined.", (string) $3));\r
 808                           }\r
 809                         | D_PARAM K_TYPE OPEN_BRACKET int32 CLOSE_BRACKET\r
 810                           {\r
 811                                   int index = ((int) $4);\r
 812                                   if (codegen.CurrentMethodDef != null)\r
 813                                           codegen.CurrentCustomAttrTarget = codegen.CurrentMethodDef.GetGenericParam (index - 1);\r
 814                                   else\r
 815                                           codegen.CurrentCustomAttrTarget = codegen.CurrentTypeDef.GetGenericParam (index - 1);\r
 816                                   if (codegen.CurrentCustomAttrTarget == null)\r
 817                                           Report.Error (String.Format ("Type parameter '{0}' index out of range.", index));\r
 818                           }\r
 819                         ;\r
 820                         \r
 821 class_refs              : class_ref\r
 822                           {\r
 823                                 ArrayList class_list = new ArrayList ();\r
 824                                 class_list.Add ($1);\r
 825                                 $$ = class_list; \r
 826                           }\r
 827                         | class_refs COMMA class_ref\r
 828                           {\r
 829                                 ArrayList class_list = (ArrayList) $1;\r
 830                                 class_list.Add ($3);\r
 831                           }\r
 832                         ;\r
 833 \r
 834 slashed_name            : comp_name\r
 835                         | slashed_name SLASH comp_name\r
 836                           {\r
 837                                 $$ = String.Format ("{0}/{1}", $1, $3);\r
 838                           }\r
 839                         ;\r
 840 \r
 841 class_ref               : OPEN_BRACKET slashed_name CLOSE_BRACKET slashed_name\r
 842                           {\r
 843                                 if (codegen.IsThisAssembly ((string) $2)) {\r
 844                                         $$ = codegen.GetTypeRef ((string) $4);\r
 845                                 } else {\r
 846                                         $$ = codegen.ExternTable.GetTypeRef ((string) $2, (string) $4, false);\r
 847                                 }\r
 848                           }\r
 849                         | OPEN_BRACKET D_MODULE slashed_name CLOSE_BRACKET slashed_name\r
 850                           {\r
 851                                 if (codegen.IsThisModule ((string) $3)) {\r
 852                                         $$ = codegen.GetTypeRef ((string) $5);\r
 853                                 } else {\r
 854                                         $$ = codegen.ExternTable.GetModuleTypeRef ((string) $3, (string) $5, false);\r
 855                                 }\r
 856                           }\r
 857                         | slashed_name\r
 858                           {\r
 859                                 PrimitiveTypeRef prim = PrimitiveTypeRef.GetPrimitiveType ((string) $1);\r
 860 \r
 861                                 if (prim != null && !codegen.IsThisAssembly ("mscorlib"))\r
 862                                         $$ = prim;\r
 863                                 else\r
 864                                         $$ = codegen.GetTypeRef ((string) $1);\r
 865                           }\r
 866                       \r
 867                         ;\r
 868 \r
 869 class_decls             : /* EMPTY */\r
 870                         | class_decls class_decl\r
 871                         ;\r
 872 \r
 873 class_decl              : method_all\r
 874                         | class_all\r
 875                         | event_all\r
 876                         | prop_all\r
 877                         | field_decl\r
 878                         | data_decl\r
 879                         | sec_decl\r
 880                           {\r
 881                                 AddSecDecl ($1, false);\r
 882                           }\r
 883                         | extsource_spec\r
 884                         | customattr_decl\r
 885                           {\r
 886                                 if (codegen.CurrentCustomAttrTarget != null)\r
 887                                         codegen.CurrentCustomAttrTarget.AddCustomAttribute ((CustomAttr) $1);\r
 888                           }\r
 889                         | param_type_decl\r
 890                         | D_SIZE int32\r
 891                           {\r
 892                                 codegen.CurrentTypeDef.SetSize ((int) $2);\r
 893                           }\r
 894                         | D_PACK int32\r
 895                           {\r
 896                                 codegen.CurrentTypeDef.SetPack ((int) $2);\r
 897                           }\r
 898                         | D_OVERRIDE type_spec DOUBLE_COLON method_name K_WITH call_conv type\r
 899                           type_spec DOUBLE_COLON method_name type_list\r
 900                           {\r
 901                                 //\r
 902                                 // My copy of the spec didn't have a type_list but\r
 903                                 // it seems pretty crucial\r
 904                                 //\r
 905                                 BaseTypeRef owner = (BaseTypeRef) $2;\r
 906                                 ArrayList arg_list = (ArrayList) $11;\r
 907                                 BaseTypeRef[] param_list;\r
 908                                 BaseMethodRef decl;\r
 909 \r
 910                                 if (arg_list != null)\r
 911                                         param_list = (BaseTypeRef[]) arg_list.ToArray (typeof (BaseTypeRef));\r
 912                                 else\r
 913                                         param_list = new BaseTypeRef[0];\r
 914 \r
 915                                 decl = owner.GetMethodRef ((BaseTypeRef) $7,\r
 916                                         (CallConv) $6, (string) $4, param_list, 0);\r
 917 \r
 918                                 // NOTICE: `owner' here might be wrong\r
 919                                 string sig = MethodDef.CreateSignature (owner, (CallConv) $6, (string) $10,\r
 920                                                                         param_list, 0, false);\r
 921                                 codegen.CurrentTypeDef.AddOverride (sig, decl);                                        \r
 922                           }\r
 923                           OPEN_PARENS sig_args CLOSE_PARENS\r
 924                         | language_decl\r
 925                         ;\r
 926 \r
 927 type                    : generic_class_ref\r
 928                           {\r
 929                                 $$ = GetTypeRef ((BaseTypeRef) $1);\r
 930                           }\r
 931                         | K_VALUE K_CLASS class_ref\r
 932                           {\r
 933                                 BaseClassRef class_ref = (BaseClassRef) $3;\r
 934                                 class_ref.MakeValueClass ();\r
 935                                 $$ = GetTypeRef (class_ref);\r
 936                           }\r
 937                         | K_VALUETYPE OPEN_BRACKET slashed_name CLOSE_BRACKET slashed_name typars_clause\r
 938                           {\r
 939                                 ExternTypeRef ext_ref = codegen.ExternTable.GetTypeRef ((string) $3, (string) $5, true);\r
 940                                 if ($6 != null)\r
 941                                         $$ = ext_ref.GetGenericTypeInst ((GenericArguments) $6);\r
 942                                 else\r
 943                                         $$ = GetTypeRef (ext_ref);\r
 944                           }\r
 945                         | K_VALUETYPE slashed_name typars_clause\r
 946                           {\r
 947                                 TypeRef t_ref = codegen.GetTypeRef ((string) $2);\r
 948                                 t_ref.MakeValueClass ();\r
 949                                 if ($3 != null)\r
 950                                         $$ = t_ref.GetGenericTypeInst ((GenericArguments) $3);\r
 951                                 else\r
 952                                         $$ = GetTypeRef (t_ref);\r
 953                           }\r
 954                         | type OPEN_BRACKET CLOSE_BRACKET\r
 955                           {\r
 956                                 BaseTypeRef base_type = (BaseTypeRef) $1;\r
 957                                 base_type.MakeArray ();\r
 958                                 $$ = base_type;\r
 959                           }\r
 960                         | type OPEN_BRACKET bounds CLOSE_BRACKET\r
 961                           {\r
 962                                 BaseTypeRef base_type = (BaseTypeRef) $1;\r
 963                                 ArrayList bound_list = (ArrayList) $3;\r
 964                                 base_type.MakeBoundArray (bound_list);\r
 965                                 $$ = base_type;\r
 966                           }\r
 967                         | type AMPERSAND\r
 968                           {\r
 969                                 BaseTypeRef base_type = (BaseTypeRef) $1;\r
 970                                 base_type.MakeManagedPointer ();\r
 971                                 $$ = base_type;\r
 972                           }\r
 973                         | type STAR\r
 974                           {\r
 975                                 BaseTypeRef base_type = (BaseTypeRef) $1;\r
 976                                 base_type.MakeUnmanagedPointer ();\r
 977                                 $$ = base_type;\r
 978                           }\r
 979                         | type K_PINNED\r
 980                           {\r
 981                                 BaseTypeRef base_type = (BaseTypeRef) $1;\r
 982                                 base_type.MakePinned ();\r
 983                                 $$ = base_type;\r
 984                           }\r
 985                         | type K_MODREQ OPEN_PARENS custom_modifier_type CLOSE_PARENS\r
 986                           {\r
 987                                 BaseTypeRef base_type = (BaseTypeRef) $1;\r
 988                                 BaseTypeRef class_ref = (BaseTypeRef) $4;\r
 989                                 base_type.MakeCustomModified (codegen,\r
 990                                         CustomModifier.modreq, class_ref);\r
 991                                 $$ = base_type;\r
 992                           }\r
 993                         | type K_MODOPT OPEN_PARENS custom_modifier_type CLOSE_PARENS\r
 994                           {\r
 995                                 BaseTypeRef base_type = (BaseTypeRef) $1;\r
 996                                 BaseTypeRef class_ref = (BaseTypeRef) $4;\r
 997                                 base_type.MakeCustomModified (codegen,\r
 998                                         CustomModifier.modopt, class_ref);\r
 999                                 $$ = base_type;\r
1000                           }\r
1001                         | K_METHOD call_conv type STAR OPEN_PARENS sig_args CLOSE_PARENS\r
1002                           {\r
1003                                 $$ = new MethodPointerTypeRef ((CallConv) $2, (BaseTypeRef) $3, (ArrayList) $6);\r
1004                           }\r
1005                         | primitive_type\r
1006                         ;\r
1007 \r
1008 primitive_type          : K_INT8\r
1009                           {\r
1010                                 $$ = new PrimitiveTypeRef (PrimitiveType.Int8, "System.SByte");\r
1011                           }\r
1012                         | K_INT16\r
1013                           {\r
1014                                 $$ = new PrimitiveTypeRef (PrimitiveType.Int16, "System.Int16");\r
1015                           }\r
1016                         | K_INT32\r
1017                           {\r
1018                                 $$ = new PrimitiveTypeRef (PrimitiveType.Int32, "System.Int32");\r
1019                           }\r
1020                         | K_INT64\r
1021                           {\r
1022                                 $$ = new PrimitiveTypeRef (PrimitiveType.Int64, "System.Int64");\r
1023                           }\r
1024                         | K_FLOAT32\r
1025                           {\r
1026                                 $$ = new PrimitiveTypeRef (PrimitiveType.Float32, "System.Single");\r
1027                           }\r
1028                         | K_FLOAT64\r
1029                           {\r
1030                                 $$ = new PrimitiveTypeRef (PrimitiveType.Float64, "System.Double");\r
1031                           }\r
1032                         | K_UNSIGNED K_INT8\r
1033                           {\r
1034                                 $$ = new PrimitiveTypeRef (PrimitiveType.UInt8, "System.Byte");\r
1035                           }\r
1036                         | K_UINT8\r
1037                           {\r
1038                                 $$ = new PrimitiveTypeRef (PrimitiveType.UInt8, "System.Byte");\r
1039                           }\r
1040                         | K_UNSIGNED K_INT16\r
1041                           {\r
1042                                 $$ = new PrimitiveTypeRef (PrimitiveType.UInt16, "System.UInt16");     \r
1043                           }\r
1044                         | K_UINT16\r
1045                           {\r
1046                                 $$ = new PrimitiveTypeRef (PrimitiveType.UInt16, "System.UInt16");     \r
1047                           }\r
1048                         | K_UNSIGNED K_INT32\r
1049                           {\r
1050                                 $$ = new PrimitiveTypeRef (PrimitiveType.UInt32, "System.UInt32");\r
1051                           }\r
1052                         | K_UINT32\r
1053                           {\r
1054                                 $$ = new PrimitiveTypeRef (PrimitiveType.UInt32, "System.UInt32");\r
1055                           }\r
1056                         | K_UNSIGNED K_INT64\r
1057                           {\r
1058                                 $$ = new PrimitiveTypeRef (PrimitiveType.UInt64, "System.UInt64");\r
1059                           }\r
1060                         | K_UINT64\r
1061                           {\r
1062                                 $$ = new PrimitiveTypeRef (PrimitiveType.UInt64, "System.UInt64");\r
1063                           }\r
1064                         | K_NATIVE K_INT\r
1065                           {\r
1066                                 // TODO: Is this the proper full name\r
1067                                 $$ = new PrimitiveTypeRef (PrimitiveType.NativeInt, "System.IntPtr");\r
1068                           }\r
1069                         | K_NATIVE K_UNSIGNED K_INT\r
1070                           {\r
1071                                 $$ = new PrimitiveTypeRef (PrimitiveType.NativeUInt, "System.UIntPtr");\r
1072                           }\r
1073                         | K_NATIVE K_UINT\r
1074                           {\r
1075                                 $$ = new PrimitiveTypeRef (PrimitiveType.NativeUInt, "System.UIntPtr");\r
1076                           }\r
1077                         | K_TYPEDREF\r
1078                           {\r
1079                                 $$ = new PrimitiveTypeRef (PrimitiveType.TypedRef,\r
1080                                         "System.TypedReference");\r
1081                           }\r
1082                         | K_CHAR\r
1083                           {\r
1084                                 $$ = new PrimitiveTypeRef (PrimitiveType.Char, "System.Char");\r
1085                           }\r
1086                         | K_WCHAR\r
1087                           {\r
1088                                 $$ = new PrimitiveTypeRef (PrimitiveType.Char, "System.Char");\r
1089                           }\r
1090                         | K_VOID\r
1091                           {\r
1092                                 $$ = new PrimitiveTypeRef (PrimitiveType.Void, "System.Void");\r
1093                           }\r
1094                         | K_BOOL\r
1095                           {\r
1096                                 $$ = new PrimitiveTypeRef (PrimitiveType.Boolean, "System.Boolean");\r
1097                           }\r
1098                         | K_STRING\r
1099                           {\r
1100                                 $$ = new PrimitiveTypeRef (PrimitiveType.String, "System.String");\r
1101                           }\r
1102                         ;\r
1103 \r
1104 bounds                  : bound\r
1105                           {\r
1106                                 ArrayList bound_list = new ArrayList ();\r
1107                                 bound_list.Add ($1);\r
1108                                 $$ = bound_list;\r
1109                           }\r
1110                         | bounds COMMA bound\r
1111                           {\r
1112                                 ArrayList bound_list = (ArrayList) $1;\r
1113                                 bound_list.Add ($3);\r
1114                           }\r
1115                         ;\r
1116 \r
1117 bound                   : /* EMPTY */\r
1118                           {\r
1119                                 // This is shortref for no lowerbound or size\r
1120                                 $$ = new DictionaryEntry (TypeRef.Ellipsis, TypeRef.Ellipsis);\r
1121                           }\r
1122                         | ELLIPSIS\r
1123                           {\r
1124                                 // No lower bound or size\r
1125                                 $$ = new DictionaryEntry (TypeRef.Ellipsis, TypeRef.Ellipsis);\r
1126                           }\r
1127                         | int32\r
1128                           {\r
1129                                 /* Only size specified */ \r
1130                                 int size = (int) $1;\r
1131                                 if (size < 0)\r
1132                                         /* size cannot be < 0, so emit as (0, ...)\r
1133                                            ilasm.net emits it like this */\r
1134                                         $$ = new DictionaryEntry (0, TypeRef.Ellipsis);\r
1135                                 else\r
1136                                         $$ = new DictionaryEntry (TypeRef.Ellipsis, size);\r
1137                           }\r
1138                         | int32 ELLIPSIS int32\r
1139                           {\r
1140                                 // lower and upper bound\r
1141                                 int lower = (int) $1;\r
1142                                 int upper = (int) $3;\r
1143                                 if (lower > upper) \r
1144                                         Report.Error ("Lower bound " + lower + " must be <= upper bound " + upper);\r
1145 \r
1146                                 $$ = new DictionaryEntry ($1, $3);\r
1147                           }\r
1148                         | int32 ELLIPSIS\r
1149                           {\r
1150                                 // Just lower bound\r
1151                                 $$ = new DictionaryEntry ($1, TypeRef.Ellipsis);\r
1152                           }\r
1153                         ;\r
1154 \r
1155 call_conv               : K_INSTANCE call_conv\r
1156                           {\r
1157                                 $$ = (CallConv) $2 | CallConv.Instance;\r
1158                           }\r
1159                         | K_EXPLICIT call_conv\r
1160                           {\r
1161                                 $$ = (CallConv) $2 | CallConv.InstanceExplicit;\r
1162                           }\r
1163                         | call_kind\r
1164                         ;\r
1165 \r
1166 call_kind               : /* EMPTY */\r
1167                           {\r
1168                                 $$ = new CallConv ();\r
1169                           }\r
1170                         | K_DEFAULT\r
1171                           {\r
1172                                 $$ = CallConv.Default;\r
1173                           }\r
1174                         | K_VARARG\r
1175                           {\r
1176                                 $$ = CallConv.Vararg;\r
1177                           }\r
1178                         | K_UNMANAGED K_CDECL\r
1179                           {\r
1180                                 $$ = CallConv.Cdecl;\r
1181                           }\r
1182                         | K_UNMANAGED K_STDCALL\r
1183                           {\r
1184                                 $$ = CallConv.Stdcall;\r
1185                           }\r
1186                         | K_UNMANAGED K_THISCALL\r
1187                           {\r
1188                                 $$ = CallConv.Thiscall;\r
1189                           }\r
1190                         | K_UNMANAGED K_FASTCALL\r
1191                           {\r
1192                                 $$ = CallConv.Fastcall;\r
1193                           }\r
1194                         ;\r
1195 \r
1196 native_type             : /* EMPTY */\r
1197                         | K_CUSTOM OPEN_PARENS comp_qstring COMMA comp_qstring CLOSE_PARENS\r
1198                           {\r
1199                                 $$ = new CustomMarshaller ((string) $3, (string) $5);\r
1200                           }\r
1201                         | K_FIXED K_SYSSTRING OPEN_BRACKET int32 CLOSE_BRACKET\r
1202                           {\r
1203                                 $$ = new FixedSysString ((uint) (int)$4);\r
1204                           }\r
1205                         | K_FIXED K_ARRAY OPEN_BRACKET int32 CLOSE_BRACKET\r
1206                           {\r
1207                                 $$ = new FixedArray ((int) $4);        \r
1208                           }\r
1209                         | K_VARIANT\r
1210                         | K_CURRENCY\r
1211                           {\r
1212                                 $$ = NativeType.Currency;\r
1213                           }\r
1214                         | K_SYSCHAR\r
1215                         | K_VOID\r
1216                           {\r
1217                                 $$ = NativeType.Void;\r
1218                           }\r
1219                         | K_BOOL\r
1220                           {\r
1221                                 $$ = NativeType.Boolean;\r
1222                           }\r
1223                         | K_INT8\r
1224                           {\r
1225                                 $$ = NativeType.Int8;\r
1226                           }\r
1227                         | K_INT16\r
1228                           {\r
1229                                 $$ = NativeType.Int16;\r
1230                           }\r
1231                         | K_INT32\r
1232                           {\r
1233                                 $$ = NativeType.Int32;\r
1234                           }\r
1235                         | K_INT64\r
1236                           {\r
1237                                 $$ = NativeType.Int64;\r
1238                           }\r
1239                         | K_FLOAT32\r
1240                           {\r
1241                                 $$ = NativeType.Float32;\r
1242                           }\r
1243                         | K_FLOAT64\r
1244                           {\r
1245                                 $$ = NativeType.Float64;\r
1246                           }\r
1247                         | K_ERROR\r
1248                           {\r
1249                                 $$ = NativeType.Error;\r
1250                           }\r
1251                         | K_UNSIGNED K_INT8\r
1252                           {\r
1253                                 $$ = NativeType.UInt8;\r
1254                           }\r
1255                         | K_UINT8\r
1256                           {\r
1257                                 $$ = NativeType.UInt8;\r
1258                           }\r
1259                         | K_UNSIGNED K_INT16\r
1260                           {\r
1261                                 $$ = NativeType.UInt16;\r
1262                           }\r
1263                         | K_UINT16\r
1264                           {\r
1265                                 $$ = NativeType.UInt16;\r
1266                           }\r
1267                         | K_UNSIGNED K_INT32\r
1268                           {\r
1269                                 $$ = NativeType.UInt32;\r
1270                           }\r
1271                         | K_UINT32\r
1272                           {\r
1273                                 $$ = NativeType.UInt32;\r
1274                           }\r
1275                         | K_UNSIGNED K_INT64\r
1276                           {\r
1277                                 $$ = NativeType.UInt64;\r
1278                           }\r
1279                         | K_UINT64\r
1280                           {\r
1281                                 $$ = NativeType.UInt64;\r
1282                           }\r
1283                         | native_type STAR\r
1284                         | native_type OPEN_BRACKET CLOSE_BRACKET\r
1285                           {\r
1286                                 $$ = new NativeArray ((NativeType) $1);\r
1287                           }\r
1288                         | native_type OPEN_BRACKET int32 CLOSE_BRACKET\r
1289                           {\r
1290                                 $$ = new NativeArray ((NativeType) $1, (int) $3, 0, 0);\r
1291                           }\r
1292                         | native_type OPEN_BRACKET int32 PLUS int32 CLOSE_BRACKET\r
1293                           {\r
1294                                 //FIXME: Allowed only for methods, !fields\r
1295                                 $$ = new NativeArray ((NativeType) $1, (int) $3, (int) $5);\r
1296                           }\r
1297                         | native_type OPEN_BRACKET PLUS int32 CLOSE_BRACKET\r
1298                           {\r
1299                                 //FIXME: Allowed only for methods, !fields\r
1300                                 $$ = new NativeArray ((NativeType) $1, -1, (int) $4);\r
1301                           }\r
1302                         | K_DECIMAL\r
1303                         | K_DATE\r
1304                         | K_BSTR\r
1305                           {\r
1306                                 $$ = NativeType.BStr;\r
1307                           }\r
1308                         | K_LPSTR\r
1309                           {\r
1310                                 $$ = NativeType.LPStr;\r
1311                           }\r
1312                         | K_LPWSTR\r
1313                           {\r
1314                                 $$ = NativeType.LPWStr;\r
1315                           }\r
1316                         | K_LPTSTR\r
1317                           {\r
1318                                 $$ = NativeType.LPTStr;\r
1319                           }\r
1320                         | K_OBJECTREF\r
1321                         | K_IUNKNOWN\r
1322                           {\r
1323                                 $$ = NativeType.IUnknown;\r
1324                           }\r
1325                         | K_IDISPATCH\r
1326                           {\r
1327                                 $$ = NativeType.IDispatch;\r
1328                           }\r
1329                         | K_STRUCT\r
1330                           {\r
1331                                 $$ = NativeType.Struct;\r
1332                           }\r
1333                         | K_INTERFACE\r
1334                           {\r
1335                                 $$ = NativeType.Interface;\r
1336                           }\r
1337                         | K_SAFEARRAY variant_type\r
1338                           {\r
1339                                 if ($2 == null)\r
1340                                         $$ = new SafeArray ();\r
1341                                 else        \r
1342                                         $$ = new SafeArray ((SafeArrayType) $2);\r
1343                           }\r
1344                         | K_SAFEARRAY variant_type COMMA comp_qstring\r
1345                         | K_INT\r
1346                           {\r
1347                                 $$ = NativeType.Int;\r
1348                           }\r
1349                         | K_UNSIGNED K_INT\r
1350                           {\r
1351                                 $$ = NativeType.UInt;\r
1352                           }\r
1353                         | K_NESTED K_STRUCT\r
1354                         | K_BYVALSTR\r
1355                           {\r
1356                                 $$ = NativeType.ByValStr;\r
1357                           }\r
1358                         | K_ANSI K_BSTR\r
1359                           {\r
1360                                 $$ = NativeType.AnsiBStr;\r
1361                           }\r
1362                         | K_TBSTR\r
1363                           {\r
1364                                 $$ = NativeType.TBstr;\r
1365                           }\r
1366                         | K_VARIANT K_BOOL\r
1367                           {\r
1368                                 $$ = NativeType.VariantBool;\r
1369                           }\r
1370                         | K_METHOD\r
1371                           {\r
1372                                 $$ = NativeType.FuncPtr;\r
1373                           }     \r
1374                         | K_AS K_ANY\r
1375                           {\r
1376                                 $$ = NativeType.AsAny;\r
1377                           }\r
1378                         | K_LPSTRUCT\r
1379                           {\r
1380                                 $$ = NativeType.LPStruct;\r
1381                           }\r
1382                         ;\r
1383 \r
1384 variant_type            : /* EMPTY */\r
1385                         | K_NULL\r
1386                         | K_VARIANT\r
1387                           {\r
1388                                 $$ = SafeArrayType.variant;\r
1389                           }\r
1390                         | K_CURRENCY\r
1391                           {\r
1392                                 $$ = SafeArrayType.currency;\r
1393                           }\r
1394                         | K_VOID\r
1395                         | K_BOOL\r
1396                           {\r
1397                                 $$ = SafeArrayType.boolean;\r
1398                           }\r
1399                         | K_INT8\r
1400                           {\r
1401                                 $$ = SafeArrayType.int8;\r
1402                           }\r
1403                         | K_INT16\r
1404                           {\r
1405                                 $$ = SafeArrayType.int16;\r
1406                           }\r
1407                         | K_INT32\r
1408                           {\r
1409                                 $$ = SafeArrayType.int32;\r
1410                           }\r
1411                         | K_INT64\r
1412                         | K_FLOAT32\r
1413                           {\r
1414                                 $$ = SafeArrayType.float32;\r
1415                           }\r
1416                         | K_FLOAT64\r
1417                           {\r
1418                                 $$ = SafeArrayType.float64;\r
1419                           }\r
1420                         | K_UNSIGNED K_INT8\r
1421                           {\r
1422                                 $$ = SafeArrayType.uint8;\r
1423                           }\r
1424                         | K_UNSIGNED K_INT16\r
1425                           {\r
1426                                 $$ = SafeArrayType.uint16;\r
1427                           }\r
1428                         | K_UNSIGNED K_INT32\r
1429                           {\r
1430                                 $$ = SafeArrayType.uint32;\r
1431                           }\r
1432                         | K_UNSIGNED K_INT64\r
1433                         | STAR\r
1434                         | variant_type OPEN_BRACKET CLOSE_BRACKET\r
1435                         | variant_type K_VECTOR\r
1436                         | variant_type AMPERSAND\r
1437                         | K_DECIMAL\r
1438                           {\r
1439                                 $$ = SafeArrayType.Decimal;\r
1440                           }\r
1441                         | K_DATE\r
1442                           {\r
1443                                 $$ = SafeArrayType.date;\r
1444                           }\r
1445                         | K_BSTR\r
1446                           {\r
1447                                 $$ = SafeArrayType.bstr;\r
1448                           }\r
1449                         | K_LPSTR\r
1450                         | K_LPWSTR\r
1451                         | K_IUNKNOWN\r
1452                           {\r
1453                                 $$ = SafeArrayType.unknown;\r
1454                           }\r
1455                         | K_IDISPATCH\r
1456                           {\r
1457                                 $$ = SafeArrayType.unknown;\r
1458                           }\r
1459                         | K_SAFEARRAY\r
1460                         | K_INT\r
1461                           {\r
1462                                 $$ = SafeArrayType.Int;\r
1463                           }\r
1464                         | K_UNSIGNED K_INT\r
1465                           {\r
1466                                 $$ = SafeArrayType.UInt;\r
1467                           }\r
1468                         | K_ERROR\r
1469                           {\r
1470                                 $$ = SafeArrayType.error;\r
1471                           }\r
1472                         | K_HRESULT\r
1473                         | K_CARRAY\r
1474                         | K_USERDEFINED\r
1475                         | K_RECORD\r
1476                         | K_FILETIME\r
1477                         | K_BLOB\r
1478                         | K_STREAM\r
1479                         | K_STORAGE\r
1480                         | K_STREAMED_OBJECT\r
1481                         | K_STORED_OBJECT\r
1482                         | K_BLOB_OBJECT\r
1483                         | K_CF\r
1484                         | K_CLSID\r
1485                         ;\r
1486 \r
1487 custom_modifier_type\r
1488                         : primitive_type\r
1489                         | class_ref\r
1490                         ;\r
1491 \r
1492 field_decl              : D_FIELD repeat_opt field_attr type id at_opt init_opt semicolon_opt\r
1493                           {\r
1494                                 FieldDef field_def = new FieldDef((FieldAttr) $3, \r
1495                                         (string) $5, (BaseTypeRef) $4);\r
1496                                 codegen.AddFieldDef (field_def);\r
1497                                 codegen.CurrentCustomAttrTarget = field_def;\r
1498                                 \r
1499                                 if ($2 != null) {\r
1500                                         field_def.SetOffset ((uint) (int)$2);\r
1501                                 }\r
1502 \r
1503                                 if ($6 != null) {\r
1504                                         field_def.AddDataValue ((string) $6);\r
1505                                 }\r
1506 \r
1507                                 if ($7 != null) {\r
1508                                         field_def.SetValue ((Constant) $7);\r
1509                                 }\r
1510                           }\r
1511                         ;\r
1512 \r
1513 repeat_opt              : /* EMPTY */\r
1514                         | OPEN_BRACKET int32 CLOSE_BRACKET\r
1515                           {\r
1516                                 $$ = $2;\r
1517                           }\r
1518                         ;\r
1519 \r
1520 field_attr              : /* EMPTY */\r
1521                           {\r
1522                                 $$ = new FieldAttr ();\r
1523                           }\r
1524                         | field_attr K_PUBLIC\r
1525                           {\r
1526                                 $$ = (FieldAttr) $1 | FieldAttr.Public;\r
1527                           }\r
1528                         | field_attr K_PRIVATE\r
1529                           {\r
1530                                 $$ = (FieldAttr) $1 | FieldAttr.Private;\r
1531                           }\r
1532                         | field_attr K_FAMILY\r
1533                           {\r
1534                                 $$ = (FieldAttr) $1 | FieldAttr.Family;\r
1535                           }\r
1536                         | field_attr K_ASSEMBLY\r
1537                           {\r
1538                                 $$ = (FieldAttr) $1 | FieldAttr.Assembly;\r
1539                           }\r
1540                         | field_attr K_FAMANDASSEM\r
1541                           {\r
1542                                 $$ = (FieldAttr) $1 | FieldAttr.FamAndAssem;\r
1543                           }\r
1544                         | field_attr K_FAMORASSEM\r
1545                           {\r
1546                                 $$ = (FieldAttr) $1 | FieldAttr.FamOrAssem;\r
1547                           }\r
1548                         | field_attr K_PRIVATESCOPE\r
1549                           {\r
1550                                 // This is just 0x0000\r
1551                           }\r
1552                         | field_attr K_STATIC\r
1553                           {\r
1554                                 $$ = (FieldAttr) $1 | FieldAttr.Static;\r
1555                           }\r
1556                         | field_attr K_INITONLY\r
1557                           {\r
1558                                 $$ = (FieldAttr) $1 | FieldAttr.Initonly;\r
1559                           }\r
1560                         | field_attr K_RTSPECIALNAME\r
1561                           {\r
1562                                 $$ = (FieldAttr) $1 | FieldAttr.RTSpecialName;\r
1563                           }\r
1564                         | field_attr K_SPECIALNAME\r
1565                           {\r
1566                                 $$ = (FieldAttr) $1 | FieldAttr.SpecialName;\r
1567                           }\r
1568                         | field_attr K_MARSHAL OPEN_PARENS native_type CLOSE_PARENS\r
1569                           {\r
1570                                codegen.AddFieldMarshalInfo ((NativeType) $4);\r
1571                                $$ = (FieldAttr) $1 | FieldAttr.HasFieldMarshal;\r
1572                           }\r
1573                         | field_attr K_LITERAL\r
1574                           {\r
1575                                 $$ = (FieldAttr) $1 | FieldAttr.Literal;\r
1576                           }\r
1577                         | field_attr K_NOTSERIALIZED\r
1578                           {\r
1579                                 $$ = (FieldAttr) $1 | FieldAttr.Notserialized;\r
1580                           }\r
1581                         ;\r
1582 \r
1583 at_opt                  : /* EMPTY */\r
1584                         | K_AT id\r
1585                           {\r
1586                                 $$ = $2;\r
1587                           }\r
1588                         ;\r
1589 \r
1590 init_opt                : /* EMPTY */\r
1591                         | ASSIGN field_init\r
1592                           {\r
1593                                 $$ = $2;\r
1594                           }\r
1595                         ;\r
1596 \r
1597 field_init_primitive    : K_FLOAT32 OPEN_PARENS float64 CLOSE_PARENS\r
1598                           {\r
1599                                 $$ = new FloatConst (Convert.ToSingle ($3));\r
1600                           }\r
1601                         | K_FLOAT64 OPEN_PARENS float64 CLOSE_PARENS\r
1602                           {\r
1603                                 $$ = new DoubleConst (Convert.ToDouble ($3));\r
1604                           }\r
1605                         | K_FLOAT32 OPEN_PARENS int64 CLOSE_PARENS\r
1606                           {\r
1607                                 $$ = new FloatConst (BitConverter.ToSingle (BitConverter.GetBytes ((long)$3), BitConverter.IsLittleEndian ? 0 : 4));\r
1608                           }\r
1609                         | K_FLOAT64 OPEN_PARENS int64 CLOSE_PARENS\r
1610                           {\r
1611                                 $$ = new DoubleConst (BitConverter.Int64BitsToDouble ((long)$3));\r
1612                           }\r
1613                         | K_INT64 OPEN_PARENS int64 CLOSE_PARENS\r
1614                           {\r
1615                                 $$ = new IntConst (Convert.ToInt64 ($3));\r
1616                           }\r
1617                         | K_UINT64 OPEN_PARENS int64 CLOSE_PARENS\r
1618                           {\r
1619                                 $$ = new UIntConst (Convert.ToUInt64 ((ulong)(long) $3));\r
1620                           }\r
1621                         | K_INT32 OPEN_PARENS int64 CLOSE_PARENS\r
1622                           {\r
1623                                 $$ = new IntConst ((int)((long)$3));\r
1624                           }\r
1625                         | K_UINT32 OPEN_PARENS int64 CLOSE_PARENS\r
1626                           {\r
1627                                 $$ = new UIntConst ((uint)((long)$3));\r
1628                           }\r
1629                         | K_INT16 OPEN_PARENS int64 CLOSE_PARENS\r
1630                           {\r
1631                                 $$ = new IntConst ((short)((long) $3));\r
1632                           }\r
1633                         | K_UINT16 OPEN_PARENS int64 CLOSE_PARENS\r
1634                           {\r
1635                                 $$ = new UIntConst ((ushort)((long) $3));\r
1636                           }\r
1637                         | K_CHAR OPEN_PARENS int64 CLOSE_PARENS\r
1638                           {\r
1639                                 $$ = new CharConst (Convert.ToChar ($3));\r
1640                           }\r
1641                         | K_WCHAR OPEN_PARENS int64 CLOSE_PARENS\r
1642                           {\r
1643                                 $$ = new CharConst (Convert.ToChar ($3));\r
1644                           }\r
1645                         | K_INT8 OPEN_PARENS int64 CLOSE_PARENS\r
1646                           {\r
1647                                 $$ = new IntConst ((sbyte)((long) ($3)));\r
1648                           }\r
1649                         | K_UINT8 OPEN_PARENS int64 CLOSE_PARENS\r
1650                           {\r
1651                                 $$ = new UIntConst ((byte)((long) ($3)));\r
1652                           }\r
1653                         | K_BOOL OPEN_PARENS truefalse CLOSE_PARENS\r
1654                           {\r
1655                                 $$ = new BoolConst ((bool) $3);\r
1656                           }\r
1657                         ;\r
1658 \r
1659 field_init_full : field_init_primitive\r
1660                         | K_BYTEARRAY bytes_list\r
1661                           {\r
1662                                 $$ = new ByteArrConst ((byte[]) $2);\r
1663                           }\r
1664                         ;\r
1665 \r
1666 field_init : field_init_full\r
1667                         | comp_qstring\r
1668                           {\r
1669                                 // ******** THIS IS NOT IN THE DOCUMENTATION ******** //\r
1670                                 $$ = new StringConst ((string) $1);\r
1671                           }\r
1672                         | K_NULLREF\r
1673                           {\r
1674                                 $$ = new NullConst ();\r
1675                           }\r
1676                         ;\r
1677 \r
1678 member_init : field_init_full\r
1679                         | K_STRING OPEN_PARENS SQSTRING CLOSE_PARENS\r
1680                           {\r
1681                                 $$ = new StringConst ((string) $3);\r
1682                           }\r
1683                         ;\r
1684 \r
1685 opt_truefalse_list\r
1686                                 : truefalse_list\r
1687                                 ;\r
1688 \r
1689 truefalse_list\r
1690                                 : truefalse\r
1691                                   {\r
1692                                         $$ = new List<BoolConst> () { new BoolConst ((bool) $1) };\r
1693                                   }\r
1694                                 | truefalse_list truefalse\r
1695                                   {\r
1696                                         var l = (List<BoolConst>) $1;\r
1697                                         l.Add (new BoolConst ((bool) $2));\r
1698                                         $$ = l;\r
1699                                   }\r
1700                                 ;\r
1701 \r
1702 data_decl               : data_head data_body\r
1703                           {\r
1704                                 DataDef datadef = (DataDef) $1;\r
1705                                 \r
1706                                 if ($2 is ArrayList) {\r
1707                                         ArrayList const_list = (ArrayList) $2;\r
1708                                         DataConstant[] const_arr = new DataConstant[const_list.Count];\r
1709                                         \r
1710                                         for (int i=0; i<const_arr.Length; i++)\r
1711                                                 const_arr[i] = (DataConstant) const_list[i];\r
1712 \r
1713                                         datadef.PeapiConstant = new ArrayConstant (const_arr);\r
1714                                 } else {\r
1715                                         datadef.PeapiConstant = (PEAPI.Constant) $2;\r
1716                                 }\r
1717                                 codegen.AddDataDef (datadef);\r
1718                           }\r
1719                         ;\r
1720 \r
1721 data_head               : D_DATA data_attr id ASSIGN\r
1722                           {\r
1723                                 $$ = new DataDef ((string) $3, (DataSegment) $2);\r
1724                           } \r
1725                         | D_DATA data_attr\r
1726                           {\r
1727                                 $$ = new DataDef (String.Empty, (DataSegment) $2);\r
1728                           }\r
1729                         ;\r
1730 \r
1731 data_attr               : /* EMPTY */                   { $$ = DataSegment.Data; }\r
1732                         | K_TLS                         { $$ = DataSegment.TLS; }\r
1733                         | K_CIL                         { $$ = DataSegment.CIL; }\r
1734                         ;\r
1735 \r
1736 data_body               : OPEN_BRACE dataitem_list CLOSE_BRACE\r
1737                           {\r
1738                                 $$ = $2;\r
1739                           }\r
1740                         | dataitem\r
1741                         ;\r
1742 \r
1743 dataitem_list           : dataitem\r
1744                           {\r
1745                                 ArrayList dataitem_list = new ArrayList ();\r
1746                                 dataitem_list.Add ($1);\r
1747                                 $$ = dataitem_list;\r
1748                           }\r
1749                         | dataitem_list COMMA dataitem\r
1750                           {\r
1751                                 ArrayList list = (ArrayList) $1;\r
1752                                 list.Add ($3);\r
1753                           }\r
1754                         ;\r
1755 \r
1756 dataitem                : K_CHAR STAR OPEN_PARENS comp_qstring CLOSE_PARENS\r
1757                           {\r
1758                                 $$ = new StringConst ((string) $4);\r
1759                           }\r
1760                         | K_WCHAR STAR OPEN_PARENS comp_qstring CLOSE_PARENS\r
1761                           {\r
1762                                 $$ = new StringConst ((string) $4);\r
1763                           }\r
1764                         | AMPERSAND OPEN_PARENS id CLOSE_PARENS\r
1765                           {\r
1766                            //     DataDef def = codegen.CurrentTypeDef.GetDataDef ((string) $3);\r
1767                            //     $$ = new AddressConstant ((DataConstant) def.PeapiConstant);\r
1768                           }\r
1769                         | K_BYTEARRAY ASSIGN bytes_list\r
1770                           {\r
1771                                 $$ = new ByteArrConst ((byte[]) $3);\r
1772                           }\r
1773                         | K_BYTEARRAY bytes_list\r
1774                           {\r
1775                                 // ******** THIS IS NOT IN THE SPECIFICATION ******** //\r
1776                                 $$ = new ByteArrConst ((byte[]) $2);\r
1777                           }\r
1778                         | K_FLOAT32 OPEN_PARENS float64 CLOSE_PARENS repeat_opt\r
1779                           {\r
1780                                 double d = (double) $3;\r
1781                                 FloatConst float_const = new FloatConst ((float) d);\r
1782 \r
1783                                 if ($5 != null)\r
1784                                         $$ = new RepeatedConstant (float_const, (int) $5);\r
1785                                 else\r
1786                                         $$ = float_const;\r
1787                           }\r
1788                         | K_FLOAT64 OPEN_PARENS float64 CLOSE_PARENS repeat_opt\r
1789                           {\r
1790                                 DoubleConst double_const = new DoubleConst ((double) $3);\r
1791 \r
1792                                 if ($5 != null)\r
1793                                         $$ = new RepeatedConstant (double_const, (int) $5);\r
1794                                 else\r
1795                                         $$ = double_const;\r
1796                           }\r
1797                         | K_INT64 OPEN_PARENS int64 CLOSE_PARENS repeat_opt\r
1798                           {\r
1799                                 IntConst int_const = new IntConst ((long) $3);\r
1800 \r
1801                                 if ($5 != null)\r
1802                                         $$ = new RepeatedConstant (int_const, (int) $5);\r
1803                                 else\r
1804                                         $$ = int_const;\r
1805                           }\r
1806                         | K_INT32 OPEN_PARENS int32 CLOSE_PARENS repeat_opt\r
1807                           {\r
1808                                 IntConst int_const = new IntConst ((int) $3);\r
1809 \r
1810                                 if ($5 != null)\r
1811                                         $$ = new RepeatedConstant (int_const, (int) $5);\r
1812                                 else\r
1813                                         $$ = int_const;\r
1814                           }\r
1815                         | K_INT16 OPEN_PARENS int32 CLOSE_PARENS repeat_opt\r
1816                           {\r
1817                                 int i = (int) $3;\r
1818                                 IntConst int_const = new IntConst ((short) i);\r
1819 \r
1820                                 if ($5 != null)\r
1821                                         $$ = new RepeatedConstant (int_const, (int) $5);\r
1822                                 else\r
1823                                         $$ = int_const;\r
1824                           }\r
1825                         | K_INT8 OPEN_PARENS int32 CLOSE_PARENS repeat_opt\r
1826                           {\r
1827                                 int i = (int) $3;\r
1828                                 IntConst int_const = new IntConst ((sbyte) i);\r
1829 \r
1830                                 if ($5 != null)\r
1831                                         $$ = new RepeatedConstant (int_const, (int) $5);\r
1832                                 else\r
1833                                         $$ = int_const;\r
1834                           }\r
1835                         | K_FLOAT32 repeat_opt\r
1836                           {\r
1837                                 FloatConst float_const = new FloatConst (0F);\r
1838 \r
1839                                 if ($2 != null)\r
1840                                         $$ = new RepeatedConstant (float_const, (int) $2);\r
1841                                 else\r
1842                                         $$ = float_const;\r
1843                           }\r
1844                         | K_FLOAT64 repeat_opt\r
1845                           {\r
1846                                 DoubleConst double_const = new DoubleConst (0);\r
1847 \r
1848                                 if ($2 != null)\r
1849                                         $$ = new RepeatedConstant (double_const, (int) $2);\r
1850                                 else\r
1851                                         $$ = double_const;\r
1852                           }\r
1853                         | K_INT64 repeat_opt\r
1854                           {\r
1855                                 IntConst int_const = new IntConst ((long) 0);\r
1856 \r
1857                                 if ($2 != null)\r
1858                                         $$ = new RepeatedConstant (int_const, (int) $2);\r
1859                                 else\r
1860                                         $$ = int_const;\r
1861                           }\r
1862                         | K_INT32 repeat_opt\r
1863                           {\r
1864                                 IntConst int_const = new IntConst ((int) 0);\r
1865 \r
1866                                 if ($2 != null)\r
1867                                         $$ = new RepeatedConstant (int_const, (int) $2);\r
1868                                 else\r
1869                                         $$ = int_const;\r
1870                           }\r
1871                         | K_INT16 repeat_opt\r
1872                           {\r
1873                                 IntConst int_const = new IntConst ((short) 0);\r
1874 \r
1875                                 if ($2 != null)\r
1876                                         $$ = new RepeatedConstant (int_const, (int) $2);\r
1877                                 else\r
1878                                         $$ = int_const;\r
1879                           }\r
1880                         | K_INT8 repeat_opt\r
1881                           {\r
1882                                 IntConst int_const = new IntConst ((sbyte) 0);\r
1883 \r
1884                                 if ($2 != null)\r
1885                                         $$ = new RepeatedConstant (int_const, (int) $2);\r
1886                                 else\r
1887                                         $$ = int_const;\r
1888                           }\r
1889                         ;\r
1890 \r
1891 method_all              : method_head OPEN_BRACE method_decls CLOSE_BRACE\r
1892                           {\r
1893                                 codegen.EndMethodDef (tokenizer.Location);\r
1894                           }\r
1895                         ;\r
1896 \r
1897 method_head             : D_METHOD meth_attr call_conv param_attr type method_name\r
1898                           formal_typars_clause OPEN_PARENS sig_args CLOSE_PARENS impl_attr\r
1899                           {\r
1900                                 CallConv cc = (CallConv) $3;\r
1901                                 if ($7 != null)\r
1902                                         cc |= CallConv.Generic;\r
1903 \r
1904                                 MethodDef methdef = new MethodDef (\r
1905                                         codegen, (MethAttr) $2, cc,\r
1906                                         (ImplAttr) $11, (string) $6, (BaseTypeRef) $5,\r
1907                                         (ArrayList) $9, tokenizer.Reader.Location, (GenericParameters) $7, codegen.CurrentTypeDef);\r
1908                                 if (pinvoke_info) {\r
1909                                         ExternModule mod = codegen.ExternTable.AddModule (pinvoke_mod);\r
1910                                         methdef.AddPInvokeInfo (pinvoke_attr, mod, pinvoke_meth);\r
1911                                         pinvoke_info = false;\r
1912                                 }\r
1913                           }\r
1914                         | D_METHOD meth_attr call_conv param_attr type \r
1915                           K_MARSHAL OPEN_PARENS native_type CLOSE_PARENS method_name\r
1916                           OPEN_PARENS sig_args CLOSE_PARENS impl_attr\r
1917                           {\r
1918                                 MethodDef methdef = new MethodDef (\r
1919                                         codegen, (MethAttr) $2, (CallConv) $3,\r
1920                                         (ImplAttr) $14, (string) $10, (BaseTypeRef) $5,\r
1921                                         (ArrayList) $12, tokenizer.Reader.Location, null, codegen.CurrentTypeDef);\r
1922 \r
1923                                 if (pinvoke_info) {\r
1924                                         ExternModule mod = codegen.ExternTable.AddModule (pinvoke_mod);\r
1925                                         methdef.AddPInvokeInfo (pinvoke_attr, mod, pinvoke_meth);\r
1926                                         pinvoke_info = false;\r
1927                                 }\r
1928                                 \r
1929                                 methdef.AddRetTypeMarshalInfo ((NativeType) $8);\r
1930                           }\r
1931                         ;\r
1932 \r
1933 meth_attr               : /* EMPTY */                   { $$ = new MethAttr (); }\r
1934                         | meth_attr K_STATIC            { $$ = (MethAttr) $1 | MethAttr.Static; }\r
1935                         | meth_attr K_PUBLIC            { $$ = (MethAttr) $1 | MethAttr.Public; }\r
1936                         | meth_attr K_PRIVATE           { $$ = (MethAttr) $1 | MethAttr.Private; }\r
1937                         | meth_attr K_FAMILY            { $$ = (MethAttr) $1 | MethAttr.Family; }\r
1938                         | meth_attr K_ASSEMBLY          { $$ = (MethAttr) $1 | MethAttr.Assembly; }\r
1939                         | meth_attr K_FAMANDASSEM       { $$ = (MethAttr) $1 | MethAttr.FamAndAssem; } \r
1940                         | meth_attr K_FAMORASSEM        { $$ = (MethAttr) $1 | MethAttr.FamOrAssem; } \r
1941                         | meth_attr K_PRIVATESCOPE      { /* CHECK HEADERS */ }\r
1942                         | meth_attr K_FINAL             { $$ = (MethAttr) $1 | MethAttr.Final; } \r
1943                         | meth_attr K_VIRTUAL           { $$ = (MethAttr) $1 | MethAttr.Virtual; }\r
1944                         | meth_attr K_ABSTRACT          { $$ = (MethAttr) $1 | MethAttr.Abstract; }\r
1945                         | meth_attr K_HIDEBYSIG         { $$ = (MethAttr) $1 | MethAttr.HideBySig; }\r
1946                         | meth_attr K_NEWSLOT           { $$ = (MethAttr) $1 | MethAttr.NewSlot; }\r
1947                         | meth_attr K_REQSECOBJ         { $$ = (MethAttr) $1 | MethAttr.RequireSecObject; }\r
1948                         | meth_attr K_SPECIALNAME       { $$ = (MethAttr) $1 | MethAttr.SpecialName; }\r
1949                         | meth_attr K_RTSPECIALNAME     { $$ = (MethAttr) $1 | MethAttr.RTSpecialName; }\r
1950                         | meth_attr K_STRICT            { $$ = (MethAttr) $1 | MethAttr.Strict; }\r
1951                         | meth_attr K_COMPILERCONTROLLED { /* Do nothing */ }\r
1952                         | meth_attr K_UNMANAGEDEXP      \r
1953                         | meth_attr K_PINVOKEIMPL OPEN_PARENS comp_qstring K_AS\r
1954                                 comp_qstring pinv_attr CLOSE_PARENS\r
1955                           {\r
1956                                 pinvoke_info = true;\r
1957                                 pinvoke_mod = (string) $4;\r
1958                                 pinvoke_meth = (string) $6;\r
1959                                 pinvoke_attr = (PInvokeAttr) $7;\r
1960                           }\r
1961                         | meth_attr K_PINVOKEIMPL OPEN_PARENS comp_qstring pinv_attr CLOSE_PARENS\r
1962                           {\r
1963                                 pinvoke_info = true;\r
1964                                 pinvoke_mod = (string) $4;\r
1965                                 pinvoke_meth = null;\r
1966                                 pinvoke_attr = (PInvokeAttr) $5;\r
1967                           }\r
1968                         | meth_attr K_PINVOKEIMPL OPEN_PARENS pinv_attr CLOSE_PARENS\r
1969                           {\r
1970                                 pinvoke_info = true;\r
1971                                 pinvoke_mod = null;\r
1972                                 pinvoke_meth = null;\r
1973                                 pinvoke_attr = (PInvokeAttr) $4;\r
1974                           }\r
1975                         ;\r
1976 \r
1977 pinv_attr               : /* EMPTY */ { $$ = new PInvokeAttr (); }\r
1978                         | pinv_attr K_NOMANGLE { $$ = (PInvokeAttr) $1 | PInvokeAttr.nomangle; }\r
1979                         | pinv_attr K_ANSI { $$ = (PInvokeAttr) $1 | PInvokeAttr.ansi; }\r
1980                         | pinv_attr K_UNICODE { $$ = (PInvokeAttr) $1 | PInvokeAttr.unicode; }\r
1981                         | pinv_attr K_AUTOCHAR { $$ = (PInvokeAttr) $1 | PInvokeAttr.autochar; }\r
1982                         | pinv_attr K_LASTERR { $$ = (PInvokeAttr) $1 | PInvokeAttr.lasterr; }\r
1983                         | pinv_attr K_WINAPI { $$ = (PInvokeAttr) $1 | PInvokeAttr.winapi; }\r
1984                         | pinv_attr K_CDECL { $$ = (PInvokeAttr) $1 | PInvokeAttr.cdecl; }\r
1985                         | pinv_attr K_STDCALL { $$ = (PInvokeAttr) $1 | PInvokeAttr.stdcall; }\r
1986                         | pinv_attr K_THISCALL { $$ = (PInvokeAttr) $1 | PInvokeAttr.thiscall; }\r
1987                         | pinv_attr K_FASTCALL { $$ = (PInvokeAttr) $1 | PInvokeAttr.fastcall; }\r
1988                         | pinv_attr K_BESTFIT COLON K_ON { $$ = (PInvokeAttr) $1 | PInvokeAttr.bestfit_on; }\r
1989                         | pinv_attr K_BESTFIT COLON K_OFF { $$ = (PInvokeAttr) $1 | PInvokeAttr.bestfit_off; }\r
1990                         | pinv_attr K_CHARMAPERROR COLON K_ON { $$ = (PInvokeAttr) $1 | PInvokeAttr.charmaperror_on; }\r
1991                         | pinv_attr K_CHARMAPERROR COLON K_OFF { $$ = (PInvokeAttr) $1 | PInvokeAttr.charmaperror_off; }\r
1992                         ;\r
1993 \r
1994 method_name             : D_CTOR\r
1995                         | D_CCTOR\r
1996                         | comp_name\r
1997                         ;\r
1998 \r
1999 param_attr              : /* EMPTY */                                   { $$ = new ParamAttr (); }\r
2000                         | param_attr OPEN_BRACKET K_IN CLOSE_BRACKET    { $$ = (ParamAttr) $1 | ParamAttr.In; }\r
2001                         | param_attr OPEN_BRACKET K_OUT CLOSE_BRACKET   { $$ = (ParamAttr) $1 | ParamAttr.Out; }\r
2002                         | param_attr OPEN_BRACKET K_OPT CLOSE_BRACKET   { $$ = (ParamAttr) $1 | ParamAttr.Opt; }\r
2003                         ;\r
2004 \r
2005 impl_attr               : /* EMPTY */                   { $$ = new ImplAttr (); }\r
2006                         | impl_attr K_NATIVE            { $$ = (ImplAttr) $1 | ImplAttr.Native; }\r
2007                         | impl_attr K_CIL               { $$ = (ImplAttr) $1 | ImplAttr.IL; }\r
2008                         | impl_attr K_IL                { $$ = (ImplAttr) $1 | ImplAttr.IL; }\r
2009                         | impl_attr K_OPTIL             { $$ = (ImplAttr) $1 | ImplAttr.Optil; }\r
2010                         | impl_attr K_MANAGED           { /* should this reset? */ }\r
2011                         | impl_attr K_UNMANAGED         { $$ = (ImplAttr) $1 | ImplAttr.Unmanaged; }\r
2012                         | impl_attr K_FORWARDREF        { $$ = (ImplAttr) $1 | ImplAttr.ForwardRef; }\r
2013                         | impl_attr K_PRESERVESIG       { $$ = (ImplAttr) $1 | ImplAttr.PreserveSig; }\r
2014                         | impl_attr K_RUNTIME           { $$ = (ImplAttr) $1 | ImplAttr.Runtime; }\r
2015                         | impl_attr K_INTERNALCALL      { $$ = (ImplAttr) $1 | ImplAttr.InternalCall; }\r
2016                         | impl_attr K_SYNCHRONIZED      { $$ = (ImplAttr) $1 | ImplAttr.Synchronised; }\r
2017                         | impl_attr K_NOINLINING        { $$ = (ImplAttr) $1 | ImplAttr.NoInLining; }\r
2018                         | impl_attr K_NOOPTIMIZATION    { $$ = (ImplAttr) $1 | ImplAttr.NoOptimization; }\r
2019                         ;\r
2020 \r
2021 sig_args                : /* EMPTY */\r
2022                         | sig_arg_list\r
2023                         ;\r
2024 \r
2025 sig_arg_list            : sig_arg\r
2026                           {\r
2027                                 ArrayList sig_list = new ArrayList ();\r
2028                                 sig_list.Add ($1);\r
2029                                 $$ = sig_list;\r
2030                           }\r
2031                         | sig_arg_list COMMA sig_arg\r
2032                           {\r
2033                                 ArrayList sig_list = (ArrayList) $1;\r
2034                                 sig_list.Add ($3);\r
2035                                 $$ = sig_list;\r
2036                           }\r
2037                         ;\r
2038 \r
2039 sig_arg                 : param_attr type\r
2040                           {\r
2041                                 $$ = new ParamDef ((ParamAttr) $1, null, (BaseTypeRef) $2);\r
2042                           }\r
2043                         | param_attr type id\r
2044                           {\r
2045                                 $$ = new ParamDef ((ParamAttr) $1, (string) $3, (BaseTypeRef) $2);\r
2046                           }\r
2047                         | ELLIPSIS\r
2048                           {\r
2049                                 $$ = new ParamDef ((ParamAttr) 0, "...", new SentinelTypeRef ());\r
2050                                 // $$ = ParamDef.Ellipsis;\r
2051                           }\r
2052                         | param_attr type K_MARSHAL OPEN_PARENS native_type CLOSE_PARENS\r
2053                           {\r
2054                                 ParamDef param_def = new ParamDef ((ParamAttr) $1, null, (BaseTypeRef) $2);\r
2055                                 param_def.AddMarshalInfo ((PEAPI.NativeType) $5);\r
2056 \r
2057                                 $$ = param_def;\r
2058                           }\r
2059                         | param_attr type K_MARSHAL OPEN_PARENS native_type CLOSE_PARENS id\r
2060                           {\r
2061                                 ParamDef param_def = new ParamDef ((ParamAttr) $1, (string) $7, (BaseTypeRef) $2);\r
2062                                 param_def.AddMarshalInfo ((PEAPI.NativeType) $5);\r
2063 \r
2064                                 $$ = param_def;\r
2065                           }\r
2066                         ;\r
2067 \r
2068 type_list               : /* EMPTY */\r
2069                           {\r
2070                                 $$ = new ArrayList (0);\r
2071                           }\r
2072                         | ELLIPSIS\r
2073                           {\r
2074                                 ArrayList type_list = new ArrayList ();\r
2075                                 // type_list.Add (TypeRef.Ellipsis);\r
2076                                 type_list.Add (new SentinelTypeRef ());\r
2077                                 $$ = type_list;\r
2078                           }\r
2079                         | type_list COMMA ELLIPSIS\r
2080                           {\r
2081                                 ArrayList type_list = (ArrayList) $1;\r
2082                                 // type_list.Add (TypeRef.Ellipsis);\r
2083                                 type_list.Add (new SentinelTypeRef ());\r
2084                                 $$ = type_list;\r
2085                           }\r
2086                         | param_attr type opt_id\r
2087                           {\r
2088                                 ArrayList type_list = new ArrayList ();\r
2089                                 type_list.Add ($2);\r
2090                                 $$ = type_list;\r
2091                           }\r
2092                         | type_list COMMA param_attr type opt_id\r
2093                           {\r
2094                                 ArrayList type_list = (ArrayList) $1;\r
2095                                 type_list.Add ($4);\r
2096                           }\r
2097                         ;\r
2098 \r
2099 opt_id                  : /* EMPTY */\r
2100                         | id\r
2101                         ;\r
2102 \r
2103 method_decls            : /* EMPTY */\r
2104                         | method_decls method_decl\r
2105                         ;\r
2106 \r
2107 method_decl             : D_EMITBYTE int32\r
2108                                                 {\r
2109                                                         codegen.CurrentMethodDef.AddInstr (new\r
2110                                         EmitByteInstr ((int) $2, tokenizer.Location));\r
2111                           \r
2112                                                 }\r
2113                         | D_MAXSTACK int32\r
2114                           {\r
2115                                 codegen.CurrentMethodDef.SetMaxStack ((int) $2);\r
2116                           }\r
2117                         | D_LOCALS OPEN_PARENS local_list CLOSE_PARENS\r
2118                           {\r
2119                                 if ($3 != null) {\r
2120                                         codegen.CurrentMethodDef.AddLocals (\r
2121                                                 (ArrayList) $3);\r
2122                                 }\r
2123                           }\r
2124                         | D_LOCALS K_INIT OPEN_PARENS local_list CLOSE_PARENS\r
2125                           {\r
2126                                 if ($4 != null) {\r
2127                                         codegen.CurrentMethodDef.AddLocals (\r
2128                                                 (ArrayList) $4);\r
2129                                         codegen.CurrentMethodDef.InitLocals ();\r
2130                                 }\r
2131                           }\r
2132                         | D_ENTRYPOINT\r
2133                           {\r
2134                                 codegen.CurrentMethodDef.EntryPoint ();\r
2135                                 codegen.HasEntryPoint = true;\r
2136                           }\r
2137                         | D_ZEROINIT\r
2138                           {\r
2139                                 codegen.CurrentMethodDef.ZeroInit ();\r
2140                           }\r
2141                         | D_EXPORT OPEN_BRACKET int32 CLOSE_BRACKET\r
2142                         | D_EXPORT OPEN_BRACKET int32 CLOSE_BRACKET K_AS id\r
2143                         | D_VTENTRY int32 COLON int32 \r
2144                         | D_OVERRIDE type_spec DOUBLE_COLON method_name\r
2145                           {\r
2146                                 codegen.CurrentTypeDef.AddOverride (codegen.CurrentMethodDef,\r
2147                                         (BaseTypeRef) $2, (string) $4);\r
2148                                 \r
2149                           }\r
2150                         | D_OVERRIDE K_METHOD method_ref\r
2151                           {\r
2152                                 codegen.CurrentTypeDef.AddOverride (codegen.CurrentMethodDef.Signature,\r
2153                                         (BaseMethodRef) $3);\r
2154                           }\r
2155                         | D_OVERRIDE K_METHOD call_conv type type_spec DOUBLE_COLON method_name\r
2156                           OPEN_ANGLE_BRACKET OPEN_BRACKET int32 CLOSE_BRACKET CLOSE_ANGLE_BRACKET\r
2157                           OPEN_PARENS type_list CLOSE_PARENS \r
2158                           {\r
2159                                 BaseTypeRef owner = (BaseTypeRef) $5;\r
2160                                 ArrayList arg_list = (ArrayList) $14;\r
2161                                 BaseTypeRef[] param_list;\r
2162                                 BaseMethodRef methref;\r
2163 \r
2164                                 if (arg_list != null)\r
2165                                         param_list = (BaseTypeRef[]) arg_list.ToArray (typeof (BaseTypeRef));\r
2166                                 else\r
2167                                         param_list = new BaseTypeRef[0];\r
2168 \r
2169                                 if (owner.UseTypeSpec) {\r
2170                                         methref = new TypeSpecMethodRef (owner, (CallConv) $3, (BaseTypeRef) $4,\r
2171                                                 (string) $7, param_list, (int) $10);\r
2172                                 } else {\r
2173                                         methref = owner.GetMethodRef ((BaseTypeRef) $4,\r
2174                                                 (CallConv) $3, (string) $7, param_list, (int) $10);\r
2175                                 }\r
2176 \r
2177                                 codegen.CurrentTypeDef.AddOverride (codegen.CurrentMethodDef.Signature,\r
2178                                         methref);\r
2179                           }\r
2180                         | scope_block\r
2181                         | D_PARAM OPEN_BRACKET int32 CLOSE_BRACKET init_opt\r
2182                           {\r
2183                                 int index = (int) $3;\r
2184                                 ParamDef param = codegen.CurrentMethodDef.GetParam (index);\r
2185                                 codegen.CurrentCustomAttrTarget = param;\r
2186 \r
2187                                 if (param == null) {\r
2188                                         Report.Warning (tokenizer.Location, String.Format ("invalid param index ({0}) with .param", index));\r
2189                                 } else if ($5 != null)\r
2190                                         param.AddDefaultValue ((Constant) $5);\r
2191                           }\r
2192                         | param_type_decl\r
2193                         | id COLON\r
2194                           {\r
2195                                 codegen.CurrentMethodDef.AddLabel ((string) $1);\r
2196                           }\r
2197                         | seh_block\r
2198                         | instr\r
2199                         | sec_decl\r
2200                           {\r
2201                                 AddSecDecl ($1, false);\r
2202                           }\r
2203                         | extsource_spec\r
2204                         | language_decl\r
2205                         | customattr_decl\r
2206                           {\r
2207                                 if (codegen.CurrentCustomAttrTarget != null)\r
2208                                         codegen.CurrentCustomAttrTarget.AddCustomAttribute ((CustomAttr) $1);\r
2209                           }\r
2210                         | data_decl\r
2211                         ;\r
2212 \r
2213 local_list              : /* EMPTY */\r
2214                         | local\r
2215                           {\r
2216                                 ArrayList local_list = new ArrayList ();\r
2217                                 local_list.Add ($1);\r
2218                                 $$ = local_list;\r
2219                           }\r
2220                         | local_list COMMA local\r
2221                           {\r
2222                                 ArrayList local_list = (ArrayList) $1;\r
2223                                 local_list.Add ($3);\r
2224                           }\r
2225                         ;\r
2226 \r
2227 local                   : type\r
2228                           {\r
2229                                 $$ = new Local (-1, (BaseTypeRef) $1);\r
2230                           }\r
2231                         | type id\r
2232                           {\r
2233                                 $$ = new Local (-1, (string) $2, (BaseTypeRef) $1);\r
2234                           }\r
2235                         | slot_num type\r
2236                           {\r
2237                                 $$ = new Local ((int) $1, (BaseTypeRef) $2);\r
2238                           }\r
2239                         | slot_num type id\r
2240                           {\r
2241                                 $$ = new Local ((int) $1, (string) $3, (BaseTypeRef) $2);\r
2242                           }\r
2243                         ;\r
2244 \r
2245 slot_num                : OPEN_BRACKET int32 CLOSE_BRACKET\r
2246                           {\r
2247                                 $$ = $2;\r
2248                           }\r
2249                         ;\r
2250 \r
2251 type_spec               : OPEN_BRACKET slashed_name CLOSE_BRACKET\r
2252                           {\r
2253                                 // This is a reference to a global method in another\r
2254                                 // assembly. This is not supported in the MS version of ilasm\r
2255                           }\r
2256                         | OPEN_BRACKET D_MODULE slashed_name CLOSE_BRACKET\r
2257                           {\r
2258                                 string module = (string) $3;\r
2259 \r
2260                                 if (codegen.IsThisModule (module)) {\r
2261                                     // This is not handled yet.\r
2262                                 } else {\r
2263                                     $$ = codegen.ExternTable.GetModuleTypeRef ((string) $3, "<Module>", false);\r
2264                                 }\r
2265 \r
2266                           }\r
2267                         | type\r
2268                         ;\r
2269 \r
2270 scope_block             : scope_block_begin method_decls CLOSE_BRACE\r
2271                           {\r
2272                                 $$ = new HandlerBlock ((LabelInfo) $1,\r
2273                                         codegen.CurrentMethodDef.AddLabel ());\r
2274                                 codegen.CurrentMethodDef.EndLocalsScope ();\r
2275                           }\r
2276                         ;\r
2277 \r
2278 scope_block_begin       : OPEN_BRACE\r
2279                           {\r
2280                                 $$ = codegen.CurrentMethodDef.AddLabel ();\r
2281                                 codegen.CurrentMethodDef.BeginLocalsScope ();\r
2282                           }\r
2283                         ;\r
2284                         \r
2285                         \r
2286 seh_block               : try_block seh_clauses\r
2287                           {\r
2288                                 TryBlock try_block = (TryBlock) $1;\r
2289 \r
2290                                 ArrayList clause_list = (ArrayList) $2;\r
2291                                 foreach (object clause in clause_list)\r
2292                                         try_block.AddSehClause ((ISehClause) clause);\r
2293 \r
2294                                 codegen.CurrentMethodDef.AddInstr (try_block);\r
2295                           }\r
2296                         ;\r
2297 \r
2298 try_block               : D_TRY scope_block\r
2299                           {\r
2300                                 $$ = new TryBlock ((HandlerBlock) $2, tokenizer.Location);\r
2301                           }\r
2302                         | D_TRY id K_TO id\r
2303                           {\r
2304                                 LabelInfo from = codegen.CurrentMethodDef.AddLabelRef ((string) $2);\r
2305                                 LabelInfo to = codegen.CurrentMethodDef.AddLabelRef ((string) $4);\r
2306                                 \r
2307                                 $$ = new TryBlock (new HandlerBlock (from, to), tokenizer.Location);\r
2308                           }\r
2309                         | D_TRY int32 K_TO int32\r
2310                           {\r
2311                                 LabelInfo from = codegen.CurrentMethodDef.AddLabel ((int) $2);\r
2312                                 LabelInfo to = codegen.CurrentMethodDef.AddLabel ((int) $4);\r
2313                                 \r
2314                                 $$ = new TryBlock (new HandlerBlock (from, to), tokenizer.Location);\r
2315                           }\r
2316                         ;\r
2317 \r
2318 seh_clauses             : seh_clause\r
2319                           {\r
2320                                 ArrayList clause_list = new ArrayList ();\r
2321                                 clause_list.Add ($1);\r
2322                                 $$ = clause_list;\r
2323                           }\r
2324                         | seh_clauses seh_clause\r
2325                           {\r
2326                                 ArrayList clause_list = (ArrayList) $1;\r
2327                                 clause_list.Add ($2);\r
2328                           }\r
2329                         ;\r
2330 \r
2331 seh_clause              : K_CATCH type handler_block\r
2332                           {\r
2333                                 if ($2.GetType () == typeof (PrimitiveTypeRef))\r
2334                                         Report.Error ("Exception not be of a primitive type.");\r
2335                                         \r
2336                                 BaseTypeRef type = (BaseTypeRef) $2;\r
2337                                 CatchBlock cb = new CatchBlock (type);\r
2338                                 cb.SetHandlerBlock ((HandlerBlock) $3);\r
2339                                 $$ = cb;\r
2340                           }\r
2341                         | K_FINALLY handler_block\r
2342                           {\r
2343                                 FinallyBlock fb = new FinallyBlock ();\r
2344                                 fb.SetHandlerBlock ((HandlerBlock) $2);\r
2345                                 $$ = fb;\r
2346                           }\r
2347                         | K_FAULT handler_block\r
2348                           {\r
2349                                 FaultBlock fb = new FaultBlock ();\r
2350                                 fb.SetHandlerBlock ((HandlerBlock) $2);\r
2351                                 $$ = fb;\r
2352                           }\r
2353                         | filter_clause handler_block\r
2354                           {\r
2355                                 FilterBlock fb = (FilterBlock) $1;\r
2356                                 fb.SetHandlerBlock ((HandlerBlock) $2);\r
2357                           }\r
2358                         ;\r
2359 \r
2360 filter_clause           : K_FILTER scope_block\r
2361                           {\r
2362                                 HandlerBlock block = (HandlerBlock) $2;\r
2363                                 FilterBlock fb = new FilterBlock (block);\r
2364                                 $$ = fb;\r
2365                           }\r
2366                         | K_FILTER id\r
2367                           {\r
2368                                 LabelInfo from = codegen.CurrentMethodDef.AddLabelRef ((string) $2);\r
2369                                 FilterBlock fb = new FilterBlock (new HandlerBlock (from, null));\r
2370                                 $$ = fb;\r
2371                           }\r
2372                         | K_FILTER int32\r
2373                           {\r
2374                                 LabelInfo from = codegen.CurrentMethodDef.AddLabel ((int) $2);\r
2375                                 FilterBlock fb = new FilterBlock (new HandlerBlock (from, null));\r
2376                                 $$ = fb;\r
2377                           }\r
2378                         ;\r
2379 \r
2380 handler_block           : scope_block\r
2381                           {\r
2382                                 \r
2383                           }\r
2384                         | K_HANDLER id K_TO id\r
2385                           {     \r
2386                                 LabelInfo from = codegen.CurrentMethodDef.AddLabelRef ((string) $2);\r
2387                                 LabelInfo to = codegen.CurrentMethodDef.AddLabelRef ((string) $4);\r
2388 \r
2389                                 $$ = new HandlerBlock (from, to);\r
2390                           }\r
2391                         | K_HANDLER int32 K_TO int32\r
2392                           {\r
2393                                 LabelInfo from = codegen.CurrentMethodDef.AddLabel ((int) $2);\r
2394                                 LabelInfo to = codegen.CurrentMethodDef.AddLabel ((int) $4);\r
2395 \r
2396                                 $$ = new HandlerBlock (from, to);\r
2397                           }\r
2398                         ;\r
2399 \r
2400 instr                   : INSTR_NONE\r
2401                           {\r
2402                                 codegen.CurrentMethodDef.AddInstr (\r
2403                                         new SimpInstr ((Op) $1, tokenizer.Location));\r
2404                           }\r
2405                         | INSTR_LOCAL int32\r
2406                           {\r
2407                                 codegen.CurrentMethodDef.AddInstr (\r
2408                                         new IntInstr ((IntOp) $1, (int) $2, tokenizer.Location));        \r
2409                           }\r
2410                         | INSTR_LOCAL id\r
2411                           {\r
2412                                 int slot = codegen.CurrentMethodDef.GetNamedLocalSlot ((string) $2);\r
2413                                 if (slot < 0)\r
2414                                         Report.Error (String.Format ("Undeclared identifier '{0}'", (string) $2));\r
2415                                 codegen.CurrentMethodDef.AddInstr (\r
2416                                         new IntInstr ((IntOp) $1, slot, tokenizer.Location));\r
2417                           }\r
2418                         | INSTR_PARAM int32\r
2419                           {\r
2420                                 codegen.CurrentMethodDef.AddInstr (\r
2421                                         new IntInstr ((IntOp) $1, (int) $2, tokenizer.Location));\r
2422                           }\r
2423                         | INSTR_PARAM id\r
2424                           {\r
2425                                 int pos = codegen.CurrentMethodDef.GetNamedParamPos ((string) $2);\r
2426                                 if (pos < 0)\r
2427                                         Report.Error (String.Format ("Undeclared identifier '{0}'", (string) $2));\r
2428 \r
2429                                 codegen.CurrentMethodDef.AddInstr (\r
2430                                         new IntInstr ((IntOp) $1, pos, tokenizer.Location));\r
2431                           }\r
2432                         | INSTR_I int32\r
2433                           {\r
2434                                 codegen.CurrentMethodDef.AddInstr (new\r
2435                                         IntInstr ((IntOp) $1, (int) $2, tokenizer.Location));\r
2436                           }\r
2437                         | INSTR_I id\r
2438                           {\r
2439                                 int slot = codegen.CurrentMethodDef.GetNamedLocalSlot ((string) $2);\r
2440                                 if (slot < 0)\r
2441                                         Report.Error (String.Format ("Undeclared identifier '{0}'", (string) $2));\r
2442                                 codegen.CurrentMethodDef.AddInstr (new\r
2443                                         IntInstr ((IntOp) $1, slot, tokenizer.Location));\r
2444                           }\r
2445                         | INSTR_I8 int64\r
2446                           {\r
2447                                 if ($1 is MiscInstr) {\r
2448                                         switch ((MiscInstr) $1) {\r
2449                                         case MiscInstr.ldc_i8:\r
2450                                         codegen.CurrentMethodDef.AddInstr (new LdcInstr ((MiscInstr) $1,\r
2451                                                 (long) $2, tokenizer.Location));\r
2452                                         break;\r
2453                                         }\r
2454                                 }\r
2455                           }\r
2456                         | INSTR_R float64\r
2457                           {\r
2458                                 switch ((MiscInstr) $1) {\r
2459                                 case MiscInstr.ldc_r4:\r
2460                                 case MiscInstr.ldc_r8:\r
2461                                          codegen.CurrentMethodDef.AddInstr (new LdcInstr ((MiscInstr) $1, (double) $2, tokenizer.Location));\r
2462                                          break;\r
2463                                 }\r
2464                           }\r
2465                         | INSTR_R int64\r
2466                           {\r
2467                                 long l = (long) $2;\r
2468                                 \r
2469                                 switch ((MiscInstr) $1) {\r
2470                                         case MiscInstr.ldc_r4:\r
2471                                         case MiscInstr.ldc_r8:\r
2472                                         codegen.CurrentMethodDef.AddInstr (new LdcInstr ((MiscInstr) $1, (double) l, tokenizer.Location));\r
2473                                         break;\r
2474                                 }\r
2475                           }\r
2476                         | INSTR_R bytes_list\r
2477                           {\r
2478                                 byte[] fpdata;\r
2479                                 switch ((MiscInstr) $1) {\r
2480                                         case MiscInstr.ldc_r4:\r
2481                                                 fpdata = (byte []) $2;\r
2482                                                 if (!BitConverter.IsLittleEndian) {\r
2483                                                         System.Array.Reverse (fpdata, 0, 4);\r
2484                                                 }\r
2485                                                 float s = BitConverter.ToSingle (fpdata, 0);\r
2486                                                 codegen.CurrentMethodDef.AddInstr (new LdcInstr ((MiscInstr) $1, s, tokenizer.Location));\r
2487                                                 break;\r
2488                                         case MiscInstr.ldc_r8:\r
2489                                                 fpdata = (byte []) $2;\r
2490                                                 if (!BitConverter.IsLittleEndian) {\r
2491                                                         System.Array.Reverse (fpdata, 0, 8);\r
2492                                                 }\r
2493                                                 double d = BitConverter.ToDouble (fpdata, 0);\r
2494                                                 codegen.CurrentMethodDef.AddInstr (new LdcInstr ((MiscInstr) $1, d, tokenizer.Location));\r
2495                                                 break;\r
2496                                 }\r
2497                           }\r
2498                         | INSTR_BRTARGET int32\r
2499                           {\r
2500                                 LabelInfo target = codegen.CurrentMethodDef.AddLabel ((int) $2);\r
2501                                 codegen.CurrentMethodDef.AddInstr (new BranchInstr ((BranchOp) $1,\r
2502                                                                    target, tokenizer.Location));  \r
2503                           }\r
2504                         | INSTR_BRTARGET id\r
2505                           {\r
2506                                 LabelInfo target = codegen.CurrentMethodDef.AddLabelRef ((string) $2);\r
2507                                 codegen.CurrentMethodDef.AddInstr (new BranchInstr ((BranchOp) $1,\r
2508                                                                    target, tokenizer.Location));\r
2509                           }\r
2510                         | INSTR_METHOD method_ref\r
2511                           {\r
2512                                 codegen.CurrentMethodDef.AddInstr (new MethodInstr ((MethodOp) $1,\r
2513                                         (BaseMethodRef) $2, tokenizer.Location));\r
2514                           }\r
2515                         | INSTR_FIELD type type_spec DOUBLE_COLON id\r
2516                           {\r
2517                                 \r
2518                                 BaseTypeRef owner = (BaseTypeRef) $3;\r
2519                                 GenericParamRef gpr = $2 as GenericParamRef;\r
2520                                 if (gpr != null && codegen.CurrentMethodDef != null)\r
2521                                         codegen.CurrentMethodDef.ResolveGenParam ((PEAPI.GenParam) gpr.PeapiType);\r
2522                                 IFieldRef fieldref = owner.GetFieldRef (\r
2523                                         (BaseTypeRef) $2, (string) $5);\r
2524 \r
2525                                 codegen.CurrentMethodDef.AddInstr (new FieldInstr ((FieldOp) $1, fieldref, tokenizer.Location));\r
2526                           }\r
2527                         | INSTR_FIELD type id\r
2528                           {\r
2529                                 GlobalFieldRef fieldref = codegen.GetGlobalFieldRef ((BaseTypeRef) $2, (string) $3);\r
2530 \r
2531                                 codegen.CurrentMethodDef.AddInstr (new FieldInstr ((FieldOp) $1, fieldref, tokenizer.Location));\r
2532                           }\r
2533                         | INSTR_TYPE type_spec\r
2534                           {\r
2535                                 codegen.CurrentMethodDef.AddInstr (new TypeInstr ((TypeOp) $1,\r
2536                                         (BaseTypeRef) $2, tokenizer.Location));\r
2537                           }\r
2538                         | INSTR_STRING comp_qstring\r
2539                           {\r
2540                                 if ((MiscInstr) $1 == MiscInstr.ldstr)\r
2541                                         codegen.CurrentMethodDef.AddInstr (new LdstrInstr ((string) $2, tokenizer.Location));\r
2542                           }\r
2543                         | INSTR_STRING K_BYTEARRAY ASSIGN bytes_list\r
2544                           {\r
2545                                 byte[] bs = (byte[]) $4;\r
2546                                 if ((MiscInstr) $1 == MiscInstr.ldstr)\r
2547                                         codegen.CurrentMethodDef.AddInstr (new LdstrInstr (bs, tokenizer.Location));\r
2548                           }\r
2549                         | INSTR_STRING K_BYTEARRAY bytes_list\r
2550                           {\r
2551                                 byte[] bs = (byte[]) $3;\r
2552                                 if ((MiscInstr) $1 == MiscInstr.ldstr)\r
2553                                         codegen.CurrentMethodDef.AddInstr (new LdstrInstr (bs, tokenizer.Location));\r
2554                           }\r
2555                         | INSTR_SIG call_conv type OPEN_PARENS type_list CLOSE_PARENS\r
2556                           {\r
2557                                 ArrayList arg_list = (ArrayList) $5;\r
2558                                 BaseTypeRef[] arg_array = null;\r
2559 \r
2560                                 if (arg_list != null)\r
2561                                         arg_array = (BaseTypeRef[]) arg_list.ToArray (typeof (BaseTypeRef));\r
2562 \r
2563                                 codegen.CurrentMethodDef.AddInstr (new CalliInstr ((CallConv) $2,\r
2564                                         (BaseTypeRef) $3, arg_array, tokenizer.Location));\r
2565                           }     \r
2566                         | INSTR_TOK owner_type\r
2567                           {\r
2568                                 if ((MiscInstr) $1 == MiscInstr.ldtoken) {\r
2569                                         if ($2 is BaseMethodRef)\r
2570                                                 codegen.CurrentMethodDef.AddInstr (new LdtokenInstr ((BaseMethodRef) $2, tokenizer.Location));\r
2571                                         else if ($2 is IFieldRef)\r
2572                                                 codegen.CurrentMethodDef.AddInstr (new LdtokenInstr ((IFieldRef) $2, tokenizer.Location));\r
2573                                         else\r
2574                                                 codegen.CurrentMethodDef.AddInstr (new LdtokenInstr ((BaseTypeRef) $2, tokenizer.Location));\r
2575                                                 \r
2576                                 }\r
2577                           }\r
2578                         | INSTR_SWITCH OPEN_PARENS labels CLOSE_PARENS\r
2579                           {\r
2580                                 codegen.CurrentMethodDef.AddInstr (new SwitchInstr ((ArrayList) $3, tokenizer.Location));\r
2581                           }\r
2582                         ;\r
2583 \r
2584 method_ref              : call_conv type method_name typars_clause\r
2585                           OPEN_PARENS type_list CLOSE_PARENS\r
2586                           {\r
2587                                 ArrayList arg_list = (ArrayList) $6;\r
2588                                 GenericArguments ga = (GenericArguments) $4;\r
2589                                 BaseTypeRef[] param_list;\r
2590   \r
2591                                 if (arg_list != null)\r
2592                                         param_list = (BaseTypeRef[]) arg_list.ToArray (typeof (BaseTypeRef));\r
2593                                 else\r
2594                                         param_list = new BaseTypeRef[0];\r
2595 \r
2596                                 BaseMethodRef methref = codegen.GetGlobalMethodRef ((BaseTypeRef) $2, (CallConv) $1,\r
2597                                         (string) $3, param_list, (ga != null ? ga.Count : 0));\r
2598 \r
2599                                 if (ga != null)\r
2600                                         methref = methref.GetGenericMethodRef (ga);\r
2601 \r
2602                                 $$ = methref;\r
2603                           }\r
2604                         | call_conv type type_spec DOUBLE_COLON method_name\r
2605                           typars_clause OPEN_PARENS type_list CLOSE_PARENS \r
2606                           {\r
2607                                 BaseTypeRef owner = (BaseTypeRef) $3;\r
2608                                 ArrayList arg_list = (ArrayList) $8;\r
2609                                 GenericArguments ga = (GenericArguments) $6;\r
2610                                 BaseTypeRef[] param_list;\r
2611                                 BaseMethodRef methref;\r
2612 \r
2613                                 if (arg_list != null)\r
2614                                         param_list = (BaseTypeRef[]) arg_list.ToArray (typeof (BaseTypeRef));\r
2615                                 else\r
2616                                         param_list = new BaseTypeRef[0];\r
2617 \r
2618                                 if (codegen.IsThisAssembly ("mscorlib")) {\r
2619                                         PrimitiveTypeRef prim = owner as PrimitiveTypeRef;\r
2620                                         if (prim != null && prim.SigMod == "")\r
2621                                                 owner = codegen.GetTypeRef (prim.Name);\r
2622                                 }\r
2623 \r
2624                                 if (owner.UseTypeSpec) {\r
2625                                         methref = new TypeSpecMethodRef (owner, (CallConv) $1, (BaseTypeRef) $2,\r
2626                                                 (string) $5, param_list, (ga != null ? ga.Count : 0));\r
2627                                 } else {\r
2628                                         methref = owner.GetMethodRef ((BaseTypeRef) $2,\r
2629                                                 (CallConv) $1, (string) $5, param_list, (ga != null ? ga.Count : 0));\r
2630                                 }\r
2631 \r
2632                                 if (ga != null)\r
2633                                         methref = methref.GetGenericMethodRef (ga);\r
2634                                 \r
2635                                 $$ = methref;\r
2636                           }\r
2637                         ;\r
2638 \r
2639 labels                  : /* EMPTY */\r
2640                         | id\r
2641                           {\r
2642                                 ArrayList label_list = new ArrayList ();\r
2643                                 label_list.Add (codegen.CurrentMethodDef.AddLabelRef ((string) $1));\r
2644                                 $$ = label_list;\r
2645                           }\r
2646                         | int32\r
2647                           {\r
2648                                 ArrayList label_list = new ArrayList ();\r
2649                                 label_list.Add ($1);\r
2650                                 $$ = label_list;\r
2651                           }\r
2652                         | labels COMMA id\r
2653                           {\r
2654                                 ArrayList label_list = (ArrayList) $1;\r
2655                                 label_list.Add (codegen.CurrentMethodDef.AddLabelRef ((string) $3));\r
2656                           }\r
2657                         | labels COMMA int32\r
2658                           {\r
2659                                 ArrayList label_list = (ArrayList) $1;\r
2660                                 label_list.Add ($3);\r
2661                           }\r
2662                         ;\r
2663 \r
2664 owner_type              : type_spec\r
2665                         | member_ref\r
2666                         ;\r
2667 \r
2668 member_ref              : K_METHOD method_ref\r
2669                           {\r
2670                                 $$ = $2;\r
2671                           }\r
2672                         | K_FIELD type type_spec DOUBLE_COLON id\r
2673                           {\r
2674                                 BaseTypeRef owner = (BaseTypeRef) $3;\r
2675 \r
2676                                 $$ = owner.GetFieldRef (\r
2677                                         (BaseTypeRef) $2, (string) $5);\r
2678                           }\r
2679                         | K_FIELD type id\r
2680                           {\r
2681                                 $$ = codegen.GetGlobalFieldRef ((BaseTypeRef) $2, (string) $3);\r
2682                           }\r
2683                         ;\r
2684 \r
2685 event_all               : event_head OPEN_BRACE event_decls CLOSE_BRACE\r
2686                           {\r
2687                                 codegen.CurrentTypeDef.EndEventDef ();\r
2688                           }\r
2689                         ;\r
2690 \r
2691 event_head              : D_EVENT event_attr type_spec comp_name\r
2692                           {\r
2693                                 EventDef event_def = new EventDef ((FeatureAttr) $2,\r
2694                                         (BaseTypeRef) $3, (string) $4);\r
2695                                 codegen.CurrentTypeDef.BeginEventDef (event_def);\r
2696                                 codegen.CurrentCustomAttrTarget = event_def;\r
2697                           }\r
2698                         | D_EVENT event_attr id\r
2699                         ;\r
2700 \r
2701 event_attr              : /* EMPTY */\r
2702                           {\r
2703                                 $$ = new FeatureAttr ();\r
2704                           }\r
2705                         | event_attr K_RTSPECIALNAME\r
2706                           {\r
2707                                 $$ = (FeatureAttr) $1 & FeatureAttr.Rtspecialname;\r
2708                           }\r
2709                         | event_attr K_SPECIALNAME\r
2710                           {\r
2711                                 $$ = (FeatureAttr) $1 & FeatureAttr.Specialname;\r
2712                           }\r
2713                         ;\r
2714 \r
2715 event_decls             : /* EMPTY */\r
2716                         | event_decls event_decl\r
2717                         ;\r
2718 \r
2719 event_decl              : D_ADDON method_ref semicolon_opt\r
2720                           {\r
2721                                 codegen.CurrentTypeDef.CurrentEvent.AddAddon (\r
2722                                         (MethodRef) $2);                                \r
2723                           }\r
2724                         | D_REMOVEON method_ref semicolon_opt\r
2725                           {\r
2726                                 codegen.CurrentTypeDef.CurrentEvent.AddRemoveon (\r
2727                                         (MethodRef) $2);\r
2728                           }\r
2729                         | D_FIRE method_ref semicolon_opt\r
2730                           {\r
2731                                 codegen.CurrentTypeDef.CurrentEvent.AddFire (\r
2732                                         (MethodRef) $2);\r
2733                           }\r
2734                         | D_OTHER method_ref semicolon_opt\r
2735                           {\r
2736                                 codegen.CurrentTypeDef.CurrentEvent.AddOther (\r
2737                                         (MethodRef) $2);\r
2738                           }\r
2739                         | customattr_decl\r
2740                           {\r
2741                                 if (codegen.CurrentCustomAttrTarget != null)\r
2742                                         codegen.CurrentCustomAttrTarget.AddCustomAttribute ((CustomAttr) $1);\r
2743                           }\r
2744                         | extsource_spec\r
2745                         | language_decl\r
2746                         ;\r
2747 \r
2748 prop_all                : prop_head OPEN_BRACE prop_decls CLOSE_BRACE\r
2749                           {\r
2750                                 codegen.CurrentTypeDef.EndPropertyDef ();\r
2751                           }\r
2752                         ;\r
2753 \r
2754 prop_head               : D_PROPERTY prop_attr type comp_name OPEN_PARENS type_list CLOSE_PARENS init_opt\r
2755                           {\r
2756                                 PropertyDef prop_def = new PropertyDef ((FeatureAttr) $2, (BaseTypeRef) $3,\r
2757                                         (string) $4, (ArrayList) $6);\r
2758                                 codegen.CurrentTypeDef.BeginPropertyDef (prop_def);\r
2759                                 codegen.CurrentCustomAttrTarget = prop_def;\r
2760 \r
2761                                 if ($8 != null) {\r
2762                                         prop_def.AddInitValue ((Constant) $8);\r
2763                                 }\r
2764                           }\r
2765                         ;\r
2766 \r
2767 prop_attr               : /* EMPTY */\r
2768                           {\r
2769                                 $$ = new FeatureAttr ();\r
2770                           }\r
2771                         | prop_attr K_RTSPECIALNAME\r
2772                           {\r
2773                                 $$ = (FeatureAttr) $1 | FeatureAttr.Rtspecialname;\r
2774                           }\r
2775                         | prop_attr K_SPECIALNAME\r
2776                           {\r
2777                                 $$ = (FeatureAttr) $1 | FeatureAttr.Specialname;\r
2778                           }\r
2779                         | prop_attr K_INSTANCE\r
2780                           {\r
2781                                 $$ = (FeatureAttr) $1 | FeatureAttr.Instance;\r
2782                           }\r
2783                         ;\r
2784 \r
2785 prop_decls              : /* EMPTY */\r
2786                         | prop_decls prop_decl\r
2787                         ;\r
2788 \r
2789 prop_decl               : D_SET method_ref\r
2790                           {\r
2791                                 codegen.CurrentTypeDef.CurrentProperty.AddSet ((MethodRef) $2);\r
2792                           }\r
2793                         | D_GET method_ref\r
2794                           {\r
2795                                 codegen.CurrentTypeDef.CurrentProperty.AddGet ((MethodRef) $2);\r
2796                           }\r
2797                         | D_OTHER method_ref\r
2798                           {\r
2799                                 codegen.CurrentTypeDef.CurrentProperty.AddOther ((MethodRef) $2);\r
2800                           }\r
2801                         | customattr_decl\r
2802                          {\r
2803                                 if (codegen.CurrentCustomAttrTarget != null)\r
2804                                         codegen.CurrentCustomAttrTarget.AddCustomAttribute ((CustomAttr) $1);\r
2805                          }\r
2806                         | extsource_spec\r
2807                         | language_decl\r
2808                         ;\r
2809 \r
2810 customattr_decl\r
2811                         : D_CUSTOM customattr_owner_type_opt custom_type\r
2812                           {\r
2813                                 $$ = new CustomAttr ((BaseMethodRef) $3, null);\r
2814                           }\r
2815                         | D_CUSTOM customattr_owner_type_opt custom_type ASSIGN comp_qstring\r
2816                         | D_CUSTOM customattr_owner_type_opt custom_type ASSIGN bytes_list\r
2817                           {\r
2818                                 $$ = new CustomAttr ((BaseMethodRef) $3, new ByteArrConst ((byte[]) $5));\r
2819                           }\r
2820             | D_CUSTOM customattr_owner_type_opt custom_type ASSIGN OPEN_BRACE customattr_values CLOSE_BRACE\r
2821               {\r
2822                 $$ = new CustomAttr ((BaseMethodRef) $3, (PEAPI.Constant) $6);\r
2823               }\r
2824                         ;\r
2825 \r
2826 // TODO: unused for now\r
2827 customattr_owner_type_opt\r
2828                         : /* empty */\r
2829                         | OPEN_PARENS type CLOSE_PARENS\r
2830                         ;\r
2831 \r
2832 customattr_values\r
2833                                 : /* empty */\r
2834                                 | K_BOOL OPEN_BRACKET int32 CLOSE_BRACKET OPEN_PARENS opt_truefalse_list CLOSE_PARENS\r
2835                                   {\r
2836                                         var l = (List<BoolConst>) $6;\r
2837                                         $$ = new ArrayConstant (l?.ToArray ()) {\r
2838                                                 ExplicitSize = (int) $3\r
2839                                         };\r
2840                                   }\r
2841                                 | K_BYTEARRAY bytes_list\r
2842                  {\r
2843                                 $$ = new ByteArrConst ((byte[]) $2);\r
2844                  }\r
2845                                 | K_STRING OPEN_PARENS SQSTRING CLOSE_PARENS\r
2846                                   {\r
2847                                         $$ = new StringConst ((string) $3);\r
2848                                   }\r
2849                                 | customattr_ctor_args\r
2850                                   {\r
2851                                         var c = $1 as Constant;\r
2852                                         $$ = c ?? new ArrayConstant (((List<DataConstant>) $1).ToArray ());\r
2853                                   }\r
2854                                 ;\r
2855 \r
2856 customattr_ctor_args\r
2857                                 : customattr_ctor_arg\r
2858                                 | customattr_ctor_args customattr_ctor_arg\r
2859                                   {\r
2860                                         var l = $1 as List<DataConstant>;\r
2861                                         if (l == null) {\r
2862                                                 l = new List<DataConstant> () {\r
2863                                                         (DataConstant) $1\r
2864                                                 };\r
2865                                         }\r
2866 \r
2867                                         l.Add ((DataConstant) $2);\r
2868                                         $$ = l;\r
2869                                   }\r
2870                                 ;\r
2871 \r
2872 customattr_ctor_arg\r
2873                                 : field_init_primitive\r
2874                                 | K_TYPE OPEN_PARENS type CLOSE_PARENS\r
2875                                   {\r
2876                                         $$ = new StringConst (((TypeRef) $3).FullName);\r
2877                                   }\r
2878                                 ;\r
2879 \r
2880                         \r
2881 custom_type             : call_conv type type_spec DOUBLE_COLON method_name OPEN_PARENS type_list CLOSE_PARENS\r
2882                           {\r
2883                                 BaseTypeRef owner = (BaseTypeRef) $3;\r
2884                                 ArrayList arg_list = (ArrayList) $7;\r
2885                                 BaseTypeRef[] param_list;\r
2886   \r
2887                                 if (arg_list != null)\r
2888                                         param_list = (BaseTypeRef[]) arg_list.ToArray (typeof (BaseTypeRef));\r
2889                                 else\r
2890                                         param_list = new BaseTypeRef[0];\r
2891 \r
2892                                 $$ = owner.GetMethodRef ((BaseTypeRef) $2,\r
2893                                         (CallConv) $1, (string) $5, param_list, 0);\r
2894                           }\r
2895                         | call_conv type method_name OPEN_PARENS type_list CLOSE_PARENS\r
2896                           {\r
2897                                 ArrayList arg_list = (ArrayList) $5;\r
2898                                 BaseTypeRef[] param_list;\r
2899   \r
2900                                 if (arg_list != null)\r
2901                                         param_list = (BaseTypeRef[]) arg_list.ToArray (typeof (BaseTypeRef));\r
2902                                 else\r
2903                                         param_list = new BaseTypeRef[0];\r
2904 \r
2905                                 $$ = codegen.GetGlobalMethodRef ((BaseTypeRef) $2, (CallConv) $1,\r
2906                                         (string) $3, param_list, 0);\r
2907                           }\r
2908                         ;\r
2909 \r
2910 sec_decl                : D_PERMISSION sec_action type_spec OPEN_PARENS nameval_pairs CLOSE_PARENS\r
2911                           {\r
2912                                 $$ = TypeSpecToPermPair ($2, $3, (ArrayList) $5);\r
2913                           }\r
2914                         | D_PERMISSION sec_action type_spec\r
2915                           {\r
2916                                 $$ = TypeSpecToPermPair ($2, $3, null);\r
2917                           }\r
2918                         | D_PERMISSIONSET sec_action ASSIGN bytes_list\r
2919                           {\r
2920                                 System.Text.UnicodeEncoding ue = new System.Text.UnicodeEncoding ();\r
2921                                 PermissionSetAttribute psa = new PermissionSetAttribute ((System.Security.Permissions.SecurityAction) (short) $2);\r
2922                                 psa.XML = ue.GetString ((byte []) $4);\r
2923                                 $$ = new PermPair ((PEAPI.SecurityAction) $2, psa.CreatePermissionSet ());\r
2924                           }\r
2925                         | D_PERMISSIONSET sec_action comp_qstring\r
2926                           {\r
2927                                 PermissionSetAttribute psa = new PermissionSetAttribute ((System.Security.Permissions.SecurityAction) (short) $2);\r
2928                                 psa.XML = (string) $3;\r
2929                                 $$ = new PermPair ((PEAPI.SecurityAction) $2, psa.CreatePermissionSet ());\r
2930                           }\r
2931                         | D_PERMISSIONSET sec_action ASSIGN OPEN_BRACE permissions CLOSE_BRACE\r
2932                           {\r
2933                                 $$ = new MIPermissionSet ((PEAPI.SecurityAction) $2, (ArrayList) $5);\r
2934                           }\r
2935                         ;\r
2936 \r
2937 permissions             : permission\r
2938                           {\r
2939                                 ArrayList list = new ArrayList ();\r
2940                                 list.Add ($1);\r
2941                                 $$ = list;\r
2942                           }\r
2943                         | permissions COMMA permission\r
2944                           {\r
2945                                 ArrayList list = (ArrayList) $1;\r
2946                                 list.Add ($3);\r
2947                                 $$ = list;\r
2948                           }\r
2949                         ;\r
2950                         \r
2951 permission              : class_ref ASSIGN OPEN_BRACE permission_members CLOSE_BRACE\r
2952                           {\r
2953                                 $$ = new MIPermission ((BaseTypeRef) $1, (ArrayList) $4);\r
2954                           }\r
2955                         ;\r
2956 \r
2957 permission_members      : permission_member\r
2958                           {\r
2959                                   ArrayList list = new ArrayList ();\r
2960                                   list.Add ($1);\r
2961                                   $$ = list;\r
2962                           }\r
2963                         | permission_members permission_member\r
2964                           {\r
2965                                   ArrayList list = (ArrayList) $1;\r
2966                                   list.Add ($2);\r
2967                                   $$ = list;\r
2968                           }\r
2969                         ;\r
2970 \r
2971 permission_member       : prop_or_field primitive_type perm_mbr_nameval_pair\r
2972                           {\r
2973                                 NameValuePair pair = (NameValuePair) $3;\r
2974                                 $$ = new PermissionMember ((MemberTypes) $1, (BaseTypeRef) $2, pair.Name, pair.Value);\r
2975                           }\r
2976                         | prop_or_field K_ENUM class_ref perm_mbr_nameval_pair\r
2977                           {\r
2978                                 NameValuePair pair = (NameValuePair) $4;\r
2979                                 $$ = new PermissionMember ((MemberTypes) $1, (BaseTypeRef) $3, pair.Name, pair.Value);\r
2980                           }\r
2981                         ;\r
2982 \r
2983 perm_mbr_nameval_pair   : SQSTRING ASSIGN member_init\r
2984                           {\r
2985                                 $$ = new NameValuePair ((string) $1, (PEAPI.Constant) $3);\r
2986                           }\r
2987                         ;\r
2988 \r
2989 prop_or_field           : K_PROPERTY\r
2990                           {\r
2991                                 $$ = MemberTypes.Property;\r
2992                           }\r
2993                         | K_FIELD\r
2994                           {\r
2995                                 $$ = MemberTypes.Field;\r
2996                           }\r
2997                         ;\r
2998 \r
2999 nameval_pairs           : nameval_pair \r
3000                           {\r
3001                                 ArrayList pairs = new ArrayList ();\r
3002                                 pairs.Add ($1);\r
3003                                 $$ = pairs;\r
3004                           }\r
3005                         | nameval_pairs COMMA nameval_pair\r
3006                           {\r
3007                                 ArrayList pairs = (ArrayList) $1;\r
3008                                 pairs.Add ($3);\r
3009                                 $$ = pairs;\r
3010                           }\r
3011                         ;\r
3012 \r
3013 nameval_pair            : comp_qstring ASSIGN cavalue\r
3014                           {\r
3015                                 $$ = new NameValuePair ((string) $1, $3);\r
3016                           }\r
3017                         ;\r
3018 \r
3019 cavalue                 : truefalse\r
3020                         | int32\r
3021                         | int32 OPEN_PARENS int32 CLOSE_PARENS\r
3022                           {\r
3023                                 $$ = $3;\r
3024                           }\r
3025                         | comp_qstring \r
3026                         | class_ref OPEN_PARENS K_INT8 COLON int32 CLOSE_PARENS\r
3027                           {\r
3028                                 $$ = ClassRefToObject ($1, (byte) (int) $5);\r
3029                           }\r
3030                         | class_ref OPEN_PARENS K_INT16 COLON int32 CLOSE_PARENS\r
3031                           {\r
3032                                 $$ = ClassRefToObject ($1, (short) (int) $5);\r
3033                           }\r
3034                         | class_ref OPEN_PARENS K_INT32 COLON int32 CLOSE_PARENS\r
3035                           {\r
3036                                 $$ = ClassRefToObject ($1, (int) $5);\r
3037                           }\r
3038                         | class_ref OPEN_PARENS int32 CLOSE_PARENS\r
3039                           {\r
3040                                 $$ = ClassRefToObject ($1, (int) $3);\r
3041                           }\r
3042                         ;\r
3043 \r
3044 sec_action              : K_REQUEST\r
3045                           {\r
3046                                 $$ = PEAPI.SecurityAction.Request;\r
3047                           }\r
3048                         | K_DEMAND\r
3049                           {\r
3050                                 $$ = PEAPI.SecurityAction.Demand;\r
3051                           }\r
3052                         | K_ASSERT\r
3053                           {\r
3054                                 $$ = PEAPI.SecurityAction.Assert;\r
3055                           }\r
3056                         | K_DENY\r
3057                           {\r
3058                                 $$ = PEAPI.SecurityAction.Deny;\r
3059                           }\r
3060                         | K_PERMITONLY\r
3061                           {\r
3062                                 $$ = PEAPI.SecurityAction.PermitOnly;\r
3063                           }\r
3064                         | K_LINKCHECK\r
3065                           {\r
3066                                 $$ = PEAPI.SecurityAction.LinkDemand;\r
3067                           }\r
3068                         | K_INHERITCHECK\r
3069                           {\r
3070                                 $$ = PEAPI.SecurityAction.InheritDemand;\r
3071                           }\r
3072                         | K_REQMIN\r
3073                           {\r
3074                                 $$ = PEAPI.SecurityAction.RequestMinimum;\r
3075                           }\r
3076                         | K_REQOPT\r
3077                           {\r
3078                                 $$ = PEAPI.SecurityAction.RequestOptional;\r
3079                           }\r
3080                         | K_REQREFUSE\r
3081                           {\r
3082                                 $$ = PEAPI.SecurityAction.RequestRefuse;\r
3083                           }\r
3084                         | K_PREJITGRANT\r
3085                           {\r
3086                                 $$ = PEAPI.SecurityAction.PreJitGrant;\r
3087                           }\r
3088                         | K_PREJITDENY\r
3089                           {\r
3090                                 $$ = PEAPI.SecurityAction.PreJitDeny;\r
3091                           }\r
3092                         | K_NONCASDEMAND\r
3093                           {\r
3094                                 $$ = PEAPI.SecurityAction.NonCasDemand;\r
3095                           }\r
3096                         | K_NONCASLINKDEMAND\r
3097                           {\r
3098                                 $$ = PEAPI.SecurityAction.NonCasLinkDemand;\r
3099                           }\r
3100                         | K_NONCASINHERITANCE\r
3101                           {\r
3102                                 $$ = PEAPI.SecurityAction.NonCasInheritance;\r
3103                           }\r
3104                         /* FIXME: Should we have LinkDemandChoice, InheritDemandChoice and DemandChoice ? */  \r
3105                         ;\r
3106 \r
3107 module_head             : D_MODULE\r
3108                           {\r
3109                           }\r
3110                         | D_MODULE comp_name\r
3111                           {\r
3112                                 codegen.SetModuleName ((string) $2);\r
3113                           }\r
3114                         | D_MODULE K_EXTERN comp_name\r
3115                           {\r
3116                                 codegen.ExternTable.AddModule ((string) $3);                         \r
3117                           }\r
3118                         ;\r
3119 \r
3120 file_decl               : D_FILE file_attr comp_name file_entry D_HASH ASSIGN\r
3121                           bytes_list file_entry\r
3122                           {\r
3123                                 codegen.SetFileRef (new FileRef ((string) $3, (byte []) $7, (bool) $2, (bool) $8)); \r
3124                           }\r
3125                         | D_FILE file_attr comp_name file_entry\r
3126                           {\r
3127                                 // We need to compute the hash ourselves. :-(\r
3128                                 // AssemblyName an = AssemblyName.GetName ((string) $3);\r
3129                           }\r
3130                         ;\r
3131 \r
3132 file_attr               : /* EMPTY */\r
3133                           {\r
3134                                 $$ = true;\r
3135                           }\r
3136                         | file_attr K_NOMETADATA\r
3137                           {\r
3138                                 $$ = false;\r
3139                           }\r
3140                         ;\r
3141 \r
3142 file_entry              : /* EMPTY */\r
3143                           {\r
3144                                 $$ = false;\r
3145                           }\r
3146                         | D_ENTRYPOINT\r
3147                           {\r
3148                                 $$ = true;\r
3149                           }\r
3150                         ;\r
3151 \r
3152 assembly_all            : assembly_head OPEN_BRACE assembly_decls CLOSE_BRACE\r
3153                           {\r
3154                                 codegen.CurrentCustomAttrTarget = null;\r
3155                                 codegen.CurrentDeclSecurityTarget = null;\r
3156                           }\r
3157                         ;\r
3158 \r
3159 assembly_head           : D_ASSEMBLY legacylibrary_opt asm_attr slashed_name\r
3160                           {\r
3161                                 codegen.SetThisAssembly ((string) $4, (PEAPI.AssemAttr) $3);\r
3162                                 codegen.CurrentCustomAttrTarget = codegen.ThisAssembly;\r
3163                                 codegen.CurrentDeclSecurityTarget = codegen.ThisAssembly;\r
3164                           }\r
3165                         ;\r
3166 \r
3167 asm_attr                : /* EMPTY */\r
3168                           {\r
3169                                   $$ = new PEAPI.AssemAttr ();\r
3170                           }\r
3171                         /*| asm_attr K_NOAPPDOMAIN\r
3172                         | asm_attr K_NOPROCESS\r
3173                         | asm_attr K_NOMACHINE*/\r
3174                         | asm_attr K_RETARGETABLE\r
3175                           {\r
3176                                   $$ = ((PEAPI.AssemAttr) $1) | PEAPI.AssemAttr.Retargetable;\r
3177                           }\r
3178                         ;\r
3179 \r
3180 assembly_decls          : /* EMPTY */\r
3181                         | assembly_decls assembly_decl\r
3182                         ;\r
3183 \r
3184 assembly_decl           : D_PUBLICKEY ASSIGN bytes_list\r
3185                           {\r
3186                                 codegen.ThisAssembly.SetPublicKey ((byte []) $3);\r
3187                           }\r
3188                         | D_VER int32 COLON int32 COLON int32 COLON int32\r
3189                           {\r
3190                                 codegen.ThisAssembly.SetVersion ((int) $2, (int) $4, (int) $6, (int) $8);\r
3191                           }\r
3192                         | D_LOCALE comp_qstring\r
3193                           {\r
3194                                 codegen.ThisAssembly.SetLocale ((string) $2);\r
3195                           }\r
3196                         | D_LOCALE ASSIGN bytes_list\r
3197                         | D_HASH K_ALGORITHM int32\r
3198                           {\r
3199                                 codegen.ThisAssembly.SetHashAlgorithm ((int) $3);\r
3200                           }\r
3201                         | customattr_decl\r
3202                           {\r
3203                                 codegen.ThisAssembly.AddCustomAttribute ((CustomAttr) $1);\r
3204                           }\r
3205                         | sec_decl\r
3206                           {\r
3207                                 AddSecDecl ($1, true);\r
3208                           }\r
3209                         ;\r
3210 \r
3211 asm_or_ref_decl         : D_PUBLICKEY ASSIGN bytes_list\r
3212                         | D_VER int32 COLON int32 COLON int32 COLON int32 \r
3213                         | D_LOCALE comp_qstring\r
3214                         | D_LOCALE ASSIGN bytes_list\r
3215                         | customattr_decl\r
3216                         ;\r
3217 \r
3218 assemblyref_all         : assemblyref_head OPEN_BRACE assemblyref_decls CLOSE_BRACE\r
3219                         ;\r
3220 \r
3221 assemblyref_head        : D_ASSEMBLY K_EXTERN legacylibrary_opt asm_attr slashed_name\r
3222                           {\r
3223                                 System.Reflection.AssemblyName asmb_name = \r
3224                                         new System.Reflection.AssemblyName ();\r
3225                                 asmb_name.Name = (string) $5;\r
3226                                 codegen.BeginAssemblyRef ((string) $5, asmb_name, (PEAPI.AssemAttr) $4);\r
3227                           }\r
3228                         | D_ASSEMBLY K_EXTERN legacylibrary_opt asm_attr slashed_name K_AS slashed_name\r
3229                           {\r
3230                                 System.Reflection.AssemblyName asmb_name = \r
3231                                         new System.Reflection.AssemblyName ();\r
3232                                 asmb_name.Name = (string) $5;\r
3233                                 codegen.BeginAssemblyRef ((string) $7, asmb_name, (PEAPI.AssemAttr) $4);\r
3234                           }\r
3235                         ;\r
3236 \r
3237 assemblyref_decls       : /* EMPTY */\r
3238                         | assemblyref_decls assemblyref_decl\r
3239                         ;\r
3240 \r
3241 assemblyref_decl        : D_VER int32 COLON int32 COLON int32 COLON int32\r
3242                           {\r
3243                                 codegen.CurrentAssemblyRef.SetVersion ((int) $2, (int) $4, (int) $6, (int) $8);\r
3244                           }\r
3245                         | D_PUBLICKEY ASSIGN bytes_list\r
3246                           {\r
3247                                 codegen.CurrentAssemblyRef.SetPublicKey ((byte []) $3);\r
3248                           }\r
3249                         | D_PUBLICKEYTOKEN ASSIGN bytes_list\r
3250                           {\r
3251                                 codegen.CurrentAssemblyRef.SetPublicKeyToken ((byte []) $3);\r
3252                           }\r
3253                         | D_LOCALE comp_qstring\r
3254                           {\r
3255                                 codegen.CurrentAssemblyRef.SetLocale ((string) $2);\r
3256                           }\r
3257                         | D_LOCALE ASSIGN bytes_list\r
3258                         \r
3259                         | D_HASH ASSIGN bytes_list\r
3260                           {\r
3261                                 codegen.CurrentAssemblyRef.SetHash ((byte []) $3);\r
3262                           }\r
3263                         | customattr_decl\r
3264                           {\r
3265                                 if (codegen.CurrentCustomAttrTarget != null)\r
3266                                         codegen.CurrentCustomAttrTarget.AddCustomAttribute ((CustomAttr) $1);\r
3267                           }\r
3268             | K_AUTO  /* MS ilasm uses this keyword to lookup the specified assembly in the GAC and embeds its attributes, we just ignore it */\r
3269                         ;\r
3270 \r
3271 exptype_all             : exptype_head OPEN_BRACE exptype_decls CLOSE_BRACE\r
3272                         ;\r
3273 \r
3274 exptype_head            : D_CLASS K_EXTERN expt_attr comp_name\r
3275                                         {\r
3276                                                 current_extern = new KeyValuePair<string, TypeAttr> ((string) $4, (TypeAttr) $3);\r
3277                                         }\r
3278                         ;\r
3279 \r
3280 expt_attr               : { $$ = 0; } /* EMPTY */\r
3281                         | expt_attr K_PRIVATE                   { $$ = (TypeAttr)$1 | TypeAttr.Private; }\r
3282                         | expt_attr K_PUBLIC                    { $$ = (TypeAttr)$1 | TypeAttr.Public; }\r
3283                         | expt_attr K_FORWARDER                 { $$ = (TypeAttr)$1 | TypeAttr.Forwarder; }\r
3284                         | expt_attr K_NESTED K_PUBLIC           { $$ = (TypeAttr)$1 | TypeAttr.NestedPublic; }\r
3285                         | expt_attr K_NESTED K_PRIVATE          { $$ = (TypeAttr)$1 | TypeAttr.NestedPrivate; }\r
3286                         | expt_attr K_NESTED K_FAMILY           { $$ = (TypeAttr)$1 | TypeAttr.NestedFamily; }\r
3287                         | expt_attr K_NESTED K_ASSEMBLY         { $$ = (TypeAttr)$1 | TypeAttr.NestedAssembly;}\r
3288                         | expt_attr K_NESTED K_FAMANDASSEM      { $$ = (TypeAttr)$1 | TypeAttr.NestedFamAndAssem; }\r
3289                         | expt_attr K_NESTED K_FAMORASSEM       { $$ = (TypeAttr)$1 | TypeAttr.NestedFamOrAssem; }\r
3290                         ;\r
3291 \r
3292 exptype_decls           : /* EMPTY */\r
3293                         | exptype_decls exptype_decl\r
3294                         ;\r
3295 \r
3296 exptype_decl            : D_FILE comp_name\r
3297                         | D_CLASS K_EXTERN comp_name\r
3298                         | customattr_decl\r
3299                         | D_ASSEMBLY K_EXTERN comp_name\r
3300                           {\r
3301                                 codegen.ExternTable.AddClass (current_extern.Key, current_extern.Value, (string) $3);\r
3302                           }\r
3303                         ;\r
3304 \r
3305 manifestres_all         : manifestres_head OPEN_BRACE manifestres_decls CLOSE_BRACE\r
3306                         ;\r
3307 \r
3308 manifestres_head        : D_MRESOURCE manres_attr comp_name\r
3309                           {\r
3310                                 FileStream s = new FileStream ((string) $3, FileMode.Open, FileAccess.Read);\r
3311                                 byte [] buff = new byte [s.Length];\r
3312                                 s.Read (buff, 0, (int) s.Length);\r
3313                                 s.Close ();\r
3314 \r
3315                                 codegen.AddManifestResource (new ManifestResource ((string) $3, buff, ($2 == null) ? 0 : (uint) $2));\r
3316                           }\r
3317                         ;\r
3318 \r
3319 manres_attr             : /* EMPTY */\r
3320                         | manres_attr K_PUBLIC { $$ = ManifestResource.PublicResource; }\r
3321                         | manres_attr K_PRIVATE { $$ = ManifestResource.PrivateResource; } \r
3322                         ;\r
3323 \r
3324 manifestres_decls       : /* EMPTY */\r
3325                         | manifestres_decls manifestres_decl\r
3326                         ;\r
3327 \r
3328 manifestres_decl        : D_FILE comp_name K_AT int32\r
3329                         | D_ASSEMBLY K_EXTERN slashed_name\r
3330                         | customattr_decl\r
3331                         ;\r
3332 \r
3333 comp_qstring            : QSTRING\r
3334                         | comp_qstring PLUS QSTRING     { $$ = String.Format ("{0}{1}", $1, $3); }\r
3335                         ;\r
3336 \r
3337 int32                   : INT64\r
3338                           {\r
3339                                 long l = (long) $1;\r
3340                                 byte[] intb = BitConverter.GetBytes (l);\r
3341                                 $$ = BitConverter.ToInt32 (intb, BitConverter.IsLittleEndian ? 0 : 4);\r
3342                           }\r
3343                         ;\r
3344 \r
3345 int64                   : INT64\r
3346                         ;\r
3347 \r
3348 float64                 : FLOAT64\r
3349                         | K_FLOAT32 OPEN_PARENS INT32 CLOSE_PARENS\r
3350                           {\r
3351                                 int i = (int) $3;\r
3352                                 byte[] intb = BitConverter.GetBytes (i);\r
3353                                 $$ = (double) BitConverter.ToSingle (intb, 0);\r
3354                           }\r
3355                         | K_FLOAT32 OPEN_PARENS INT64 CLOSE_PARENS\r
3356                           {\r
3357                                 long l = (long) $3;\r
3358                                 byte[] intb = BitConverter.GetBytes (l);\r
3359                                 $$ = (double) BitConverter.ToSingle (intb, BitConverter.IsLittleEndian ? 0 : 4);\r
3360                           }\r
3361                         | K_FLOAT64 OPEN_PARENS INT64 CLOSE_PARENS\r
3362                           {\r
3363                                 byte[] intb = BitConverter.GetBytes ((long) $3);\r
3364                                 $$ = BitConverter.ToDouble (intb, 0);\r
3365                           }\r
3366                         | K_FLOAT64 OPEN_PARENS INT32 CLOSE_PARENS\r
3367                           {\r
3368                                 byte[] intb = BitConverter.GetBytes ((int) $3);\r
3369                                 $$ = (double) BitConverter.ToSingle (intb, 0);\r
3370                           }\r
3371                         ;\r
3372 \r
3373 hexbyte                 : HEXBYTE       { }\r
3374                         ;\r
3375 \r
3376 bytes_list              : OPEN_PARENS\r
3377                           {\r
3378                                 tokenizer.InByteArray = true;\r
3379                           }\r
3380                           bytes CLOSE_PARENS\r
3381                           {\r
3382                                 $$ = $3;\r
3383                                 tokenizer.InByteArray = false;\r
3384                           }\r
3385                         ;\r
3386 \r
3387 bytes                   : /* EMPTY */   { $$ = new byte[0]; }\r
3388                         | hexbytes\r
3389                           {\r
3390                                 ArrayList byte_list = (ArrayList) $1;\r
3391                                 $$ = byte_list.ToArray (typeof (byte));\r
3392                           }\r
3393                         ;\r
3394 \r
3395 hexbytes                : hexbyte\r
3396                           {\r
3397                                 ArrayList byte_list = new ArrayList ();\r
3398                                 byte_list.Add (Convert.ToByte ($1));\r
3399                                 $$ = byte_list;\r
3400                           }\r
3401                         | hexbytes hexbyte\r
3402                           {\r
3403                                 ArrayList byte_list = (ArrayList) $1;\r
3404                                 byte_list.Add (Convert.ToByte ($2));\r
3405                           }\r
3406                         ;\r
3407 \r
3408 truefalse               : K_TRUE\r
3409                           {\r
3410                                 $$ = true;\r
3411                           }\r
3412                         | K_FALSE\r
3413                           {\r
3414                                 $$ = false;\r
3415                           }\r
3416                         ;\r
3417 \r
3418 id                      : ID\r
3419                         | SQSTRING\r
3420                         ;\r
3421 \r
3422 comp_name               : id\r
3423                         | comp_name DOT comp_name\r
3424                           {\r
3425                                 $$ = (string) $1 + '.' + (string) $3;\r
3426                           }\r
3427                         | COMP_NAME\r
3428                         ;\r
3429 \r
3430 semicolon_opt\r
3431                         : /* empty */\r
3432                         | SEMICOLON\r
3433                         ;\r
3434 \r
3435 legacylibrary_opt       : /* empty */\r
3436                                         | K_LEGACY K_LIBRARY  /* MS ilasm has these keywords for backwards compatibility, we just ignore them */\r
3437                                         ;\r
3438 \r
3439 %%\r
3440 \r
3441 }\r
3442 \r