X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Filasm%2Fparser%2FILParser.jay;h=1c4c9c40deca3fc71985ef52110d8cdcd1a4bd1b;hb=ba2604940e0dcfe116c44eea72932326aabaa8ff;hp=b0ac8dab7ddb6c51b773a12612b6f832e9f2ff73;hpb=01a00d3020acef8b08cbb21088b6921f0e47ff86;p=mono.git

diff --git a/mcs/ilasm/parser/ILParser.jay b/mcs/ilasm/parser/ILParser.jay
index b0ac8dab7dd..1c4c9c40dec 100644
--- a/mcs/ilasm/parser/ILParser.jay
+++ b/mcs/ilasm/parser/ILParser.jay
@@ -6,6 +6,7 @@
 using PEAPI;
 using System;
 using System.Collections;
+using System.Globalization;
 
 namespace Mono.ILASM {
 
@@ -67,7 +68,8 @@ namespace Mono.ILASM {
 %token BANG          "!"
 %token ELLIPSIS      "..."
 %token DASH          "-"
-
+%token OPEN_ANGLE_BRACKET   "<"
+%token CLOSE_ANGLE_BRACKET  ">"
 
 
 
@@ -97,7 +99,6 @@ namespace Mono.ILASM {
 
 
 
-
 /* Mechanically generated  - DO NOT EDIT! */
 
 
@@ -401,7 +402,6 @@ vtfixup_decl		: D_VTFIXUP OPEN_BRACKET int32 CLOSE_BRACKET
 			;
 
 vtfixup_attr		: /* EMPTY */
-			| vtfixup_attr int32
 			| vtfixup_attr int64
 			| vtfixup_attr K_FROMUNMANAGED
 			| vtfixup_attr K_CALLMOSTDERIVED
@@ -419,29 +419,30 @@ namespace_head		: D_NAMESPACE comp_name
                           }
 			;
 
-class_all		: class_head OPEN_BRACE class_decls
-                          CLOSE_BRACE
+class_all		: class_head OPEN_BRACE class_decls CLOSE_BRACE
                           {
-                                codegen.CompleteClass ();
+                                codegen.EndTypeDef ();
                           }
-                        
 			;
 
-class_head 		: D_CLASS class_attr id extends_clause
+class_head 		: D_CLASS class_attr id typars_clause extends_clause
                           impl_clause
                           {
+                                codegen.BeginTypeDef ((TypeAttr) $2, (string) $3, 
+						$5 as IClassRef, $6 as ArrayList, null);
+
+                                /*
+                                // Lets not worry about generics for now :p
                                 if ($4 != null) {
-					codegen.AddClass ((TypeAttr) $2, (string) $3, 
-						((TypeRef)$4).Type as Class, null);
-				} else {
-					codegen.AddClass ((TypeAttr)$2, (string) $3, null);
-				}
-                                
-				ArrayList impl_list = (ArrayList) $5;
-				if (impl_list != null) {
-					foreach (TypeRef type_ref in impl_list)
-						codegen.CurrentClass.AddImplementedInterface (type_ref.Type as Class);
-				}
+                                        ArrayList typars_list = (ArrayList) $4;
+                                        int index = 0;
+                                        foreach (DictionaryEntry entry in typars_list) {
+                                                TypeRef type = (TypeRef) entry.Key;
+                                                string name = (string) entry.Value;
+                                                codegen.CurrentClass.AddGenericParameter ((short) index++, type.Type, name);
+                                        }
+                                }
+                                */
                           }
 			;
 
@@ -489,6 +490,46 @@ impl_clause		: /* EMPTY */
                           }
 			;
 
+typars_clause           : /* EMPTY */
+                        | OPEN_ANGLE_BRACKET formal_typars CLOSE_ANGLE_BRACKET
+                          {
+                                $$ = $2;
+                          }
+                        ;
+
+typars                  : type
+                          {
+                                ArrayList typars_list = new ArrayList ();
+                                typars_list.Add ($1);
+                                $$ = typars_list;
+                          }
+                        | typars COMMA type
+                          {
+                                ArrayList typars_list = (ArrayList) $1;
+                                typars_list.Add ($3);
+                                $$ = typars_list;
+                          }
+                        ;
+
+formal_typars           : formal_typar
+                          {
+                                ArrayList formal_list = new ArrayList ();
+                                formal_list.Add ($1);
+                                $$ = formal_list;
+                          }
+                        | formal_typars COMMA formal_typar
+                          {
+                                ArrayList formal_list = (ArrayList) $1;
+                                formal_list.Add ($3);
+                                $$ = formal_list;
+                          }
+                        ;
+
+
+formal_typar            : type          { $$ = new DictionaryEntry ($1, null); }
+                        | type id       { $$ = new DictionaryEntry ($1, $2); }
+                        ;
+                        
 class_refs		: class_ref
                           {
                                 ArrayList class_list = new ArrayList ();
@@ -511,14 +552,13 @@ slashed_name		: comp_name
 
 class_ref		: OPEN_BRACKET comp_name CLOSE_BRACKET slashed_name
                           {
-                                PEAPI.Type type = codegen.ExternTable.GetClass ((string) $2, (string)$4);
-                                $$ = new TypeRef (type, (string) $4);
+                                ClassRef klass = codegen.ExternTable.GetClass ((string) $2, (string)$4);
+                                $$ = new ExternTypeRef (klass, (string) $4);
                           }
 			| OPEN_BRACKET D_MODULE comp_name CLOSE_BRACKET slashed_name
 			| slashed_name
                           {
-                                $$ = new TypeRef (codegen.ClassTable.GetReference ((string) $1, null),
-					(string) $1);
+                                $$ = new TypeRef ((string) $1, null);
                           }
 			;
 
@@ -536,6 +576,9 @@ class_decl		: method_all
 			| extsource_spec
 			| customattr_decl
 			| D_SIZE int32
+                          {
+                                
+                          }
 			| D_PACK int32
 			| D_OVERRIDE type_spec DOUBLE_COLON method_name
 			  K_WITH call_conv type type_spec DOUBLE_COLON method_name
@@ -549,11 +592,11 @@ type			: K_CLASS class_ref
                           }
 			| K_OBJECT
                           {
-                                $$ = new TypeRef (PrimitiveType.Object, "System.Object");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.Object, "System.Object");
                           }
 			| K_STRING
                           {
-                                $$ = new TypeRef (PrimitiveType.String, "System.String");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.String, "System.String");
                           }
 			| K_VALUE K_CLASS class_ref
                           {
@@ -565,151 +608,125 @@ type			: K_CLASS class_ref
                           }
 			| type OPEN_BRACKET CLOSE_BRACKET
                           {
-                                TypeRef base_type = (TypeRef) $1;
-                                PEAPI.Type arr_type = new ZeroBasedArray (base_type.Type);
-                                $$ = new TypeRef (arr_type, base_type.FullName + "[]");
+                                ITypeRef base_type = (ITypeRef) $1;
+                                base_type.MakeArray ();
                           }
 			| type OPEN_BRACKET bounds CLOSE_BRACKET
                           {
-                                TypeRef base_type = (TypeRef) $1;
+                                ITypeRef base_type = (ITypeRef) $1;
                                 ArrayList bound_list = (ArrayList) $3;
-                                int dimen = bound_list.Count;
-                                int[] lower_array = new int[dimen];
-                                int[] size_array = new int[dimen];
-                                bool lower_set = false;
-                                bool size_set = false;
-                                bool prev_lower_set = true;
-                                bool prev_size_set = true;
-
-                                // TODO: There should probably be an error reported if
-                                // something like [3...,3...5] is done
-                                for (int i=0; i<dimen; i++) {
-                                        DictionaryEntry bound = (DictionaryEntry) bound_list[i];
-                                        
-                                        if (bound.Key != null && prev_lower_set) {
-                                                lower_array[i] = (int) bound.Key;
-                                                lower_set = true;
-                                        } else {
-                                                prev_lower_set = false;
-                                        }       
-                                        if (bound.Value != null && prev_size_set) {
-                                                size_array[i] = (int) bound.Value;
-                                                size_set = true;
-                                        } else {
-                                                prev_size_set = false;
-                                        }
-                                }
-                                if (lower_set && size_set) {
-                                        $$ = new BoundArray (base_type.Type,
-                                                (uint) dimen, lower_array, size_array);
-                                } else if (size_set) {
-                                        $$ = new BoundArray (base_type.Type,
-                                                (uint) dimen, size_array);
-                                } else {
-                                        $$ = new BoundArray (base_type.Type, (uint) dimen);
-                                }
+                                base_type.MakeBoundArray (bound_list);
                           }
 			| type AMPERSAND
                           {
-                                TypeRef base_type = $1 as TypeRef;
-                                PEAPI.Type ref_type = new ManagedPointer (base_type.Type);
-                                $$ = new TypeRef (ref_type, base_type.FullName + '&');
+                                ITypeRef base_type = (ITypeRef) $1;
+                                base_type.MakeManagedPointer ();
                           }
 			| type STAR
                           {
-                                TypeRef base_type = (TypeRef) $1;
-                                PEAPI.Type ptr_type = new UnmanagedPointer (base_type.Type);
-                                $$ = new TypeRef (ptr_type, base_type.FullName + '&');
+                                ITypeRef base_type = (ITypeRef) $1;
+                                base_type.MakeUnmanagedPointer ();
                           }
 			| type K_PINNED
                           {
-                                TypeRef type = (TypeRef) $1;
-                                type.Pinned = true;
+                                ITypeRef base_type = (ITypeRef) $1;
+                                base_type.MakePinned ();
                           }
 			| type K_MODREQ OPEN_PARENS class_ref CLOSE_PARENS
                           {
-                                TypeRef base_type = (TypeRef) $1;
-                                TypeRef class_ref = (TypeRef) $4;
+                                /*
+                                ITypeRef base_type = (ITypeRef) $1;
+                                ITypeRef class_ref = (ITypeRef) $4;
 
                                 $$ = new CustomModifiedType (base_type.Type,
                                         CustomModifier.modreq, (Class) class_ref.Type);
+                                */
                           }
 			| type K_MODOPT OPEN_PARENS class_ref CLOSE_PARENS
                           {
+                                /*
                                 TypeRef base_type = (TypeRef) $1;
                                 TypeRef class_ref = (TypeRef) $4;
 
                                 $$ = new CustomModifiedType (base_type.Type,
                                         CustomModifier.modopt, (Class) class_ref.Type);
+                                */
                           }
 			| K_METHOD call_conv type STAR OPEN_PARENS sig_args CLOSE_PARENS
 			| K_TYPEDREF
                           {
-                                $$ = new TypeRef (PrimativeType.TypedRef,
+                                $$ = new PrimitiveTypeRef (PrimitiveType.TypedRef,
                                         "System.TypedReference");
                           }
 			| K_CHAR
                           {
-                                $$ = new TypeRef (PrimitiveType.Char, "System.Char");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.Char, "System.Char");
                           }
 			| K_VOID
                           {
-                                $$ = new TypeRef (PrimitiveType.Void, "System.Void");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.Void, "System.Void");
                           }
 			| K_BOOL
                           {
-                                $$ = new TypeRef (PrimitiveType.Boolean, "System.Bool");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.Boolean, "System.Bool");
                           }
 			| K_INT8
                           {
-                                $$ = new TypeRef (PrimitiveType.Int8, "System.Int8");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.Int8, "System.Int8");
                           }
 			| K_INT16
                           {
-                                $$ = new TypeRef (PrimitiveType.Int16, "System.Int16");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.Int16, "System.Int16");
                           }
 			| K_INT32
                           {
-                                $$ = new TypeRef (PrimitiveType.Int32, "System.Int32");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.Int32, "System.Int32");
                           }
 			| K_INT64
                           {
-                                $$ = new TypeRef (PrimitiveType.Int64, "System.Int64");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.Int64, "System.Int64");
                           }
 			| K_FLOAT32
                           {
-                                $$ = new TypeRef (PrimitiveType.Float32, "System.Float32");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.Float32, "System.Float32");
                           }
 			| K_FLOAT64
                           {
-                                $$ = new TypeRef (PrimitiveType.Float64, "System.Float64");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.Float64, "System.Float64");
                           }
 			| K_UNSIGNED K_INT8
                           {
-                                $$ = new TypeRef (PrimitiveType.UInt8, "System.UInt8");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.UInt8, "System.UInt8");
                           }
 			| K_UNSIGNED K_INT16
                           {
-                                $$ = new TypeRef (PrimitiveType.UInt16, "System.UInt16");     
+                                $$ = new PrimitiveTypeRef (PrimitiveType.UInt16, "System.UInt16");     
                           }
 			| K_UNSIGNED K_INT32
                           {
-                                $$ = new TypeRef (PrimitiveType.UInt32, "System.UInt32");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.UInt32, "System.UInt32");
                           }
 			| K_UNSIGNED K_INT64
                           {
-                                $$ = new TypeRef (PrimitiveType.UInt64, "System.UInt64");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.UInt64, "System.UInt64");
                           }
 			| K_NATIVE K_INT
                           {
                                 // TODO: Is this the proper full name
-                                $$ = new TypeRef (PrimitiveType.NativeInt, "native int");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.NativeInt, "System.IntPtr");
                           }
                         
 			| K_NATIVE K_UNSIGNED K_INT
                           {
-                                // TODO: Is this the proper full name
-                                $$ = new TypeRef (PrimitiveType.NativeUInt, "native uint");
+                                $$ = new PrimitiveTypeRef (PrimitiveType.NativeUInt, "System.UIntPtr");
+                          }
+                        | BANG int32
+                          {
+                                // access class type parameter by number
+                          }
+                        | BANG BANG int32
+                          {
+                                // access method type parameter by number
                           }
 			;
 
