X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fcodegen.cs;h=1ca9edec4901bd49318c57b65517710c2ed89b17;hb=2d23bfcbce7a3f7e54dcd5911adb88b244baca35;hp=af6d336ad482c243e386e998a898f30e03de6a74;hpb=ebd5b41164834c7ffc788c0dc53495c7bdfde9eb;p=mono.git diff --git a/mcs/mcs/codegen.cs b/mcs/mcs/codegen.cs index af6d336ad48..d7c7233499c 100644 --- a/mcs/mcs/codegen.cs +++ b/mcs/mcs/codegen.cs @@ -4,8 +4,8 @@ // Author: // Miguel de Icaza (miguel@ximian.com) // -// (C) 2001, 2002, 2003 Ximian, Inc. -// (C) 2004 Novell, Inc. +// Copyright 2001, 2002, 2003 Ximian, Inc. +// Copyright 2004 Novell, Inc. // // @@ -19,8 +19,8 @@ using System; using System.IO; -using System.Collections; -using System.Collections.Specialized; +using System.Collections.Generic; +using System.Globalization; using System.Reflection; using System.Reflection.Emit; using System.Runtime.InteropServices; @@ -37,10 +37,8 @@ namespace Mono.CSharp { /// public class CodeGen { static AppDomain current_domain; - static public SymbolWriter SymbolWriter; public static AssemblyClass Assembly; - public static ModuleClass Module; static CodeGen () { @@ -50,7 +48,6 @@ namespace Mono.CSharp { public static void Reset () { Assembly = new AssemblyClass (); - Module = new ModuleClass (RootContext.Unsafe); } public static string Basename (string name) @@ -83,27 +80,31 @@ namespace Mono.CSharp { static public string FileName; +#if MS_COMPATIBLE + const AssemblyBuilderAccess COMPILER_ACCESS = 0; +#else + /* Keep this in sync with System.Reflection.Emit.AssemblyBuilder */ + const AssemblyBuilderAccess COMPILER_ACCESS = (AssemblyBuilderAccess) 0x800; +#endif + // - // Initializes the symbol writer + // Initializes the code generator variables for interactive use (repl) // - static void InitializeSymbolWriter (string filename) + static public void InitDynamic (CompilerContext ctx, string name) { - SymbolWriter = SymbolWriter.GetSymbolWriter (Module.Builder, filename); - - // - // If we got an ISymbolWriter instance, initialize it. - // - if (SymbolWriter == null) { - Report.Warning ( - -18, 1, "Could not find the symbol writer assembly (Mono.CompilerServices.SymbolWriter.dll). This is normally an installation problem. Please make sure to compile and install the mcs/class/Mono.CompilerServices.SymbolWriter directory."); - return; - } + current_domain = AppDomain.CurrentDomain; + AssemblyName an = Assembly.GetAssemblyName (name, name); + + Assembly.Builder = current_domain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run | COMPILER_ACCESS); + RootContext.ToplevelTypes = new ModuleCompiled (ctx, true); + RootContext.ToplevelTypes.Builder = Assembly.Builder.DefineDynamicModule (Basename (name), false); + Assembly.Name = Assembly.Builder.GetName (); } - + // // Initializes the code generator variables // - static public bool Init (string name, string output, bool want_debugging_support) + static public bool Init (string name, string output, bool want_debugging_support, CompilerContext ctx) { FileName = output; AssemblyName an = Assembly.GetAssemblyName (name, output); @@ -113,11 +114,11 @@ namespace Mono.CSharp { if (an.KeyPair != null) { // If we are going to strong name our assembly make // sure all its refs are strong named - foreach (Assembly a in RootNamespace.Global.Assemblies) { + foreach (Assembly a in GlobalRootNamespace.Instance.Assemblies) { AssemblyName ref_name = a.GetName (); byte [] b = ref_name.GetPublicKeyToken (); if (b == null || b.Length == 0) { - Report.Error (1577, "Assembly generation failed " + + ctx.Report.Error (1577, "Assembly generation failed " + "-- Referenced assembly '" + ref_name.Name + "' does not have a strong name."); @@ -130,30 +131,28 @@ namespace Mono.CSharp { try { Assembly.Builder = current_domain.DefineDynamicAssembly (an, - AssemblyBuilderAccess.Save, Dirname (name)); + AssemblyBuilderAccess.RunAndSave | COMPILER_ACCESS, Dirname (name)); } catch (ArgumentException) { // specified key may not be exportable outside it's container if (RootContext.StrongNameKeyContainer != null) { - Report.Error (1548, "Could not access the key inside the container `" + + ctx.Report.Error (1548, "Could not access the key inside the container `" + RootContext.StrongNameKeyContainer + "'."); Environment.Exit (1); } - return false; + throw; } catch (CryptographicException) { if ((RootContext.StrongNameKeyContainer != null) || (RootContext.StrongNameKeyFile != null)) { - Report.Error (1548, "Could not use the specified key to strongname the assembly."); + ctx.Report.Error (1548, "Could not use the specified key to strongname the assembly."); Environment.Exit (1); } return false; } -#if GMCS_SOURCE // Get the complete AssemblyName from the builder // (We need to get the public key and token) Assembly.Name = Assembly.Builder.GetName (); -#endif // // Pass a path-less name to DefineDynamicModule. Wonder how @@ -163,22 +162,53 @@ namespace Mono.CSharp { // If the third argument is true, the ModuleBuilder will dynamically // load the default symbol writer. // - Module.Builder = Assembly.Builder.DefineDynamicModule ( - Basename (name), Basename (output), false); - - if (want_debugging_support) - InitializeSymbolWriter (output); + try { + RootContext.ToplevelTypes.Builder = Assembly.Builder.DefineDynamicModule ( + Basename (name), Basename (output), want_debugging_support); + +#if !MS_COMPATIBLE + // TODO: We should use SymbolWriter from DefineDynamicModule + if (want_debugging_support && !SymbolWriter.Initialize (RootContext.ToplevelTypes.Builder, output)) { + ctx.Report.Error (40, "Unexpected debug information initialization error `{0}'", + "Could not find the symbol writer assembly (Mono.CompilerServices.SymbolWriter.dll)"); + return false; + } +#endif + } catch (ExecutionEngineException e) { + ctx.Report.Error (40, "Unexpected debug information initialization error `{0}'", + e.Message); + return false; + } return true; } - static public void Save (string name) + static public void Save (string name, bool saveDebugInfo, Report Report) { + PortableExecutableKinds pekind; + ImageFileMachine machine; + + switch (RootContext.Platform) { + case Platform.X86: + pekind = PortableExecutableKinds.Required32Bit; + machine = ImageFileMachine.I386; + break; + case Platform.X64: + pekind = PortableExecutableKinds.PE32Plus; + machine = ImageFileMachine.AMD64; + break; + case Platform.IA64: + pekind = PortableExecutableKinds.PE32Plus; + machine = ImageFileMachine.IA64; + break; + case Platform.AnyCPU: + default: + pekind = PortableExecutableKinds.ILOnly; + machine = ImageFileMachine.I386; + break; + } try { - Assembly.Builder.Save (Basename (name)); - - if (SymbolWriter != null) - SymbolWriter.WriteSymbolFile (); + Assembly.Builder.Save (Basename (name), pekind, machine); } catch (COMException) { if ((RootContext.StrongNameKeyFile == null) || (!RootContext.StrongNameDelaySign)) @@ -191,136 +221,51 @@ namespace Mono.CSharp { } catch (System.IO.IOException io) { Report.Error (16, "Could not write to file `"+name+"', cause: " + io.Message); + return; } catch (System.UnauthorizedAccessException ua) { Report.Error (16, "Could not write to file `"+name+"', cause: " + ua.Message); + return; + } + catch (System.NotImplementedException nie) { + Report.RuntimeMissingSupport (Location.Null, nie.Message); + return; } - } - } - - - public interface IResolveContext - { - DeclSpace DeclContainer { get; } - bool IsInObsoleteScope { get; } - bool IsInUnsafeScope { get; } - // the declcontainer to lookup for type-parameters. Should only use LookupGeneric on it. - // - // FIXME: This is somewhat of a hack. We don't need a full DeclSpace for this. We just need the - // current type parameters in scope. IUIC, that will require us to rewrite GenericMethod. - // Maybe we can replace this with a 'LookupGeneric (string)' instead, but we'll have to - // handle generic method overrides differently - DeclSpace GenericDeclContainer { get; } + // + // Write debuger symbol file + // + if (saveDebugInfo) + SymbolWriter.WriteSymbolFile (); + } } /// /// An Emit Context is created for each body of code (from methods, /// properties bodies, indexer bodies or constructor bodies) /// - public class EmitContext : IResolveContext { - - DeclSpace declSpace; - public DeclSpace TypeContainer; - public ILGenerator ig; - - [Flags] - public enum Flags : byte { - /// - /// This flag tracks the `checked' state of the compilation, - /// it controls whether we should generate code that does overflow - /// checking, or if we generate code that ignores overflows. - /// - /// The default setting comes from the command line option to generate - /// checked or unchecked code plus any source code changes using the - /// checked/unchecked statements or expressions. Contrast this with - /// the ConstantCheckState flag. - /// - CheckState = 1 << 0, - - /// - /// The constant check state is always set to `true' and cant be changed - /// from the command line. The source code can change this setting with - /// the `checked' and `unchecked' statements and expressions. - /// - ConstantCheckState = 1 << 1, - - AllCheckStateFlags = CheckState | ConstantCheckState, - - /// - /// Whether we are inside an unsafe block - /// - InUnsafe = 1 << 2, - - InCatch = 1 << 3, - InFinally = 1 << 4, - - /// - /// Whether control flow analysis is enabled - /// - DoFlowAnalysis = 1 << 5, - - /// - /// Whether control flow analysis is disabled on structs - /// (only meaningful when DoFlowAnalysis is set) - /// - OmitStructFlowAnalysis = 1 << 6 - } - - Flags flags; - - /// - /// Whether we are emitting code inside a static or instance method - /// - public bool IsStatic; - - /// - /// Whether the actual created method is static or instance method. - /// Althoug the method might be declared as `static', if an anonymous - /// method is involved, we might turn this into an instance method. - /// - /// So this reflects the low-level staticness of the method, while - /// IsStatic represents the semantic, high-level staticness. - /// - public bool MethodIsStatic; - - /// - /// Whether we are emitting a field initializer - /// - public bool IsFieldInitializer; + public class EmitContext : BuilderContext + { + // TODO: Has to be private + public ILGenerator ig; /// /// The value that is allowed to be returned or NULL if there is no /// return type. /// - public readonly Type ReturnType; - - /// - /// Points to the Type (extracted from the TypeContainer) that - /// declares this body of code - /// - public Type ContainerType; - - /// - /// Whether this is generating code for a constructor - /// - public bool IsConstructor; + TypeSpec return_type; /// /// Keeps track of the Type to LocalBuilder temporary storage created /// to store structures (used to compute the address of the structure /// value on structure method invocations) /// - public Hashtable temporary_storage; - - public Block CurrentBlock; - - public int CurrentFile; + Dictionary temporary_storage; /// /// The location where we store the return value. /// - LocalBuilder return_value; + public LocalBuilder return_value; /// /// The location where return has to jump to return the @@ -334,492 +279,489 @@ namespace Mono.CSharp { public bool HasReturnLabel; /// - /// Whether we are inside an iterator block. + /// Current loop begin and end labels. /// - public bool InIterator; - - public bool IsLastStatement; + public Label LoopBegin, LoopEnd; /// - /// Whether we are in a `fixed' initialization + /// Default target in a switch statement. Only valid if + /// InSwitch is true /// - public bool InFixedInitializer; + public Label DefaultTarget; /// - /// Whether we are inside an anonymous method. - /// - public AnonymousContainer CurrentAnonymousMethod; - - /// - /// Location for this EmitContext + /// If this is non-null, points to the current switch statement /// - public Location loc; + public Switch Switch; /// - /// Inside an enum definition, we do not resolve enumeration values - /// to their enumerations, but rather to the underlying type/value - /// This is so EnumVal + EnumValB can be evaluated. - /// - /// There is no "E operator + (E x, E y)", so during an enum evaluation - /// we relax the rules + /// Whether we are inside an anonymous method. /// - public bool InEnumContext; + public AnonymousExpression CurrentAnonymousMethod; + + public readonly IMemberContext MemberContext; - public readonly IResolveContext ResolveContext; + public EmitContext (IMemberContext rc, ILGenerator ig, TypeSpec return_type) + { + this.MemberContext = rc; + this.ig = ig; - /// - /// The current iterator - /// - public Iterator CurrentIterator { - get { return CurrentAnonymousMethod as Iterator; } + this.return_type = return_type; } - /// - /// Whether we are in the resolving stage or not - /// - enum Phase { - Created, - Resolving, - Emitting - } +#region Properties - public static EmitContext TempEc; - - bool isAnonymousMethodAllowed = true; + public TypeSpec CurrentType { + get { return MemberContext.CurrentType; } + } - Phase current_phase; - FlowBranching current_flow_branching; + public TypeParameter[] CurrentTypeParameters { + get { return MemberContext.CurrentTypeParameters; } + } - static int next_id = 0; - int id = ++next_id; + public MemberCore CurrentTypeDefinition { + get { return MemberContext.CurrentMemberDefinition; } + } - public override string ToString () - { - return String.Format ("EmitContext ({0}:{1})", id, - CurrentAnonymousMethod, loc); + public bool IsStatic { + get { return MemberContext.IsStatic; } } - - public EmitContext (IResolveContext rc, DeclSpace parent, DeclSpace ds, Location l, ILGenerator ig, - Type return_type, int code_flags, bool is_constructor) - { - this.ResolveContext = rc; - this.ig = ig; - TypeContainer = parent; - this.declSpace = ds; - if (RootContext.Checked) - flags |= Flags.CheckState; - flags |= Flags.ConstantCheckState; + bool IsAnonymousStoreyMutateRequired { + get { + return CurrentAnonymousMethod != null && + CurrentAnonymousMethod.Storey != null && + CurrentAnonymousMethod.Storey.Mutator != null; + } + } -#if GMCS_SOURCE - if ((return_type is TypeBuilder) && return_type.IsGenericTypeDefinition) - throw new InternalErrorException (); -#endif + // Has to be used for emitter errors only + public Report Report { + get { return MemberContext.Compiler.Report; } + } - IsStatic = (code_flags & Modifiers.STATIC) != 0; - MethodIsStatic = IsStatic; - InIterator = (code_flags & Modifiers.METHOD_YIELDS) != 0; - ReturnType = return_type; - IsConstructor = is_constructor; - CurrentBlock = null; - CurrentFile = 0; - current_phase = Phase.Created; - - if (parent != null){ - // Can only be null for the ResolveType contexts. - ContainerType = parent.TypeBuilder; - if (rc.IsInUnsafeScope) - flags |= Flags.InUnsafe; + public TypeSpec ReturnType { + get { + return return_type; } - loc = l; - - if (ReturnType == TypeManager.void_type) - ReturnType = null; } +#endregion - public EmitContext (IResolveContext rc, DeclSpace ds, Location l, ILGenerator ig, - Type return_type, int code_flags, bool is_constructor) - : this (rc, ds, ds, l, ig, return_type, code_flags, is_constructor) + /// + /// This is called immediately before emitting an IL opcode to tell the symbol + /// writer to which source line this opcode belongs. + /// + public void Mark (Location loc) { + if (!SymbolWriter.HasSymbolWriter || HasSet (Options.OmitDebugInfo) || loc.IsNull) + return; + + SymbolWriter.MarkSequencePoint (ig, loc); } - public EmitContext (IResolveContext rc, DeclSpace ds, Location l, ILGenerator ig, - Type return_type, int code_flags) - : this (rc, ds, ds, l, ig, return_type, code_flags, false) + public void DefineLocalVariable (string name, LocalBuilder builder) { + SymbolWriter.DefineLocalVariable (name, builder); } - public DeclSpace DeclContainer { - get { return declSpace; } - set { declSpace = value; } + public void BeginCatchBlock (TypeSpec type) + { + ig.BeginCatchBlock (type.GetMetaInfo ()); } - public DeclSpace GenericDeclContainer { - get { return DeclContainer; } + public void BeginExceptionBlock () + { + ig.BeginExceptionBlock (); } - public bool CheckState { - get { return (flags & Flags.CheckState) != 0; } + public void BeginFinallyBlock () + { + ig.BeginFinallyBlock (); } - public bool ConstantCheckState { - get { return (flags & Flags.ConstantCheckState) != 0; } + public void BeginScope () + { + ig.BeginScope(); + SymbolWriter.OpenScope(ig); } - public bool InUnsafe { - get { return (flags & Flags.InUnsafe) != 0; } + public void EndExceptionBlock () + { + ig.EndExceptionBlock (); } - public bool InCatch { - get { return (flags & Flags.InCatch) != 0; } + public void EndScope () + { + ig.EndScope(); + SymbolWriter.CloseScope(ig); } - public bool InFinally { - get { return (flags & Flags.InFinally) != 0; } - } + public LocalBuilder DeclareLocal (TypeSpec type, bool pinned) + { + if (IsAnonymousStoreyMutateRequired) + type = CurrentAnonymousMethod.Storey.Mutator.Mutate (type); - public bool DoFlowAnalysis { - get { return (flags & Flags.DoFlowAnalysis) != 0; } + return ig.DeclareLocal (type.GetMetaInfo (), pinned); } - public bool OmitStructFlowAnalysis { - get { return (flags & Flags.OmitStructFlowAnalysis) != 0; } + public Label DefineLabel () + { + return ig.DefineLabel (); } - // utility helper for CheckExpr, UnCheckExpr, Checked and Unchecked statements - // it's public so that we can use a struct at the callsite - public struct FlagsHandle : IDisposable + public void MarkLabel (Label label) { - EmitContext ec; - Flags invmask, oldval; - internal FlagsHandle (EmitContext ec, Flags mask, Flags val) - { - this.ec = ec; - invmask = ~mask; - oldval = ec.flags & mask; - ec.flags = (ec.flags & invmask) | (val & mask); - } - public void Dispose () - { - ec.flags = (ec.flags & invmask) | oldval; - } + ig.MarkLabel (label); } - // Temporarily set all the given flags to the given value. Should be used in an 'using' statement - public FlagsHandle With (Flags bits, bool enable) + public void Emit (OpCode opcode) { - return new FlagsHandle (this, bits, enable ? bits : 0); + ig.Emit (opcode); } - public FlagsHandle WithFlowAnalysis (bool do_flow_analysis, bool omit_struct_analysis) + public void Emit (OpCode opcode, LocalBuilder local) { - Flags newflags = - (do_flow_analysis ? Flags.DoFlowAnalysis : 0) | - (omit_struct_analysis ? Flags.OmitStructFlowAnalysis : 0); - return new FlagsHandle (this, Flags.DoFlowAnalysis | Flags.OmitStructFlowAnalysis, newflags); + ig.Emit (opcode, local); } - public bool IsInObsoleteScope { - get { return ResolveContext.IsInObsoleteScope; } + public void Emit (OpCode opcode, string arg) + { + ig.Emit (opcode, arg); } - public bool IsInUnsafeScope { - get { return InUnsafe || ResolveContext.IsInUnsafeScope; } + public void Emit (OpCode opcode, double arg) + { + ig.Emit (opcode, arg); } - public bool IsAnonymousMethodAllowed { - get { return isAnonymousMethodAllowed; } - set { isAnonymousMethodAllowed = value; } + public void Emit (OpCode opcode, float arg) + { + ig.Emit (opcode, arg); } - public FlowBranching CurrentBranching { - get { return current_flow_branching; } + public void Emit (OpCode opcode, int arg) + { + ig.Emit (opcode, arg); } - // - // Starts a new code branching. This inherits the state of all local - // variables and parameters from the current branching. - // - public FlowBranching StartFlowBranching (FlowBranching.BranchingType type, Location loc) + public void Emit (OpCode opcode, byte arg) { - current_flow_branching = FlowBranching.CreateBranching (CurrentBranching, type, null, loc); - return current_flow_branching; + ig.Emit (opcode, arg); } - // - // Starts a new code branching for block `block'. - // - public FlowBranching StartFlowBranching (Block block) + public void Emit (OpCode opcode, Label label) { - FlowBranching.BranchingType type; - - if ((CurrentBranching != null) && - (CurrentBranching.Type == FlowBranching.BranchingType.Switch)) - type = FlowBranching.BranchingType.SwitchSection; - else - type = FlowBranching.BranchingType.Block; - - flags |= Flags.DoFlowAnalysis; - - current_flow_branching = FlowBranching.CreateBranching ( - CurrentBranching, type, block, block.StartLocation); - return current_flow_branching; + ig.Emit (opcode, label); } - public FlowBranchingException StartFlowBranching (ExceptionStatement stmt) + public void Emit (OpCode opcode, Label[] labels) { - FlowBranchingException branching = new FlowBranchingException (CurrentBranching, stmt); - current_flow_branching = branching; - return branching; + ig.Emit (opcode, labels); } - public FlowBranchingLabeled StartFlowBranching (LabeledStatement stmt) + public void Emit (OpCode opcode, TypeSpec type) { - FlowBranchingLabeled branching = new FlowBranchingLabeled (CurrentBranching, stmt); - current_flow_branching = branching; - return branching; + if (IsAnonymousStoreyMutateRequired) + type = CurrentAnonymousMethod.Storey.Mutator.Mutate (type); + + ig.Emit (opcode, type.GetMetaInfo ()); } - public FlowBranchingToplevel StartFlowBranching (ToplevelBlock stmt) + public void Emit (OpCode opcode, FieldSpec field) { - FlowBranchingToplevel branching = new FlowBranchingToplevel (CurrentBranching, stmt); - current_flow_branching = branching; - return branching; + if (IsAnonymousStoreyMutateRequired) + field = field.Mutate (CurrentAnonymousMethod.Storey.Mutator); + + ig.Emit (opcode, field.GetMetaInfo ()); } - // - // Ends a code branching. Merges the state of locals and parameters - // from all the children of the ending branching. - // - public FlowBranching.UsageVector DoEndFlowBranching () + public void Emit (OpCode opcode, MethodSpec method) { - FlowBranching old = current_flow_branching; - current_flow_branching = current_flow_branching.Parent; + if (IsAnonymousStoreyMutateRequired) + method = method.Mutate (CurrentAnonymousMethod.Storey.Mutator); - return current_flow_branching.MergeChild (old); + if (method.IsConstructor) + ig.Emit (opcode, (ConstructorInfo) method.GetMetaInfo ()); + else + ig.Emit (opcode, (MethodInfo) method.GetMetaInfo ()); } - // - // Ends a code branching. Merges the state of locals and parameters - // from all the children of the ending branching. - // - public FlowBranching.Reachability EndFlowBranching () + // TODO: REMOVE breaks mutator + public void Emit (OpCode opcode, MethodInfo method) { - FlowBranching.UsageVector vector = DoEndFlowBranching (); - - return vector.Reachability; + ig.Emit (opcode, method); } - // - // Kills the current code branching. This throws away any changed state - // information and should only be used in case of an error. - // - public void KillFlowBranching () + // TODO: REMOVE breaks mutator + public void Emit (OpCode opcode, FieldBuilder field) { - current_flow_branching = current_flow_branching.Parent; + ig.Emit (opcode, field); } - public bool MustCaptureVariable (LocalInfo local) + public void Emit (OpCode opcode, MethodSpec method, Type[] vargs) { - if (CurrentAnonymousMethod == null) - return false; - if (CurrentAnonymousMethod.IsIterator) - return true; - return local.Block.Toplevel != CurrentBlock.Toplevel; + // TODO MemberCache: This should mutate too + ig.EmitCall (opcode, (MethodInfo) method.GetMetaInfo (), vargs); } - - public void EmitMeta (ToplevelBlock b) + + public void EmitArrayNew (ArrayContainer ac) { - b.EmitMeta (this); + if (ac.Rank == 1) { + Emit (OpCodes.Newarr, ac.Element); + } else { + if (IsAnonymousStoreyMutateRequired) + ac = (ArrayContainer) ac.Mutate (CurrentAnonymousMethod.Storey.Mutator); - if (HasReturnLabel) - ReturnLabel = ig.DefineLabel (); + ig.Emit (OpCodes.Newobj, ac.GetConstructor ()); + } } // - // Here until we can fix the problem with Mono.CSharp.Switch, which - // currently can not cope with ig == null during resolve (which must - // be fixed for switch statements to work on anonymous methods). + // Emits the right opcode to load from an array // - public void EmitTopBlock (IMethodData md, ToplevelBlock block) + public void EmitArrayLoad (ArrayContainer ac) { - if (block == null) - return; - - bool unreachable; - - if (ResolveTopBlock (null, block, md.ParameterInfo, md, out unreachable)){ - EmitMeta (block); + if (ac.Rank > 1) { + if (IsAnonymousStoreyMutateRequired) + ac = (ArrayContainer) ac.Mutate (CurrentAnonymousMethod.Storey.Mutator); - current_phase = Phase.Emitting; - EmitResolvedTopBlock (block, unreachable); + ig.Emit (OpCodes.Call, ac.GetGetMethod ()); + return; } - } - bool resolved; + var type = ac.Element; + if (TypeManager.IsEnumType (type)) + type = EnumSpec.GetUnderlyingType (type); + + if (type == TypeManager.byte_type || type == TypeManager.bool_type) + Emit (OpCodes.Ldelem_U1); + else if (type == TypeManager.sbyte_type) + Emit (OpCodes.Ldelem_I1); + else if (type == TypeManager.short_type) + Emit (OpCodes.Ldelem_I2); + else if (type == TypeManager.ushort_type || type == TypeManager.char_type) + Emit (OpCodes.Ldelem_U2); + else if (type == TypeManager.int32_type) + Emit (OpCodes.Ldelem_I4); + else if (type == TypeManager.uint32_type) + Emit (OpCodes.Ldelem_U4); + else if (type == TypeManager.uint64_type) + Emit (OpCodes.Ldelem_I8); + else if (type == TypeManager.int64_type) + Emit (OpCodes.Ldelem_I8); + else if (type == TypeManager.float_type) + Emit (OpCodes.Ldelem_R4); + else if (type == TypeManager.double_type) + Emit (OpCodes.Ldelem_R8); + else if (type == TypeManager.intptr_type) + Emit (OpCodes.Ldelem_I); + else if (TypeManager.IsStruct (type)) { + Emit (OpCodes.Ldelema, type); + Emit (OpCodes.Ldobj, type); + } else if (type.IsGenericParameter) { + Emit (OpCodes.Ldelem, type); + } else if (type.IsPointer) + Emit (OpCodes.Ldelem_I); + else + Emit (OpCodes.Ldelem_Ref); + } - public bool ResolveTopBlock (EmitContext anonymous_method_host, ToplevelBlock block, - Parameters ip, IMethodData md, out bool unreachable) + // + // Emits the right opcode to store to an array + // + public void EmitArrayStore (ArrayContainer ac) { - current_phase = Phase.Resolving; - - unreachable = false; - - if (resolved) - return true; - - if (!loc.IsNull) - CurrentFile = loc.File; + if (ac.Rank > 1) { + if (IsAnonymousStoreyMutateRequired) + ac = (ArrayContainer) ac.Mutate (CurrentAnonymousMethod.Storey.Mutator); -#if PRODUCTION - try { -#endif - if (!block.ResolveMeta (this, ip)) - return false; - - if ((md != null) && (md.Iterator != null)) { - if (!md.Iterator.Resolve (this)) - return false; - } - - using (this.With (EmitContext.Flags.DoFlowAnalysis, true)) { - FlowBranchingToplevel top_level; - if (anonymous_method_host != null) - top_level = new FlowBranchingToplevel (anonymous_method_host.CurrentBranching, block); - else - top_level = block.TopLevelBranching; - - current_flow_branching = top_level; - bool ok = block.Resolve (this); - current_flow_branching = null; - - if (!ok) - return false; - - FlowBranching.Reachability reachability = top_level.End (); - if (reachability.IsUnreachable) - unreachable = true; - } -#if PRODUCTION - } catch (Exception e) { - Console.WriteLine ("Exception caught by the compiler while compiling:"); - Console.WriteLine (" Block that caused the problem begin at: " + loc); - - if (CurrentBlock != null){ - Console.WriteLine (" Block being compiled: [{0},{1}]", - CurrentBlock.StartLocation, CurrentBlock.EndLocation); - } - Console.WriteLine (e.GetType ().FullName + ": " + e.Message); - throw; - } -#endif - - if (ReturnType != null && !unreachable) { - if (CurrentAnonymousMethod == null) { - Report.Error (161, md.Location, "`{0}': not all code paths return a value", md.GetSignatureForError ()); - return false; - } else if (!CurrentAnonymousMethod.IsIterator) { - Report.Error (1643, CurrentAnonymousMethod.Location, "Not all code paths return a value in anonymous method of type `{0}'", - CurrentAnonymousMethod.GetSignatureForError ()); - return false; - } + ig.Emit (OpCodes.Call, ac.GetSetMethod ()); + return; } - if (!block.CompleteContexts (this)) - return false; - - resolved = true; - return true; + var type = ac.Element; + + if (type.IsEnum) + type = EnumSpec.GetUnderlyingType (type); + + if (type == TypeManager.byte_type || type == TypeManager.sbyte_type || type == TypeManager.bool_type) + Emit (OpCodes.Stelem_I1); + else if (type == TypeManager.short_type || type == TypeManager.ushort_type || type == TypeManager.char_type) + Emit (OpCodes.Stelem_I2); + else if (type == TypeManager.int32_type || type == TypeManager.uint32_type) + Emit (OpCodes.Stelem_I4); + else if (type == TypeManager.int64_type || type == TypeManager.uint64_type) + Emit (OpCodes.Stelem_I8); + else if (type == TypeManager.float_type) + Emit (OpCodes.Stelem_R4); + else if (type == TypeManager.double_type) + Emit (OpCodes.Stelem_R8); + else if (type == TypeManager.intptr_type) + Emit (OpCodes.Stobj, type); + else if (TypeManager.IsStruct (type)) + Emit (OpCodes.Stobj, type); + else if (type.IsGenericParameter) + Emit (OpCodes.Stelem, type); + else if (type.IsPointer) + Emit (OpCodes.Stelem_I); + else + Emit (OpCodes.Stelem_Ref); } - public void EmitResolvedTopBlock (ToplevelBlock block, bool unreachable) + public void EmitInt (int i) { - if (block != null) - block.Emit (this); - - if (HasReturnLabel) - ig.MarkLabel (ReturnLabel); - - if (return_value != null){ - ig.Emit (OpCodes.Ldloc, return_value); - ig.Emit (OpCodes.Ret); - } else { - // - // If `HasReturnLabel' is set, then we already emitted a - // jump to the end of the method, so we must emit a `ret' - // there. - // - // Unfortunately, System.Reflection.Emit automatically emits - // a leave to the end of a finally block. This is a problem - // if no code is following the try/finally block since we may - // jump to a point after the end of the method. - // As a workaround, we're always creating a return label in - // this case. - // - - bool in_iterator = (CurrentAnonymousMethod != null) && - CurrentAnonymousMethod.IsIterator && InIterator; - - if ((block != null) && block.IsDestructor) { - // Nothing to do; S.R.E automatically emits a leave. - } else if (HasReturnLabel || (!unreachable && !in_iterator)) { - if (ReturnType != null) - ig.Emit (OpCodes.Ldloc, TemporaryReturn ()); - ig.Emit (OpCodes.Ret); - } + switch (i) { + case -1: + ig.Emit (OpCodes.Ldc_I4_M1); + break; + + case 0: + ig.Emit (OpCodes.Ldc_I4_0); + break; + + case 1: + ig.Emit (OpCodes.Ldc_I4_1); + break; + + case 2: + ig.Emit (OpCodes.Ldc_I4_2); + break; + + case 3: + ig.Emit (OpCodes.Ldc_I4_3); + break; + + case 4: + ig.Emit (OpCodes.Ldc_I4_4); + break; + + case 5: + ig.Emit (OpCodes.Ldc_I4_5); + break; + + case 6: + ig.Emit (OpCodes.Ldc_I4_6); + break; + + case 7: + ig.Emit (OpCodes.Ldc_I4_7); + break; + + case 8: + ig.Emit (OpCodes.Ldc_I4_8); + break; + + default: + if (i >= -128 && i <= 127) { + ig.Emit (OpCodes.Ldc_I4_S, (sbyte) i); + } else + ig.Emit (OpCodes.Ldc_I4, i); + break; } } - /// - /// This is called immediately before emitting an IL opcode to tell the symbol - /// writer to which source line this opcode belongs. - /// - public void Mark (Location loc, bool check_file) + public void EmitLong (long l) { - if ((CodeGen.SymbolWriter == null) || loc.IsNull) + if (l >= int.MinValue && l <= int.MaxValue) { + EmitInt (unchecked ((int) l)); + ig.Emit (OpCodes.Conv_I8); return; + } - if (check_file && (CurrentFile != loc.File)) - return; - - CodeGen.SymbolWriter.MarkSequencePoint (ig, loc.Row, loc.Column); - } - - public void DefineLocalVariable (string name, LocalBuilder builder) - { - if (CodeGen.SymbolWriter == null) + if (l >= 0 && l <= uint.MaxValue) { + EmitInt (unchecked ((int) l)); + ig.Emit (OpCodes.Conv_U8); return; + } - CodeGen.SymbolWriter.DefineLocalVariable (name, builder); + ig.Emit (OpCodes.Ldc_I8, l); } - public void BeginScope () + // + // Load the object from the pointer. + // + public void EmitLoadFromPtr (TypeSpec t) { - ig.BeginScope(); - - if (CodeGen.SymbolWriter != null) - CodeGen.SymbolWriter.OpenScope(ig); + if (t == TypeManager.int32_type) + ig.Emit (OpCodes.Ldind_I4); + else if (t == TypeManager.uint32_type) + ig.Emit (OpCodes.Ldind_U4); + else if (t == TypeManager.short_type) + ig.Emit (OpCodes.Ldind_I2); + else if (t == TypeManager.ushort_type) + ig.Emit (OpCodes.Ldind_U2); + else if (t == TypeManager.char_type) + ig.Emit (OpCodes.Ldind_U2); + else if (t == TypeManager.byte_type) + ig.Emit (OpCodes.Ldind_U1); + else if (t == TypeManager.sbyte_type) + ig.Emit (OpCodes.Ldind_I1); + else if (t == TypeManager.uint64_type) + ig.Emit (OpCodes.Ldind_I8); + else if (t == TypeManager.int64_type) + ig.Emit (OpCodes.Ldind_I8); + else if (t == TypeManager.float_type) + ig.Emit (OpCodes.Ldind_R4); + else if (t == TypeManager.double_type) + ig.Emit (OpCodes.Ldind_R8); + else if (t == TypeManager.bool_type) + ig.Emit (OpCodes.Ldind_I1); + else if (t == TypeManager.intptr_type) + ig.Emit (OpCodes.Ldind_I); + else if (t.IsEnum) { + if (t == TypeManager.enum_type) + ig.Emit (OpCodes.Ldind_Ref); + else + EmitLoadFromPtr (EnumSpec.GetUnderlyingType (t)); + } else if (TypeManager.IsStruct (t) || TypeManager.IsGenericParameter (t)) + Emit (OpCodes.Ldobj, t); + else if (t.IsPointer) + ig.Emit (OpCodes.Ldind_I); + else + ig.Emit (OpCodes.Ldind_Ref); } - public void EndScope () + // + // The stack contains the pointer and the value of type `type' + // + public void EmitStoreFromPtr (TypeSpec type) { - ig.EndScope(); - - if (CodeGen.SymbolWriter != null) - CodeGen.SymbolWriter.CloseScope(ig); + if (type.IsEnum) + type = EnumSpec.GetUnderlyingType (type); + + if (type == TypeManager.int32_type || type == TypeManager.uint32_type) + ig.Emit (OpCodes.Stind_I4); + else if (type == TypeManager.int64_type || type == TypeManager.uint64_type) + ig.Emit (OpCodes.Stind_I8); + else if (type == TypeManager.char_type || type == TypeManager.short_type || + type == TypeManager.ushort_type) + ig.Emit (OpCodes.Stind_I2); + else if (type == TypeManager.float_type) + ig.Emit (OpCodes.Stind_R4); + else if (type == TypeManager.double_type) + ig.Emit (OpCodes.Stind_R8); + else if (type == TypeManager.byte_type || type == TypeManager.sbyte_type || + type == TypeManager.bool_type) + ig.Emit (OpCodes.Stind_I1); + else if (type == TypeManager.intptr_type) + ig.Emit (OpCodes.Stind_I); + else if (TypeManager.IsStruct (type) || TypeManager.IsGenericParameter (type)) + ig.Emit (OpCodes.Stobj, type.GetMetaInfo ()); + else + ig.Emit (OpCodes.Stind_Ref); } /// /// Returns a temporary storage for a variable of type t as /// a local variable in the current body. /// - public LocalBuilder GetTemporaryLocal (Type t) + public LocalBuilder GetTemporaryLocal (TypeSpec t) { if (temporary_storage != null) { - object o = temporary_storage [t]; - if (o != null) { - if (o is Stack) { - Stack s = (Stack) o; + object o; + if (temporary_storage.TryGetValue (t, out o)) { + if (o is Stack) { + var s = (Stack) o; o = s.Count == 0 ? null : s.Pop (); } else { temporary_storage.Remove (t); @@ -828,49 +770,31 @@ namespace Mono.CSharp { if (o != null) return (LocalBuilder) o; } - return ig.DeclareLocal (t); + return DeclareLocal (t, false); } - public void FreeTemporaryLocal (LocalBuilder b, Type t) + public void FreeTemporaryLocal (LocalBuilder b, TypeSpec t) { - Stack s; - if (temporary_storage == null) { - temporary_storage = new Hashtable (); - temporary_storage [t] = b; + temporary_storage = new Dictionary (ReferenceEquality.Default); + temporary_storage.Add (t, b); return; } - object o = temporary_storage [t]; - if (o == null) { - temporary_storage [t] = b; + object o; + + if (!temporary_storage.TryGetValue (t, out o)) { + temporary_storage.Add (t, b); return; } - if (o is Stack) { - s = (Stack) o; - } else { - s = new Stack (); - s.Push (o); + var s = o as Stack; + if (s == null) { + s = new Stack (); + s.Push ((LocalBuilder)o); temporary_storage [t] = s; } s.Push (b); } - /// - /// Current loop begin and end labels. - /// - public Label LoopBegin, LoopEnd; - - /// - /// Default target in a switch statement. Only valid if - /// InSwitch is true - /// - public Label DefaultTarget; - - /// - /// If this is non-null, points to the current switch statement - /// - public Switch Switch; - /// /// ReturnValue creates on demand the LocalBuilder for the /// return value from the function. By default this is not @@ -886,62 +810,23 @@ namespace Mono.CSharp { public LocalBuilder TemporaryReturn () { if (return_value == null){ - return_value = ig.DeclareLocal (ReturnType); + return_value = DeclareLocal (return_type, false); if (!HasReturnLabel){ - ReturnLabel = ig.DefineLabel (); + ReturnLabel = DefineLabel (); HasReturnLabel = true; } } return return_value; } - - /// - /// This method is used during the Resolution phase to flag the - /// need to define the ReturnLabel - /// - public void NeedReturnLabel () - { - if (current_phase != Phase.Resolving){ - // - // The reason is that the `ReturnLabel' is declared between - // resolution and emission - // - throw new Exception ("NeedReturnLabel called from Emit phase, should only be called during Resolve"); - } - - if (!InIterator && !HasReturnLabel) - HasReturnLabel = true; - } - - - public Expression GetThis (Location loc) - { - This my_this; - if (CurrentBlock != null) - my_this = new This (CurrentBlock, loc); - else - my_this = new This (loc); - - if (!my_this.ResolveBase (this)) - my_this = null; - - return my_this; - } } - - public abstract class CommonAssemblyModulClass : Attributable, IResolveContext { - - protected CommonAssemblyModulClass (): - base (null) - { - } - - public void AddAttributes (ArrayList attrs) + public abstract class CommonAssemblyModulClass : Attributable, IMemberContext + { + public void AddAttributes (List attrs, IMemberContext context) { foreach (Attribute a in attrs) - a.AttachTo (this); + a.AttachTo (this, context); if (attributes == null) { attributes = new Attributes (attrs); @@ -958,7 +843,7 @@ namespace Mono.CSharp { OptAttributes.Emit (); } - protected Attribute ResolveAttribute (Type a_type) + protected Attribute ResolveAttribute (PredefinedAttribute a_type) { Attribute a = OptAttributes.Search (a_type); if (a != null) { @@ -967,28 +852,60 @@ namespace Mono.CSharp { return a; } - public override IResolveContext ResolveContext { - get { return this; } + #region IMemberContext Members + + public CompilerContext Compiler { + get { return RootContext.ToplevelTypes.Compiler; } + } + + public TypeSpec CurrentType { + get { return null; } } - #region IResolveContext Members + public TypeParameter[] CurrentTypeParameters { + get { return null; } + } - public DeclSpace DeclContainer { + public MemberCore CurrentMemberDefinition { get { return RootContext.ToplevelTypes; } } - public DeclSpace GenericDeclContainer { - get { return DeclContainer; } + public string GetSignatureForError () + { + return ""; + } + + public bool HasUnresolvedConstraints { + get { return false; } + } + + public bool IsObsolete { + get { return false; } } - public bool IsInObsoleteScope { + public bool IsUnsafe { get { return false; } } - public bool IsInUnsafeScope { + public bool IsStatic { get { return false; } } + public ExtensionMethodGroupExpr LookupExtensionMethod (TypeSpec extensionType, string name, int arity, Location loc) + { + throw new NotImplementedException (); + } + + public FullNamedExpression LookupNamespaceOrType (string name, int arity, Location loc, bool ignore_cs0104) + { + return RootContext.ToplevelTypes.LookupNamespaceOrType (name, arity, loc, ignore_cs0104); + } + + public FullNamedExpression LookupNamespaceAlias (string name) + { + return null; + } + #endregion } @@ -997,29 +914,27 @@ namespace Mono.CSharp { public AssemblyBuilder Builder; bool is_cls_compliant; bool wrap_non_exception_throws; - bool has_extension_method; public Attribute ClsCompliantAttribute; - ListDictionary declarative_security; -#if GMCS_SOURCE + Dictionary declarative_security; + bool has_extension_method; public AssemblyName Name; MethodInfo add_type_forwarder; - ListDictionary emitted_forwarders; -#endif + Dictionary emitted_forwarders; // Module is here just because of error messages static string[] attribute_targets = new string [] { "assembly", "module" }; - public AssemblyClass (): base () + public AssemblyClass () { -#if GMCS_SOURCE wrap_non_exception_throws = true; -#endif } public bool HasExtensionMethods { - set { has_extension_method = value; } + set { + has_extension_method = value; + } } public bool IsClsCompliant { @@ -1045,8 +960,40 @@ namespace Mono.CSharp { return is_cls_compliant; } + Report Report { + get { return Compiler.Report; } + } + public void Resolve () { + if (RootContext.Unsafe) { + // + // Emits [assembly: SecurityPermissionAttribute (SecurityAction.RequestMinimum, SkipVerification = true)] + // when -unsafe option was specified + // + + Location loc = Location.Null; + + MemberAccess system_security_permissions = new MemberAccess (new MemberAccess ( + new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Security", loc), "Permissions", loc); + + Arguments pos = new Arguments (1); + pos.Add (new Argument (new MemberAccess (new MemberAccess (system_security_permissions, "SecurityAction", loc), "RequestMinimum"))); + + Arguments named = new Arguments (1); + named.Add (new NamedArgument ("SkipVerification", loc, new BoolLiteral (true, loc))); + + GlobalAttribute g = new GlobalAttribute (new NamespaceEntry (null, null, null), "assembly", + new MemberAccess (system_security_permissions, "SecurityPermissionAttribute"), + new Arguments[] { pos, named }, loc, false); + g.AttachTo (this, this); + + if (g.Resolve () != null) { + declarative_security = new Dictionary (); + g.ExtractSecurityPermissionSet (declarative_security); + } + } + if (OptAttributes == null) return; @@ -1054,19 +1001,18 @@ namespace Mono.CSharp { if (!OptAttributes.CheckTargets()) return; - ClsCompliantAttribute = ResolveAttribute (TypeManager.cls_compliant_attribute_type); + ClsCompliantAttribute = ResolveAttribute (PredefinedAttributes.Get.CLSCompliant); + if (ClsCompliantAttribute != null) { is_cls_compliant = ClsCompliantAttribute.GetClsCompliantAttributeValue (); } -#if GMCS_SOURCE - Attribute a = ResolveAttribute (TypeManager.runtime_compatibility_attr_type); + Attribute a = ResolveAttribute (PredefinedAttributes.Get.RuntimeCompatibility); if (a != null) { - object val = a.GetPropertyValue ("WrapNonExceptionThrows"); + var val = a.GetPropertyValue ("WrapNonExceptionThrows") as BoolConstant; if (val != null) - wrap_non_exception_throws = (bool)val; + wrap_non_exception_throws = val.Value; } -#endif } // fix bug #56621 @@ -1113,43 +1059,41 @@ namespace Mono.CSharp { // are loaded yet. // TODO: Does not handle quoted attributes properly switch (a.Name) { - case "AssemblyKeyFile": - case "AssemblyKeyFileAttribute": - case "System.Reflection.AssemblyKeyFileAttribute": - if (RootContext.StrongNameKeyFile != null) { - Report.SymbolRelatedToPreviousError (a.Location, a.Name); - Report.Warning (1616, 1, "Option `{0}' overrides attribute `{1}' given in a source file or added module", - "keyfile", "System.Reflection.AssemblyKeyFileAttribute"); - } - else { - string value = a.GetString (); - if (value.Length != 0) - RootContext.StrongNameKeyFile = value; - } - break; - case "AssemblyKeyName": - case "AssemblyKeyNameAttribute": - case "System.Reflection.AssemblyKeyNameAttribute": - if (RootContext.StrongNameKeyContainer != null) { - Report.SymbolRelatedToPreviousError (a.Location, a.Name); - Report.Warning (1616, 1, "Option `{0}' overrides attribute `{1}' given in a source file or added module", + case "AssemblyKeyFile": + case "AssemblyKeyFileAttribute": + case "System.Reflection.AssemblyKeyFileAttribute": + if (RootContext.StrongNameKeyFile != null) { + Report.SymbolRelatedToPreviousError (a.Location, a.GetSignatureForError ()); + Report.Warning (1616, 1, "Option `{0}' overrides attribute `{1}' given in a source file or added module", + "keyfile", "System.Reflection.AssemblyKeyFileAttribute"); + } else { + string value = a.GetString (); + if (value != null && value.Length != 0) + RootContext.StrongNameKeyFile = value; + } + break; + case "AssemblyKeyName": + case "AssemblyKeyNameAttribute": + case "System.Reflection.AssemblyKeyNameAttribute": + if (RootContext.StrongNameKeyContainer != null) { + Report.SymbolRelatedToPreviousError (a.Location, a.GetSignatureForError ()); + Report.Warning (1616, 1, "Option `{0}' overrides attribute `{1}' given in a source file or added module", "keycontainer", "System.Reflection.AssemblyKeyNameAttribute"); - } - else { - string value = a.GetString (); - if (value.Length != 0) - RootContext.StrongNameKeyContainer = value; - } - break; - case "AssemblyDelaySign": - case "AssemblyDelaySignAttribute": - case "System.Reflection.AssemblyDelaySignAttribute": - RootContext.StrongNameDelaySign = a.GetBoolean (); - break; + } else { + string value = a.GetString (); + if (value != null && value.Length != 0) + RootContext.StrongNameKeyContainer = value; + } + break; + case "AssemblyDelaySign": + case "AssemblyDelaySignAttribute": + case "System.Reflection.AssemblyDelaySignAttribute": + RootContext.StrongNameDelaySign = a.GetBoolean (); + break; } } } - + AssemblyName an = new AssemblyName (); an.Name = Path.GetFileNameWithoutExtension (name); @@ -1219,7 +1163,6 @@ namespace Mono.CSharp { Report.Error (1548, "Error during assembly signing. " + text); } -#if GMCS_SOURCE bool CheckInternalsVisibleAttribute (Attribute a) { string assembly_name = a.GetString (); @@ -1240,7 +1183,7 @@ namespace Mono.CSharp { else if (aname.Version != null || aname.CultureInfo != null) throw new Exception ("Friend assembly `" + a.GetString () + "' is invalid. InternalsVisibleTo cannot have version or culture specified."); - else if (aname.GetPublicKey () == null && Name.GetPublicKey () != null) { + else if (aname.GetPublicKey () == null && Name.GetPublicKey () != null && Name.GetPublicKey ().Length != 0) { Report.Error (1726, a.Location, "Friend assembly reference `" + aname.FullName + "' is invalid." + " Strong named assemblies must specify a public key in their InternalsVisibleTo declarations"); return false; @@ -1248,19 +1191,40 @@ namespace Mono.CSharp { return true; } -#endif - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder customBuilder) + static bool IsValidAssemblyVersion (string version) + { + Version v; + try { + v = new Version (version); + } catch { + try { + int major = int.Parse (version, CultureInfo.InvariantCulture); + v = new Version (major, 0); + } catch { + return false; + } + } + + foreach (int candidate in new int [] { v.Major, v.Minor, v.Build, v.Revision }) { + if (candidate > ushort.MaxValue) + return false; + } + + return true; + } + + public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa) { - if (a.Type.IsSubclassOf (TypeManager.security_attr_type) && a.CheckSecurityActionValidity (true)) { + if (a.IsValidSecurityAttribute ()) { if (declarative_security == null) - declarative_security = new ListDictionary (); + declarative_security = new Dictionary (); a.ExtractSecurityPermissionSet (declarative_security); return; } - if (a.Type == TypeManager.assembly_culture_attribute_type) { + if (a.Type == pa.AssemblyCulture) { string value = a.GetString (); if (value == null || value.Length == 0) return; @@ -1271,29 +1235,41 @@ namespace Mono.CSharp { } } -#if GMCS_SOURCE - if (a.Type == TypeManager.internals_visible_attr_type && !CheckInternalsVisibleAttribute (a)) + if (a.Type == pa.AssemblyVersion) { + string value = a.GetString (); + if (value == null || value.Length == 0) + return; + + value = value.Replace ('*', '0'); + + if (!IsValidAssemblyVersion (value)) { + a.Error_AttributeEmitError (string.Format ("Specified version `{0}' is not valid", value)); + return; + } + } + + if (a.Type == pa.InternalsVisibleTo && !CheckInternalsVisibleAttribute (a)) return; - if (a.Type == TypeManager.type_forwarder_attr_type) { - Type t = a.GetArgumentType (); + if (a.Type == pa.TypeForwarder) { + TypeSpec t = a.GetArgumentType (); if (t == null || TypeManager.HasElementType (t)) { Report.Error (735, a.Location, "Invalid type specified as an argument for TypeForwardedTo attribute"); return; } if (emitted_forwarders == null) { - emitted_forwarders = new ListDictionary(); - } else if (emitted_forwarders.Contains(t)) { - Report.SymbolRelatedToPreviousError(((Attribute)emitted_forwarders[t]).Location, null); + emitted_forwarders = new Dictionary (); + } else if (emitted_forwarders.ContainsKey (t.MemberDefinition)) { + Report.SymbolRelatedToPreviousError(emitted_forwarders[t.MemberDefinition].Location, null); Report.Error(739, a.Location, "A duplicate type forward of type `{0}'", TypeManager.CSharpName(t)); return; } - emitted_forwarders.Add(t, a); + emitted_forwarders.Add(t.MemberDefinition, a); - if (TypeManager.LookupDeclSpace (t) != null) { + if (t.Assembly == Builder) { Report.SymbolRelatedToPreviousError (t); Report.Error (729, a.Location, "Cannot forward type `{0}' because it is defined in this assembly", TypeManager.CSharpName (t)); @@ -1306,11 +1282,6 @@ namespace Mono.CSharp { return; } - if (t.IsGenericType) { - Report.Error (733, a.Location, "Cannot forward generic type `{0}'", TypeManager.CSharpName (t)); - return; - } - if (add_type_forwarder == null) { add_type_forwarder = typeof (AssemblyBuilder).GetMethod ("AddTypeForwarder", BindingFlags.NonPublic | BindingFlags.Instance); @@ -1321,38 +1292,36 @@ namespace Mono.CSharp { } } - add_type_forwarder.Invoke (Builder, new object[] { t }); + add_type_forwarder.Invoke (Builder, new object[] { t.GetMetaInfo () }); return; } - if (a.Type == TypeManager.extension_attribute_type) { + if (a.Type == pa.Extension) { a.Error_MisusedExtensionAttribute (); return; } -#endif - Builder.SetCustomAttribute (customBuilder); + + Builder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), cdata); } public override void Emit (TypeContainer tc) { base.Emit (tc); -#if GMCS_SOURCE if (has_extension_method) - Builder.SetCustomAttribute (TypeManager.extension_attribute_attr); + PredefinedAttributes.Get.Extension.EmitAttribute (Builder); // FIXME: Does this belong inside SRE.AssemblyBuilder instead? - if (OptAttributes == null || !OptAttributes.Contains (TypeManager.runtime_compatibility_attr_type)) { - ConstructorInfo ci = TypeManager.GetConstructor ( - TypeManager.runtime_compatibility_attr_type, Type.EmptyTypes); + PredefinedAttribute pa = PredefinedAttributes.Get.RuntimeCompatibility; + if (pa.IsDefined && (OptAttributes == null || !OptAttributes.Contains (pa))) { + var ci = TypeManager.GetPredefinedConstructor (pa.Type, Location.Null, TypeSpec.EmptyTypes); PropertyInfo [] pis = new PropertyInfo [1]; - pis [0] = TypeManager.GetProperty ( - TypeManager.runtime_compatibility_attr_type, "WrapNonExceptionThrows"); + pis [0] = TypeManager.GetPredefinedProperty (pa.Type, + "WrapNonExceptionThrows", Location.Null, TypeManager.bool_type).MetaInfo; object [] pargs = new object [1]; pargs [0] = true; - Builder.SetCustomAttribute (new CustomAttributeBuilder (ci, new object [0], pis, pargs)); + Builder.SetCustomAttribute (new CustomAttributeBuilder ((ConstructorInfo) ci.GetMetaInfo (), new object[0], pis, pargs)); } -#endif if (declarative_security != null) { @@ -1362,16 +1331,17 @@ namespace Mono.CSharp { try { // Microsoft runtime hacking if (add_permission == null) { - Type assembly_builder = typeof (AssemblyBuilder).Assembly.GetType ("System.Reflection.Emit.AssemblyBuilderData"); + var assembly_builder = typeof (AssemblyBuilder).Assembly.GetType ("System.Reflection.Emit.AssemblyBuilderData"); add_permission = assembly_builder.GetMethod ("AddPermissionRequests", BindingFlags.Instance | BindingFlags.NonPublic); FieldInfo fi = typeof (AssemblyBuilder).GetField ("m_assemblyData", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField); builder_instance = fi.GetValue (Builder); } - object[] args = new object [] { declarative_security [SecurityAction.RequestMinimum], - declarative_security [SecurityAction.RequestOptional], - declarative_security [SecurityAction.RequestRefuse] }; + var args = new PermissionSet [3]; + declarative_security.TryGetValue (SecurityAction.RequestMinimum, out args [0]); + declarative_security.TryGetValue (SecurityAction.RequestOptional, out args [1]); + declarative_security.TryGetValue (SecurityAction.RequestRefuse, out args [2]); add_permission.Invoke (builder_instance, args); } catch { @@ -1410,109 +1380,4 @@ namespace Mono.CSharp { } } } - - public class ModuleClass : CommonAssemblyModulClass { - // TODO: make it private and move all builder based methods here - public ModuleBuilder Builder; - bool m_module_is_unsafe; - bool has_default_charset; - - public CharSet DefaultCharSet = CharSet.Ansi; - public TypeAttributes DefaultCharSetType = TypeAttributes.AnsiClass; - - static string[] attribute_targets = new string [] { "module" }; - - public ModuleClass (bool is_unsafe) - { - m_module_is_unsafe = is_unsafe; - } - - public override AttributeTargets AttributeTargets { - get { - return AttributeTargets.Module; - } - } - - public override bool IsClsComplianceRequired () - { - return CodeGen.Assembly.IsClsCompliant; - } - - public override void Emit (TypeContainer tc) - { - base.Emit (tc); - - if (!m_module_is_unsafe) - return; - - if (TypeManager.unverifiable_code_ctor == null) { - Console.WriteLine ("Internal error ! Cannot set unverifiable code attribute."); - return; - } - - Builder.SetCustomAttribute (new CustomAttributeBuilder (TypeManager.unverifiable_code_ctor, new object [0])); - } - - public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder customBuilder) - { - if (a.Type == TypeManager.cls_compliant_attribute_type) { - if (CodeGen.Assembly.ClsCompliantAttribute == null) { - Report.Warning (3012, 1, a.Location, "You must specify the CLSCompliant attribute on the assembly, not the module, to enable CLS compliance checking"); - } - else if (CodeGen.Assembly.IsClsCompliant != a.GetBoolean ()) { - Report.SymbolRelatedToPreviousError (CodeGen.Assembly.ClsCompliantAttribute.Location, CodeGen.Assembly.ClsCompliantAttribute.GetSignatureForError ()); - Report.Error (3017, a.Location, "You cannot specify the CLSCompliant attribute on a module that differs from the CLSCompliant attribute on the assembly"); - return; - } - } - - Builder.SetCustomAttribute (customBuilder); - } - - public bool HasDefaultCharSet { - get { - return has_default_charset; - } - } - - /// - /// It is called very early therefore can resolve only predefined attributes - /// - public void Resolve () - { -#if GMCS_SOURCE - if (OptAttributes == null) - return; - - if (!OptAttributes.CheckTargets()) - return; - - Attribute a = ResolveAttribute (TypeManager.default_charset_type); - if (a != null) { - has_default_charset = true; - DefaultCharSet = a.GetCharSetValue (); - switch (DefaultCharSet) { - case CharSet.Ansi: - case CharSet.None: - break; - case CharSet.Auto: - DefaultCharSetType = TypeAttributes.AutoClass; - break; - case CharSet.Unicode: - DefaultCharSetType = TypeAttributes.UnicodeClass; - break; - default: - Report.Error (1724, a.Location, "Value specified for the argument to 'System.Runtime.InteropServices.DefaultCharSetAttribute' is not valid"); - break; - } - } -#endif - } - - public override string[] ValidAttributeTargets { - get { - return attribute_targets; - } - } - } }