public void Define (CodeGen code_gen, PEAPI.ClassDef classdef)
                {
                        if (!is_resolved)
                                Resolve (code_gen, classdef);

                        if (addon != null) {
                                addon.Resolve (code_gen);
                                event_def.AddAddon (AsMethodDef (addon.PeapiMethod, "addon"));
                        }

                        if (fire != null) {
                                fire.Resolve (code_gen);
                                event_def.AddFire (AsMethodDef (fire.PeapiMethod, "fire"));
                        }

                        if (other_list != null) {
				foreach (MethodRef otherm in other_list) {
	                                otherm.Resolve (code_gen);
        	                        event_def.AddOther (AsMethodDef (otherm.PeapiMethod, "other"));
				}
                        }

                        if (removeon != null) {
                                removeon.Resolve (code_gen);
                                event_def.AddRemoveOn (AsMethodDef (removeon.PeapiMethod, "removeon"));
                        }
                }

 public PrimitiveTypeRef (PEAPI.PrimitiveType type, string full_name, ArrayList conv_list, string sig_mod)
         : base (full_name, conv_list, sig_mod)
 {
         this.type = type;
         if (SigMod == null)
                 SigMod = String.Empty;
 }

                public PEAPI.Property Resolve (CodeGen code_gen, PEAPI.ClassDef classdef)
                {
                        if (is_resolved)
                                return prop_def;

                        PEAPI.Type[] type_list = new PEAPI.Type[arg_list.Count];

                        for (int i=0; i<type_list.Length; i++) {
                                BaseTypeRef arg_type = (BaseTypeRef) arg_list[i];
                                arg_type.Resolve (code_gen);
                                type_list[i] = arg_type.PeapiType;
                        }

                        type.Resolve (code_gen);
                        prop_def = classdef.AddProperty (name, type.PeapiType, type_list);

                        if ((attr & FeatureAttr.Rtspecialname) != 0)
                                prop_def.SetRTSpecialName ();

                        if ((attr & FeatureAttr.Specialname) != 0)
                                prop_def.SetSpecialName ();

                        prop_def.SetInstance ((attr & FeatureAttr.Instance) != 0);

                        if (customattr_list != null)
                                foreach (CustomAttr customattr in customattr_list)
                                        customattr.AddTo (code_gen, prop_def);


                        is_resolved = true;

                        return prop_def;
                }

 private PEAPI.MethodDef AsMethodDef (PEAPI.Method method, string type)
 {
         PEAPI.MethodDef methoddef = method as PEAPI.MethodDef;
         if (methoddef == null)
                 Report.Error (type + " method of property " + name + " not found");
         return methoddef;
 }

                public void AddTo (CodeGen code_gen, PEAPI.MetaDataElement elem)
                {
                        System.Text.UnicodeEncoding ue = new System.Text.UnicodeEncoding ();
                        foreach (DictionaryEntry entry in permissionset_table) {
                                PEAPI.SecurityAction sec_action = (PEAPI.SecurityAction) entry.Key;
                                SSPermissionSet ps = (SSPermissionSet) entry.Value;

                                code_gen.PEFile.AddDeclSecurity (sec_action,
                                        ue.GetBytes (ps.ToXml ().ToString ()), 
                                         elem);
                        }

                        if (permissionset20_table == null)
                                return;

                        foreach (DictionaryEntry entry in permissionset20_table) {
                                PEAPI.SecurityAction sec_action = (PEAPI.SecurityAction) entry.Key;
                                MIPermissionSet ps = (MIPermissionSet) entry.Value;

                                code_gen.PEFile.AddDeclSecurity (sec_action,
                                        ps.Resolve (code_gen), 
                                        elem);
                        }

                }

 public GenericParamRef (PEAPI.GenParam gen_param, string full_name, ArrayList conv_list)
         : base (full_name, false, conv_list, "")
 {
         this.type = gen_param;
         this.param = gen_param;
         is_added = false;
 }

 public ParamDef (PEAPI.ParamAttr attr, string name,
                 BaseTypeRef typeref) {
         this.attr = attr;
         this.name = name;
         this.typeref = typeref;
         is_defined = false;
         defval = null;
 }

 public PeapiTypeRef (PEAPI.Type peapi_type)
 {
         this.peapi_type = peapi_type;
         is_pinned = false;
         is_array = false;
         is_ref = false;
         use_type_spec = false;
 }

                public CalliInstr (PEAPI.CallConv call_conv, BaseTypeRef ret_type,
				   BaseTypeRef[] param, Location loc)
			: base (loc)
                {
                        this.call_conv = call_conv;
                        this.ret_type = ret_type;
                        this.param = param;
                }

                public override void Emit (CodeGen code_gen, MethodDef meth,
					   PEAPI.CILInstructions cil)
                {
                        if (operand != null)
                                cil.ldstr (operand);
                        else
                                cil.ldstr (b_operand);
                }

 protected override BaseMethodRef CreateMethodRef (BaseTypeRef ret_type,
         PEAPI.CallConv call_conv, string name, BaseTypeRef[] param, int gen_param_count)
 {
         if (SigMod == null | SigMod == "")
                 return new MethodRef (this, call_conv, ret_type, name, param, gen_param_count);
         else
                 return new TypeSpecMethodRef (this, call_conv, ret_type, name, param, gen_param_count);
 }

		private void Resolve (CodeGen code_gen, PEAPI.GenericParameter gp)
		{
			ResolveConstraints (code_gen, gp);
			if (customattrList == null)
				return;

			foreach (CustomAttr customattr in customattrList)
				customattr.AddTo (code_gen, gp);
		}

                public MethodInstr (PEAPI.MethodOp op, BaseMethodRef operand, Location loc)
			: base (loc)
                {
                        this.op = op;
                        this.operand = operand;

                        if (op == PEAPI.MethodOp.newobj || op == PEAPI.MethodOp.callvirt)
                                operand.CallConv |= PEAPI.CallConv.Instance;
                }

                public void Resolve (CodeGen code_gen, PEAPI.Module module)
                {
                        this.module = module;

                        if (customattr_list == null)
                                return;

                        foreach (CustomAttr customattr in customattr_list)
                                customattr.AddTo (code_gen, module);
                }

                public void AddPermission (PEAPI.SecurityAction sec_action, IPermission perm)
                {
                        SSPermissionSet ps = (SSPermissionSet) permissionset_table [sec_action];
                        if (ps == null) {
                                ps = new SSPermissionSet (PermissionState.None);        
                                permissionset_table [sec_action] = ps;
                        }

                        ps.AddPermission (perm);
                }

                public MethodPointerTypeRef (PEAPI.CallConv callconv, BaseTypeRef ret, ArrayList param_list, ArrayList conv_list, string sig_mod)
                        : base (String.Empty, conv_list, sig_mod)
                {
                        this.callconv = callconv;
                        this.ret = ret;
                        this.param_list = param_list;

                        // We just need these to not break the interface
                        full_name = BuildTypeName ();
                        //sig_mod = String.Empty;
                }

                public void AddPermissionSet (PEAPI.SecurityAction sec_action, SSPermissionSet perm_set)
                {
                        SSPermissionSet ps = (SSPermissionSet) permissionset_table [sec_action];
                        if (ps == null) {
                                permissionset_table [sec_action] = perm_set;
                                return;
                        }

                        foreach (IPermission iper in perm_set)
                                ps.AddPermission (iper);
                }

                public override void Emit (CodeGen code_gen, MethodDef meth,
					   PEAPI.CILInstructions cil)
                {
                        PEAPI.CILLabel from = block.GetFromLabel (code_gen, meth);
                        PEAPI.CILLabel to = block.GetToLabel (code_gen, meth);
                        PEAPI.TryBlock try_block = new PEAPI.TryBlock (from, to);

                        foreach (ISehClause clause in clause_list)
                                try_block.AddHandler (clause.Resolve (code_gen, meth));
			
                        cil.AddTryBlock (try_block);
                }

		public GenericParameter (string id, PEAPI.GenericParamAttributes attr, ArrayList constraints)
		{
			this.id = id;
			this.attr = attr;
			num = -1;
			constraintsList = null;
			customattrList = null;
				
			if (constraints != null)
				foreach (BaseTypeRef typeref in constraints)
					AddConstraint (typeref);
		}

 public BaseMethodRef (BaseTypeRef owner, PEAPI.CallConv call_conv,
         BaseTypeRef ret_type, string name, BaseTypeRef[] param, int gen_param_count)
 {
         this.owner = owner;
         this.call_conv = call_conv;
         this.ret_type = ret_type;
         this.name = name;
         this.param = param;
         this.gen_param_count = gen_param_count;
         if (gen_param_count > 0)
                 CallConv |= PEAPI.CallConv.Generic;
         is_resolved = false;
 }