@@ -752,39 +769,108 @@ bound			: /* EMPTY */
 			;
 
 call_conv		: K_INSTANCE call_conv
+                          {
+                                $$ = (CallConv) $2 | CallConv.Instance;
+                          }
 			| K_EXPLICIT call_conv
+                          {
+                                $$ = (CallConv) $2 | CallConv.InstanceExplicit;
+                          }
 			| call_kind
 			;
 
 call_kind		: /* EMPTY */
+                          {
+                                $$ = new CallConv ();
+                          }
 			| K_DEFAULT
+                          {
+                                $$ = CallConv.Default;
+                          }
 			| K_VARARG
+                          {
+                                $$ = CallConv.Vararg;
+                          }
 			| K_UNMANAGED K_CDECL
+                          {
+                                $$ = CallConv.Cdecl;
+                          }
 			| K_UNMANAGED K_STDCALL
+                          {
+                                $$ = CallConv.Stdcall;
+                          }
 			| K_UNMANAGED K_THISCALL
+                          {
+                                $$ = CallConv.Thiscall;
+                          }
 			| K_UNMANAGED K_FASTCALL
+                          {
+                                $$ = CallConv.Fastcall;
+                          }
 			;
 
 native_type		: /* EMPTY */
 			| K_CUSTOM OPEN_PARENS comp_qstring COMMA comp_qstring CLOSE_PARENS
 			| K_FIXED K_SYSSTRING OPEN_BRACKET int32 CLOSE_BRACKET
