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