+                          {
+                                $$ = NativeType.FixedSysString;
+                          }
 			| K_FIXED K_ARRAY OPEN_BRACKET int32 CLOSE_BRACKET
 			| K_VARIANT
 			| K_CURRENCY
+                          {
+                                $$ = NativeType.Currency;
+                          }
 			| K_SYSCHAR
 			| K_VOID
+                          {
+                                $$ = NativeType.Void;
+                          }
 			| K_BOOL
+                          {
+                                $$ = NativeType.Boolean;
+                          }
 			| K_INT8
+                          {
+                                $$ = NativeType.Int8;
+                          }
 			| K_INT16
+                          {
+                                $$ = NativeType.Int16;
+                          }
 			| K_INT32
+                          {
+                                $$ = NativeType.Int32;
+                          }
 			| K_INT64
+                          {
+                                $$ = NativeType.Int64;
+                          }
 			| K_FLOAT32
+                          {
+                                $$ = NativeType.Float32;
+                          }
 			| K_FLOAT64
+                          {
+                                $$ = NativeType.Float64;
+                          }
 			| K_ERROR
 			| K_UNSIGNED K_INT8
+                          {
+                                $$ = NativeType.UInt8;
+                          }
 			| K_UNSIGNED K_INT16
+                          {
+                                $$ = NativeType.UInt16;
+                          }
 			| K_UNSIGNED K_INT32
+                          {
+                                $$ = NativeType.UInt32;
+                          }
 			| K_UNSIGNED K_INT64
+                          {
+                                $$ = NativeType.UInt64;
+                          }
 			| native_type STAR
 			| native_type OPEN_BRACKET CLOSE_BRACKET
 			| native_type OPEN_BRACKET int32 CLOSE_BRACKET
@@ -793,25 +879,70 @@ native_type		: /* EMPTY */
 			| K_DECIMAL
 			| K_DATE
 			| K_BSTR
+                          {
+                                $$ = NativeType.BStr;
+                          }
 			| K_LPSTR
+                          {
+                                $$ = NativeType.LPStr;
+                          }
 			| K_LPWSTR
+                          {
+                                $$ = NativeType.LPWStr;
+                          }
 			| K_LPTSTR
+                          {
+                                $$ = NativeType.LPTStr;
+                          }
 			| K_OBJECTREF
 			| K_IUNKNOWN
+                          {
+                                $$ = NativeType.IUnknown;
+                          }
 			| K_IDISPATCH
+                          {
+                                $$ = NativeType.IDispatch;
+                          }
 			| K_STRUCT
+                          {
+                                $$ = NativeType.Struct;
+                          }
 			| K_INTERFACE
+                          {
+                                $$ = NativeType.Interface;
+                          }
 			| K_SAFEARRAY variant_type
 			| K_SAFEARRAY variant_type COMMA comp_qstring
 			| K_INT
+                          {
+                                $$ = NativeType.Int;
+                          }
 			| K_UNSIGNED K_INT
+                          {
+                                $$ = NativeType.UInt;
+                          }
 			| K_NESTED K_STRUCT
 			| K_BYVALSTR
+                          {
+                                $$ = NativeType.ByValStr;
+                          }
 			| K_ANSI K_BSTR
+                          {
+                                $$ = NativeType.AnsiBStr;
+                          }
 			| K_TBSTR
+                          {
+                                $$ = NativeType.TBstr;
+                          }
 			| K_VARIANT K_BOOL
+                          {
+                                $$ = NativeType.VariantBool;
+                          }
 			| K_METHOD
 			| K_AS K_ANY
+                          {
+                                $$ = NativeType.AsAny;
+                          }
 			| K_LPSTRUCT
 			;
 
@@ -862,61 +993,198 @@ variant_type		: /* EMPTY */
 			;
 
 field_decl		: D_FIELD repeat_opt field_attr type id at_opt init_opt
+                          {
+                                FieldDef field_def = new FieldDef((FieldAttr) $3, 
+					(string) $5, (ITypeRef) $4);
+                                codegen.AddFieldDef (field_def);
+                                
+                                if ($2 != null) {
+                                        field_def.SetOffset ((uint) $2);
+                                }
+                                /*
+                                if ($6 != null) {
+                                        field_def.AddDataValue ((DataConstant) $6);
+                                }
+                                */
+                                if ($7 != null) {
+                                        field_def.SetValue ((Constant) $7);
+                                }
+                          }
 			;
 
 repeat_opt		: /* EMPTY */
 			| OPEN_BRACKET int32 CLOSE_BRACKET
+                          {
+                                $$ = $2;
+                          }
 			;
 
 field_attr		: /* EMPTY */
+                          {
+                                $$ = new FieldAttr ();
+                          }
 			| field_attr K_PUBLIC
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.Public;
+                          }
 			| field_attr K_PRIVATE
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.Private;
+                          }
 			| field_attr K_FAMILY
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.Family;
+                          }
 			| field_attr K_ASSEMBLY
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.Assembly;
+                          }
 			| field_attr K_FAMANDASSEM
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.FamAndAssem;
+                          }
 			| field_attr K_FAMORASSEM
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.FamOrAssem;
+                          }
 			| field_attr K_PRIVATESCOPE
+                          {
+                                // This is just 0x0000
+                          }
 			| field_attr K_STATIC
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.Static;
+                          }
 			| field_attr K_INITONLY
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.Initonly;
+                          }
 			| field_attr K_RTSPECIALNAME
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.RTSpecialName;
+                          }
 			| field_attr K_SPECIALNAME
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.SpecialName;
+                          }
 			| field_attr K_MARSHAL OPEN_PARENS native_type CLOSE_PARENS
+                          {
+                                
+                          }
 			| field_attr K_LITERAL
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.Literal;
+                          }
 			| field_attr K_NOTSERIALIZED
+                          {
+                                $$ = (FieldAttr) $1 | FieldAttr.Notserialized;
+                          }
 			;
 
 at_opt			: /* EMPTY */
 			| K_AT id
+                          {
+                                // TODO: Implement DataTable
+                                // $$ = new DataConstant (DataTable.GetOffset ((string) $2));
+                          }
 			;
 
 init_opt		: /* EMPTY */
 			| ASSIGN field_init
+                          {
+                                $$ = $2;
+                          }
 			;
 
 field_init		: K_FLOAT32 OPEN_PARENS float64 CLOSE_PARENS
+                          {
+                                $$ = new FloatConst (Convert.ToSingle ($3));
+                          }
 			| K_FLOAT64 OPEN_PARENS float64 CLOSE_PARENS
+                          {
+                                $$ = new DoubleConst (Convert.ToDouble ($3));
+                          }
 			| K_FLOAT32 OPEN_PARENS int64 CLOSE_PARENS
+                          {
+                                $$ = new FloatConst (Convert.ToSingle ($3));
+                          }
 			| K_FLOAT64 OPEN_PARENS int64 CLOSE_PARENS
+                          {
+                                $$ = new DoubleConst (Convert.ToDouble (3));
+                          }
 			| K_INT64 OPEN_PARENS int64 CLOSE_PARENS
+                          {
+                                $$ = new IntConst (Convert.ToInt64 ($3));
+                          }
 			| K_INT32 OPEN_PARENS int64 CLOSE_PARENS
+                          {
+                                $$ = new IntConst (Convert.ToUInt32 ($3));
+                          }
 			| K_INT16 OPEN_PARENS int64 CLOSE_PARENS
+                          {
+                                $$ = new IntConst (Convert.ToUInt16 ($3));
+                          }
 			| K_CHAR OPEN_PARENS int64 CLOSE_PARENS
+                          {
+                                $$ = new CharConst (Convert.ToChar ($3));
+                          }
 			| K_INT8 OPEN_PARENS int64 CLOSE_PARENS
+                          {
+                                $$ = new IntConst (Convert.ToByte ($3));
+                          }
 			| K_BOOL OPEN_PARENS truefalse CLOSE_PARENS
+                          {
+                                $$ = new BoolConst ((bool) $3);
+                          }
 			| K_BYTEARRAY OPEN_PARENS bytes CLOSE_PARENS
-			| comp_qstring						// ******** ADDED
+                          {
+                                $$ = new ByteArrConst ((byte[]) $3);
+                          }
+			| comp_qstring
+                          {
+                                // ******** THIS IS NOT IN THE DOCUMENTATION ******** //
+                                $$ = new StringConst ((string) $1);
+                          }
 			| K_NULLREF
+                          {
+                                $$ = new NullConst ();
+                          }
 			;
 
 data_decl		: data_head data_body
+                          {
+                                /*
+                                Console.WriteLine ("Creating data decl: '{0}' '{1}'", $1, $2);
+
+                                DataDef datadef = (DataDef) $1;
+                                
+                                if ($2 is ArrayList) {
+                                        ArrayList const_list = (ArrayList) $2;
+                                        DataConstant[] const_arr = new DataConstant[const_list.Count];
+                                        
+                                        for (int i=0; i<const_arr.Length; i++)
+                                                const_arr[i] = (DataConstant) const_list[i];
+
+                                        datadef.PeapiConstant = new ArrayConstant (const_arr);
+                                } else {
+                                        datadef.PeapiConstant = (PEAPI.Constant) $2;
+                                }
+                                */
+                          }
 			;
 
-data_head		: D_DATA tls id ASSIGN 
+data_head		: D_DATA tls id ASSIGN
+                          {
+                                $$ = new DataDef ((string) $3, (bool) $2);    
+                          } 
 			| D_DATA tls
+                          {
+                                $$ = new DataDef (String.Empty, (bool) $2);
+                          }
 			;
 
-tls			: /* EMPTY */
-			| K_TLS
+tls			: /* EMPTY */   { $$ = false; }
+			| K_TLS         { $$ = true; }
 			;
 
 data_body		: OPEN_BRACE dataitem_list CLOSE_BRACE
@@ -930,49 +1198,161 @@ dataitem_list		: dataitem
 dataitem		: K_CHAR STAR OPEN_PARENS comp_qstring CLOSE_PARENS
 			| AMPERSAND OPEN_PARENS id CLOSE_PARENS
 			| K_BYTEARRAY ASSIGN OPEN_PARENS bytes CLOSE_PARENS
-			| K_BYTEARRAY OPEN_PARENS bytes CLOSE_PARENS			// ******** ADDED
+                          {
+                                $$ = new ByteArrConst ((byte[]) $4);
+                          }
+			| K_BYTEARRAY OPEN_PARENS bytes CLOSE_PARENS
+                          {
+                                // ******** THIS IS NOT IN THE SPECIFICATION ******** //
+                                $$ = new ByteArrConst ((byte[]) $3);
+                          }
 			| K_FLOAT32 OPEN_PARENS float64 CLOSE_PARENS repeat_opt
+                          {
+                                FloatConst float_const = new FloatConst ((float) $3);
+
+                                if ($5 != null)
+                                        $$ = new RepeatedConstant (float_const, (int) $5);
+                                else
+                                        $$ = float_const;
+                          }
 			| K_FLOAT64 OPEN_PARENS float64 CLOSE_PARENS repeat_opt
+                          {
+                                DoubleConst double_const = new DoubleConst ((double) $3);
+
+                                if ($5 != null)
+                                        $$ = new RepeatedConstant (double_const, (int) $5);
+                                else
+                                        $$ = double_const;
+                          }
 			| K_INT64 OPEN_PARENS int64 CLOSE_PARENS repeat_opt
+                          {
+                                IntConst int_const = new IntConst ((long) $3);
+
+                                if ($5 != null)
+                                        $$ = new RepeatedConstant (int_const, (int) $5);
+                                else
+                                        $$ = int_const;
+                          }
 			| K_INT32 OPEN_PARENS int32 CLOSE_PARENS repeat_opt
+                          {
+                                IntConst int_const = new IntConst ((int) $3);
+
+                                if ($5 != null)
+                                        $$ = new RepeatedConstant (int_const, (int) $5);
+                                else
+                                        $$ = int_const;
+                          }
 			| K_INT16 OPEN_PARENS int32 CLOSE_PARENS repeat_opt
+                          {
+                                IntConst int_const = new IntConst ((short) $3);
+
+                                if ($5 != null)
+                                        $$ = new RepeatedConstant (int_const, (int) $5);
+                                else
+                                        $$ = int_const;
+                          }
 			| K_INT8 OPEN_PARENS int32 CLOSE_PARENS repeat_opt
+                          {
+                                IntConst int_const = new IntConst ((sbyte) $3);
+
+                                if ($5 != null)
+                                        $$ = new RepeatedConstant (int_const, (int) $5);
+                                else
+                                        $$ = int_const;
+                          }
 			| K_FLOAT32 repeat_opt
+                          {
+                                FloatConst float_const = new FloatConst (0F);
+
+                                if ($2 != null)
+                                        $$ = new RepeatedConstant (float_const, (int) $2);
+                                else
+                                        $$ = float_const;
+                          }
 			| K_FLOAT64 repeat_opt
+                          {
+                                DoubleConst double_const = new DoubleConst (0);
+
+                                if ($2 != null)
+                                        $$ = new RepeatedConstant (double_const, (int) $2);
+                                else
+                                        $$ = double_const;
+                          }
 			| K_INT64 repeat_opt
+                          {
+                                IntConst int_const = new IntConst ((long) 0);
+
+                                if ($2 != null)
+                                        $$ = new RepeatedConstant (int_const, (int) $2);
+                                else
+                                        $$ = int_const;
+                          }
 			| K_INT32 repeat_opt
+                          {
+                                IntConst int_const = new IntConst ((int) 0);
+
+                                if ($2 != null)
+                                        $$ = new RepeatedConstant (int_const, (int) $2);
+                                else
+                                        $$ = int_const;
+                          }
 			| K_INT16 repeat_opt
+                          {
+                                IntConst int_const = new IntConst ((short) 0);
+
+                                if ($2 != null)
+                                        $$ = new RepeatedConstant (int_const, (int) $2);
+                                else
+                                        $$ = int_const;
+                          }
 			| K_INT8 repeat_opt
+                          {
+                                IntConst int_const = new IntConst ((sbyte) 0);
+
+                                if ($2 != null)
+                                        $$ = new RepeatedConstant (int_const, (int) $2);
+                                else
+                                        $$ = int_const;
+                          }
 			;
 
 method_all		: method_head OPEN_BRACE method_decls CLOSE_BRACE
+                          {
+                                codegen.EndMethodDef ();
+                          }
 			;
 
 method_head		: D_METHOD meth_attr call_conv param_attr type method_name
-			  OPEN_PARENS sig_args CLOSE_PARENS impl_attr
+                          typars_clause OPEN_PARENS sig_args CLOSE_PARENS impl_attr
+                          {
+                                MethodDef methdef = new MethodDef ((MethAttr) $2,
+                                        (ImplAttr) $11, (string) $6, (ITypeRef) $5,
+                                        (ArrayList) $9);
+                                codegen.BeginMethodDef (methdef);
+                          }
 			| D_METHOD meth_attr call_conv param_attr type 
 			  K_MARSHAL OPEN_PARENS native_type CLOSE_PARENS method_name
 			  OPEN_PARENS sig_args CLOSE_PARENS impl_attr
 			;
 
-meth_attr		: /* EMPTY */
-			| meth_attr K_STATIC
-			| meth_attr K_PUBLIC
-			| meth_attr K_PRIVATE
-			| meth_attr K_FAMILY
-			| meth_attr K_ASSEMBLY
-			| meth_attr K_FAMANDASSEM
-			| meth_attr K_FAMORASSEM
-			| meth_attr K_PRIVATESCOPE
-			| meth_attr K_FINAL
-			| meth_attr K_VIRTUAL
-			| meth_attr K_ABSTRACT
-			| meth_attr K_HIDEBYSIG
-			| meth_attr K_NEWSLOT
-			| meth_attr K_REQSECOBJ
-			| meth_attr K_SPECIALNAME
-			| meth_attr K_RTSPECIALNAME
-			| meth_attr K_UNMANAGEDEXP
+meth_attr		: /* EMPTY */                   { $$ = new MethAttr (); }
+			| meth_attr K_STATIC            { $$ = (MethAttr) $1 | MethAttr.Static; }
+			| meth_attr K_PUBLIC            { $$ = (MethAttr) $1 | MethAttr.Public; }
+			| meth_attr K_PRIVATE           { $$ = (MethAttr) $1 | MethAttr.Private; }
+			| meth_attr K_FAMILY            { $$ = (MethAttr) $1 | MethAttr.Family; }
+			| meth_attr K_ASSEMBLY          { $$ = (MethAttr) $1 | MethAttr.Assembly; }
+			| meth_attr K_FAMANDASSEM       { $$ = (MethAttr) $1 | MethAttr.FamAndAssem; } 
+			| meth_attr K_FAMORASSEM        { $$ = (MethAttr) $1 | MethAttr.FamOrAssem; } 
+			| meth_attr K_PRIVATESCOPE      { /* CHECK HEADERS */ }
+			| meth_attr K_FINAL             { $$ = (MethAttr) $1 | MethAttr.Final; } 
+			| meth_attr K_VIRTUAL           { $$ = (MethAttr) $1 | MethAttr.Virtual; }
+			| meth_attr K_ABSTRACT          { $$ = (MethAttr) $1 | MethAttr.Abstract; }
+			| meth_attr K_HIDEBYSIG         { $$ = (MethAttr) $1 | MethAttr.HideBySig; }
+			| meth_attr K_NEWSLOT           { $$ = (MethAttr) $1 | MethAttr.NewSlot; }
+			| meth_attr K_REQSECOBJ         { $$ = (MethAttr) $1 | MethAttr.RequireSecObject; }
+			| meth_attr K_SPECIALNAME       { $$ = (MethAttr) $1 | MethAttr.SpecialName; }
+			| meth_attr K_RTSPECIALNAME     { $$ = (MethAttr) $1 | MethAttr.RTSpecialName; }
+			| meth_attr K_UNMANAGEDEXP      
 			| meth_attr K_PINVOKEIMPL OPEN_PARENS comp_qstring K_AS
 				comp_qstring pinv_attr CLOSE_PARENS
 			| meth_attr K_PINVOKEIMPL OPEN_PARENS comp_qstring pinv_attr CLOSE_PARENS
@@ -997,49 +1377,91 @@ method_name		: D_CTOR
 			| comp_name
 			;
 
-param_attr		: /* EMPTY */
-			| param_attr OPEN_BRACKET K_IN CLOSE_BRACKET
-			| param_attr OPEN_BRACKET K_OUT CLOSE_BRACKET
-			| param_attr OPEN_BRACKET K_OPT CLOSE_BRACKET
+param_attr		: /* EMPTY */                                   { $$ = new ParamAttr (); }
+			| param_attr OPEN_BRACKET K_IN CLOSE_BRACKET    { $$ = (ParamAttr) $1 | ParamAttr.In; }
+			| param_attr OPEN_BRACKET K_OUT CLOSE_BRACKET   { $$ = (ParamAttr) $1 | ParamAttr.Out; }
+			| param_attr OPEN_BRACKET K_OPT CLOSE_BRACKET   { $$ = (ParamAttr) $1 | ParamAttr.Opt; }
 			;
 
-impl_attr		: /* EMPTY */
-			| impl_attr K_NATIVE
-			| impl_attr K_CIL
-			| impl_attr K_OPTIL
-			| impl_attr K_MANAGED
-			| impl_attr K_UNMANAGED
-			| impl_attr K_FORWARDREF
-			| impl_attr K_PRESERVESIG
-			| impl_attr K_RUNTIME
-			| impl_attr K_INTERNALCALL
-			| impl_attr K_SYNCHRONIZED
-			| impl_attr K_NOINLINING
+impl_attr		: /* EMPTY */                   { $$ = new ImplAttr (); }
+			| impl_attr K_NATIVE            { $$ = (ImplAttr) $1 | ImplAttr.Native; }
+			| impl_attr K_CIL               { $$ = (ImplAttr) $1 | ImplAttr.IL; }
+			| impl_attr K_OPTIL             { $$ = (ImplAttr) $1 | ImplAttr.Optil; }
+			| impl_attr K_MANAGED           { /* should this reset? */ }
+			| impl_attr K_UNMANAGED         { $$ = (ImplAttr) $1 | ImplAttr.Unmanaged; }
+			| impl_attr K_FORWARDREF        { $$ = (ImplAttr) $1 | ImplAttr.ForwardRef; }
+			| impl_attr K_PRESERVESIG       { $$ = (ImplAttr) $1 | ImplAttr.PreserveSig; }
+			| impl_attr K_RUNTIME           { $$ = (ImplAttr) $1 | ImplAttr.Runtime; }
+			| impl_attr K_INTERNALCALL      { $$ = (ImplAttr) $1 | ImplAttr.InternalCall; }
+			| impl_attr K_SYNCHRONIZED      { $$ = (ImplAttr) $1 | ImplAttr.Synchronised; }
+			| impl_attr K_NOINLINING        { $$ = (ImplAttr) $1 | ImplAttr.NoInLining; }
 			;
 
-sig_args		: /* EMPTY */
+sig_args		:               { $$ = new ArrayList (); }
 			| sig_arg_list
 			;
 
-sig_arg_list		: sig_arg
+sig_arg_list 		: sig_arg
+                          {
+                                ArrayList sig_list = new ArrayList ();
+                                sig_list.Add ($1);
+                                $$ = sig_list;
+                          }
 			| sig_arg_list COMMA sig_arg
+                          {
+                                ArrayList sig_list = (ArrayList) $1;
+                                sig_list.Add ($3);
+                                $$ = sig_list;
+                          }
 			;
 
 sig_arg			: param_attr type
+                          {
+                                $$ = new ParamDef ((ParamAttr) $1, null, (ITypeRef) $2);
+                          }
 			| param_attr type id
+                          {
+                                $$ = new ParamDef ((ParamAttr) $1, (string) $3, (ITypeRef) $2);
+                          }
 			| param_attr type K_MARSHAL OPEN_PARENS native_type CLOSE_PARENS
 			| param_attr type K_MARSHAL OPEN_PARENS native_type CLOSE_PARENS id
 			;
 
+type_list               : /* EMPTY */   { $$ = new ArrayList (); }
+                        | type
+                          {
+                                ArrayList type_list = new ArrayList ();
+                                type_list.Add ($1);
+                                $$ = type_list;
+                          }
+                        | type_list COMMA type
+                          {
+                                ArrayList type_list = (ArrayList) $1;
+                                type_list.Add ($3);
+                          }
+                        ;
+
 method_decls		: /* EMPTY */
 			| method_decls method_decl
 			;
 
 method_decl		: D_EMITBYTE int32
 			| D_MAXSTACK int32
-			| D_LOCALS OPEN_PARENS sig_args CLOSE_PARENS
-			| D_LOCALS K_INIT OPEN_PARENS sig_args CLOSE_PARENS
+			| D_LOCALS OPEN_PARENS local_list CLOSE_PARENS
+                          {
+                                codegen.CurrentMethodDef.AddLocals (
+                                        (ArrayList) $3);
+                          }
+			| D_LOCALS K_INIT OPEN_PARENS local_list CLOSE_PARENS
+                          {
+                                codegen.CurrentMethodDef.AddLocals (
+                                        (ArrayList) $4);
+                                codegen.CurrentMethodDef.InitLocals ();
+                          }
 			| D_ENTRYPOINT
+                          {
+                                codegen.CurrentMethodDef.EntryPoint ();
+                          }
 			| D_ZEROINIT
 			| D_EXPORT OPEN_BRACKET int32 CLOSE_BRACKET
 			| D_EXPORT OPEN_BRACKET int32 CLOSE_BRACKET K_AS id
@@ -1048,6 +1470,9 @@ method_decl		: D_EMITBYTE int32
 			| scope_block
 			| D_PARAM OPEN_BRACKET int32 CLOSE_BRACKET init_opt
 			| id COLON
+                          {
+                                codegen.CurrentMethodDef.AddLabel ((string) $1);
+                          }
 			| seh_block
 			| instr
 			| sec_decl
@@ -1057,6 +1482,38 @@ method_decl		: D_EMITBYTE int32
 			| data_decl
 			;
 
+local_list              : /* EMPTY */
+                        | local
+                          {
+                                ArrayList local_list = new ArrayList ();
+                                local_list.Add ($1);
+                                $$ = local_list;
+                          }
+                        | local_list COMMA local
+                          {
+                                ArrayList local_list = (ArrayList) $1;
+                                local_list.Add ($3);
+                          }
+                        ;
+
+local                   : type
+                          {
+                                $$ = new Local (-1, (ITypeRef) $1);
+                          }
+                        | type id
+                          {
+                                $$ = new Local (-1, (string) $2, (ITypeRef) $1);
+                          }
+                        | OPEN_BRACKET int32 CLOSE_BRACKET type
+                          {
+                                $$ = new Local ((int) $2, (ITypeRef) $4);
+                          }
+                        | OPEN_BRACKET int32 CLOSE_BRACKET type id
+                          {
+                                $$ = new Local ((int) $2, (string) $5, (ITypeRef) $4);
+                          }
+                        ;
+
 type_spec		: class_ref
 			| OPEN_BRACKET comp_name CLOSE_BRACKET
 			| OPEN_BRACKET D_MODULE comp_name CLOSE_BRACKET
@@ -1095,40 +1552,122 @@ handler_block		: scope_block
 			;
 
 instr			: INSTR_NONE
+                          {
+                                codegen.CurrentMethodDef.AddInstr (
+                                        new SimpInstr ((Op) $1));
+                          }
 			| INSTR_VAR int32
+                          {
+                               
+                          }
 			| INSTR_I int32
-			| INSTR_I id /* Allow variable names :p */
+                          {
+                                codegen.CurrentMethodDef.AddInstr (new
+                                        IntInstr ((IntOp) $1, (int) $2));
+                          }
+			| INSTR_I id /* Allow variable names */
 			| INSTR_I8 int64
+                          {
+                                codegen.CurrentMethodDef.AddInstr (new
+                                        IntInstr ((IntOp) $1, (int) $2));
+                          }
 			| INSTR_R float64
+                          {
+                                switch ((MiscInstr) $1) {
+                                case MiscInstr.ldc_r4:
+                                case MiscInstr.ldc_r8:
+                                         codegen.CurrentMethodDef.AddInstr (new LdcInstr ((MiscInstr) $1, (double) $2));
+                                         break;
+                                }
+                          }
 			| INSTR_R int64
+                          {
+                                switch ((MiscInstr) $1) {
+                                        case MiscInstr.ldc_r8:
+                                        codegen.CurrentMethodDef.AddInstr (new LdcInstr ((MiscInstr) $1, (double) $2));
+                                        break;
+                                }
+                          }
 			| INSTR_R OPEN_PARENS bytes CLOSE_PARENS
 			| INSTR_BRTARGET int32
+                          {
+                                // Need to add this to PEAPI        
+                          }
 			| INSTR_BRTARGET id
+                          {
+                                codegen.CurrentMethodDef.AddInstr (new BranchInstr ((BranchOp) $1,
+                                        codegen.CurrentMethodDef, (string) $2));
+                          }
 			| INSTR_METHOD method_ref
+                          {
+                                codegen.CurrentMethodDef.AddInstr (new MethodInstr ((MethodOp) $1,
+                                        (IMethodRef) $2));
+                          }
 			| INSTR_FIELD type type_spec DOUBLE_COLON id
 			| INSTR_FIELD type id
-			| INSTR_TYPE K_FIELD type type_spec DOUBLE_COLON id 			// ****** ADDED
-			| INSTR_TYPE K_FIELD type id						// ****** ADDED
 			| INSTR_TYPE type_spec
+                          {
+                                codegen.CurrentMethodDef.AddInstr (new TypeInstr ((TypeOp) $1,
+                                        (ITypeRef) $2));
+                          }
 			| INSTR_STRING comp_qstring
+                          {
+                                if ((MiscInstr) $1 == MiscInstr.ldstr)
+                                        codegen.CurrentMethodDef.AddInstr (new LdstrInstr ((string) $2));
+                          }
 			| INSTR_STRING K_BYTEARRAY ASSIGN OPEN_PARENS bytes CLOSE_PARENS
 			| INSTR_STRING K_BYTEARRAY OPEN_PARENS bytes CLOSE_PARENS		// ****** ADDED
 			| INSTR_SIG call_conv type OPEN_PARENS sig_args CLOSE_PARENS
 			| INSTR_TOK owner_type
 			| INSTR_SWITCH OPEN_PARENS labels CLOSE_PARENS
+                          {
+                                codegen.CurrentMethodDef.AddInstr (new SwitchInstr ((ArrayList) $3,
+                                        codegen.CurrentMethodDef));
+                          }
 			;
 
 method_ref		: call_conv type type_spec DOUBLE_COLON method_name 
-			  OPEN_PARENS sig_args CLOSE_PARENS
+			  OPEN_PARENS type_list CLOSE_PARENS
+                          {
+                                IClassRef owner = (IClassRef) $3;
+                                ArrayList arg_list = (ArrayList) $7;
+                                
+                                $$ = owner.GetMethodRef ((ITypeRef) $2, (string) $5,
+                                        (ITypeRef[]) arg_list.ToArray (typeof (ITypeRef)));
+                          }
 			| call_conv type method_name 
-			  OPEN_PARENS sig_args CLOSE_PARENS
+			  OPEN_PARENS type_list CLOSE_PARENS
+                          {
+                                ArrayList arg_list = (ArrayList) $5;
+
+                                $$ = new GlobalMethodRef ((ITypeRef) $2, (string) $3,
+                                        (ITypeRef[]) arg_list.ToArray (typeof (ITypeRef)));
+                          }
 			;
 
 labels			: /* EMPTY */
 			| id
+                          {
+                                ArrayList label_list = new ArrayList ();
+                                label_list.Add ($1);
+                                $$ = label_list;
+                          }
 			| int32
+                          {
+                                ArrayList label_list = new ArrayList ();
+                                label_list.Add ($1);
+                                $$ = label_list;
+                          }
 			| labels COMMA id
+                          {
+                                ArrayList label_list = (ArrayList) $1;
+                                label_list.Add ($3);
+                          }
 			| labels COMMA int32
+                          {
+                                ArrayList label_list = (ArrayList) $1;
+                                label_list.Add ($3);
+                          }
 			;
 
 owner_type		: type_spec
@@ -1290,7 +1829,19 @@ assemblyref_all		: assemblyref_head OPEN_BRACE assemblyref_decls CLOSE_BRACE
 			;
 
 assemblyref_head	: D_ASSEMBLY K_EXTERN comp_name
+                          {
+                                System.Reflection.AssemblyName asmb_name = 
+					new System.Reflection.AssemblyName ();
+				asmb_name.Name = (string) $3;
+				codegen.ExternTable.AddAssembly ((string) $3, asmb_name);
+                          }
 			| D_ASSEMBLY K_EXTERN comp_name K_AS comp_name
+                          {
+                                System.Reflection.AssemblyName asmb_name = 
+					new System.Reflection.AssemblyName ();
+				asmb_name.Name = (string) $3;
+				codegen.ExternTable.AddAssembly ((string) $5, asmb_name);
+                          }
 			;
 
 assemblyref_decls	: /* EMPTY */
@@ -1349,20 +1900,24 @@ manifestres_decl	: D_FILE comp_name K_AT int32
 			| customattr_decl
 			;
 
-dotted_name		: id
-			| dotted_name DOT id	{ $$ = String.Format ("{0}.{1}", $1, $3); }
-			;
-
 comp_qstring		: QSTRING
 			| comp_qstring PLUS QSTRING 	{ $$ = String.Format ("{0}{1}", $1, $3); }
 			;
 
 int32			: INT32
-			| INT64
+                        | INT64
+                          {
+                                Int64 int64 = (Int64) $1;
+
+                                if (int64 > Int32.MaxValue)
+                                        $$ = Int32.MaxValue;
+                                else if (int64 < Int32.MinValue)
+                                        $$ = Int32.MinValue;  
+                          }
 			;
 
-int64			: INT32
-			| INT64
+int64		        : INT64
+                        | INT32
 			;
 
 float64			: FLOAT64
@@ -1371,16 +1926,32 @@ float64			: FLOAT64
 			;
 
 hexbyte			: HEXBYTE
-                        | INT32                                 // ******** ADDED
-                        | ID                                    // ******** ADDED
+                        | INT32         { $$ = Convert.ToByte ($1); }
+                        | ID
+                          {
+                                $$ = Byte.Parse ((string) $1, NumberStyles.HexNumber);
+                          }
 			;
 
-bytes 			: /* EMPTY */
+bytes 			: /* EMPTY */   { $$ = new byte[0]; }
 			| hexbytes
+                          {
+                                ArrayList byte_list = (ArrayList) $1;
+                                $$ = byte_list.ToArray (typeof (byte));
+                          }
 			;
 
 hexbytes		: hexbyte
+                          {
+                                ArrayList byte_list = new ArrayList ();
+                                byte_list.Add (Convert.ToByte ($1));
+                                $$ = byte_list;
+                          }
 			| hexbytes hexbyte
+                          {
+                                ArrayList byte_list = (ArrayList) $1;
+                                byte_list.Add (Convert.ToByte ($2));
+                          }
 			;
 
 truefalse		: K_TRUE
@@ -1392,11 +1963,10 @@ id			: ID
 			;
 
 comp_name		: id
-			| dotted_name
-			;
-
-dotted_name		: id
-			| dotted_name DOT id
+			| comp_name DOT id
+                          {
+                                $$ = (string) $1 + '.' + (string) $3;
+                          }
 			;