#define VERBOSE_DEBUG
using System;
using System.Collections.Generic;
using System.Diagnostics.SymbolStore;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using Indy.IL2CPU.Assembler;
using Indy.IL2CPU.Assembler.X86;
using Indy.IL2CPU.IL;
using Microsoft.Samples.Debugging.CorSymbolStore;

namespace Indy.IL2CPU.Compiler
{
    public partial class CompilerHelper
    {
//        public CompilerHelper()
//        {
//            SkipList=new List<Assembly>();
//        }
//        public List<Assembly> SkipList
//        {
//            get;
//            set;
//        }

//        /// <summary>
//        /// first parameter tells which assembly this assembler is for. second param tells whether it's the entrypoint assembly
//        /// </summary>
//        public event Func<Assembly, bool, Assembler.Assembler> GetAssembler;
//        public event Action<Assembly, Assembler.Assembler> SaveAssembler;
//        public event Func<OpCodeMap> GetOpCodeMap;
//        public event Action<LogSeverityEnum, string> DebugLog;

//        private Dictionary<Assembly, AssemblyCompilationInfo> mAssemblyInfos =
//            new Dictionary<Assembly, AssemblyCompilationInfo>();

//        // does based on instances is unique?
//        private List<MethodBase> mAllMethods = new List<MethodBase>();
//        private int mNextMethodToScan = 0;
//        private List<FieldInfo> mAllStaticFields= new List<FieldInfo>();

//        public List<string> Plugs = new List<string>();
//        public DebugMode DebugMode;
//        public TraceAssemblies TraceAssemblies;

//        private Assembly mEntryPointAssembly;
//        private OpCodeMap mCurrentMap;
//        public void CompileExe(Assembly aAssembly)
//        {
//            mEntryPointAssembly = aAssembly;
//            Initialize();
//            // add standard methods (mainly the entry point)
//            AddStandardMethods();
//            ScanMethods();
//            foreach(var xAsmInfo in mAssemblyInfos.Values)
//            {
//                CompileAssembly(xAsmInfo);
//            }
//        }

//        private void CompileAssembly(AssemblyCompilationInfo info)
//        {
//            using(var xCurrentAssembler = GetAssembler(info.Assembly, info.Assembly == mEntryPointAssembly))
//            {
//                mCurrentAssemblyCompilationInfo = info;
//                try
//                {
//                    // emit the methods. 
//                    foreach (var xMethod in info.Methods.Values)
//                    {
//                        CompileMethod(xMethod, xCurrentAssembler);
//                    }

//                    // emit the fields
//                    foreach (var xField in info.StaticFields.Values)
//                    {
//                        CompileStaticField(xField, xCurrentAssembler);
//                    }

//                    // emit the method and type id data members
//                    foreach (var xIdMember in info.IDLabels)
//                    {
//                        xCurrentAssembler.DataMembers.Add(new DataMember(xIdMember, new int[1]));
//                    }

//                    // emit externals
//                    foreach (var xExternal in info.Externals)
//                    {
//                        new ExternalLabel(xExternal);
//                    }

//                    // todo: implement string init method, vmt init methods, cctor calling method, etc
//                    SaveAssembler(info.Assembly, xCurrentAssembler);
//                }finally
//                {
//                    mCurrentAssemblyCompilationInfo = null;
//                }
//            }
//        }

//        private void CompileStaticField(FieldInfo aField, Assembler.Assembler aAssembler)
//        {
//            //ProgressChanged.Invoke(String.Format("Processing static field: {0}", xCurrentField.GetFullName()));
//            string xFieldName = aField.GetFullName();
//            xFieldName = DataMember.GetStaticFieldName(aField);
//            if (aAssembler.DataMembers.Count(x => x.Name == xFieldName) == 0)
//            {
//                var xItemList = (from item in aField.GetCustomAttributes(false)
//                                 where item.GetType().FullName == "ManifestResourceStreamAttribute"
//                                 select item).ToList();

//                object xItem = null;
//                if (xItemList.Count > 0)
//                    xItem = xItemList[0];
//                string xManifestResourceName = null;
//                if (xItem != null)
//                {
//                    var xItemType = xItem.GetType();
//                    xManifestResourceName = (string)xItemType.GetField("ResourceName").GetValue(xItem);
//                }
//                if (xManifestResourceName != null)
//                {
//                    //RegisterType(xCurrentField.FieldType);
//                    //string xFileName = Path.Combine(mOutputDir,
//                    //                                (xCurrentField.DeclaringType.Assembly.FullName + "__" + xManifestResourceName).Replace(",",
//                    //                                                                                                                       "_") + ".res");
//                    //using (var xStream = xCurrentField.DeclaringType.Assembly.GetManifestResourceStream(xManifestResourceName)) {
//                    //    if (xStream == null) {
//                    //        throw new Exception("Resource '" + xManifestResourceName + "' not found!");
//                    //    }
//                    //    using (var xTarget = File.Create(xFileName)) {
//                    //        // todo: abstract this array code out.
//                    //        xTarget.Write(BitConverter.GetBytes(Engine.RegisterType(Engine.GetType("mscorlib",
//                    //                                                                               "System.Array"))),
//                    //                      0,
//                    //                      4);
//                    //        xTarget.Write(BitConverter.GetBytes((uint)InstanceTypeEnum.StaticEmbeddedArray),
//                    //                      0,
//                    //                      4);
//                    //        xTarget.Write(BitConverter.GetBytes((int)xStream.Length), 0, 4);
//                    //        xTarget.Write(BitConverter.GetBytes((int)1), 0, 4);
//                    //        var xBuff = new byte[128];
//                    //        while (xStream.Position < xStream.Length) {
//                    //            int xBytesRead = xStream.Read(xBuff, 0, 128);
//                    //            xTarget.Write(xBuff, 0, xBytesRead);
//                    //        }
//                    //    }
//                    //}
//                    //mAssembler.DataMembers.Add(new DataMember("___" + xFieldName + "___Contents",
//                    //                                          "incbin",
//                    //                                          "\"" + xFileName + "\""));
//                    //mAssembler.DataMembers.Add(new DataMember(xFieldName,
//                    //                                          "dd",
//                    //                                          "___" + xFieldName + "___Contents"));
//                    throw new NotImplementedException();
//                }
//                else
//                {
//                    uint xTheSize;
//                    //string theType = "db";
//                    Type xFieldTypeDef = aField.FieldType;
//                    if (!xFieldTypeDef.IsClass || xFieldTypeDef.IsValueType)
//                    {
//                        xTheSize = SizeOfType(aField.FieldType);
//                    }
//                    else
//                    {
//                        xTheSize = 4;
//                    }
//                    var xData = new byte[xTheSize];
//                    try
//                    {
//                        object xValue = aField.GetValue(null);
//                        if (xValue != null)
//                        {
//                            try
//                            {
//                                xData = new byte[xTheSize];
//                                if (xValue.GetType().IsValueType)
//                                {
//                                    for (int x = 0; x < xTheSize; x++)
//                                    {
//                                        xData[x] = Marshal.ReadByte(xValue,
//                                                                    x);
//                                    }
//                                }
//                            }
//                            catch
//                            {
//                            }
//                        }
//                    }
//                    catch
//                    {
//                    }
//                    aAssembler.DataMembers.Add(new DataMember(xFieldName, xData));
//                }
//            }
//        }

//        private void CompileMethod(MethodBase xCurrentMethod, Assembler.Assembler assembler)
//        {
//            try
//            {
//                if (xCurrentMethod.IsAbstract)
//                {
//                    return;
//                }
//                string xMethodName = Label.GetFullName(xCurrentMethod);
//                TypeInformation xTypeInfo = null;
//                if (!xCurrentMethod.IsStatic)
//                {
//                    xTypeInfo = GetTypeInfo(xCurrentMethod.DeclaringType);
//                }
//                var xMethodScanInfo = new SortedList<string, object>(StringComparer.InvariantCultureIgnoreCase);
//                MethodInformation xMethodInfo = GetMethodInfo(xCurrentMethod, xCurrentMethod
//                                                              , xMethodName, xTypeInfo, DebugMode != DebugMode.None,
//                                                              xMethodScanInfo);

//                Op xOp = GetOpFromType(mCurrentMap.MethodHeaderOp, null, xMethodInfo);
//                xOp.Assembler = assembler;
//#if VERBOSE_DEBUG
//                    string comment = "(No Type Info available)";
//                    if (xMethodInfo.TypeInfo != null)
//                    {
//                        comment = "Type Info:\r\n \r\n" + xMethodInfo.TypeInfo;
//                    }
//                    foreach (string s in comment.Trim().Split(new string[] { "\r\n" }
//                     , StringSplitOptions.RemoveEmptyEntries))
//                    {
//                        new Comment(s);
//                    }
//                    comment = xMethodInfo.ToString();
//                    foreach (string s in comment.Trim().Split(new string[] { "\r\n" }
//                     , StringSplitOptions.RemoveEmptyEntries))
//                    {
//                        new Comment(s);
//                    }
//#endif
//                xOp.Assemble();
//                MethodBase xCustomImplementation = GetCustomMethodImplementation(xMethodName);
//                bool xIsCustomImplementation = (xCustomImplementation != null);
//                // what to do if a method doesn't have a body?
//                bool xContentProduced = false;
//                if (xIsCustomImplementation)
//                {
//                    // this is for the support for having extra fields on types, and being able to use
//                    // them in custom implementation methods
//                    CustomMethodImplementationProxyOp xProxyOp
//                        = (CustomMethodImplementationProxyOp) GetOpFromType(
//                                                                  mCurrentMap.CustomMethodImplementationProxyOp, null,
//                                                                  xMethodInfo);
//                    xProxyOp.Assembler = assembler;
//                    xProxyOp.ProxiedMethod = xCustomImplementation;
//                    xProxyOp.Assemble();
//                    xContentProduced = true;
//                }
//                if (!xContentProduced)
//                {
//                    Type xOpType = mCurrentMap.GetOpForCustomMethodImplementation(xMethodName);
//                    if (xOpType != null)
//                    {
//                        Op xMethodOp = GetOpFromType(xOpType, null, xMethodInfo);
//                        if (xMethodOp != null)
//                        {
//                            xMethodOp.Assembler = assembler;
//                            xMethodOp.Assemble();
//                            xContentProduced = true;
//                        }
//                    }
//                }
//                if (!xContentProduced)
//                {
//                    if (mCurrentMap.HasCustomAssembleImplementation(xMethodInfo))
//                    {
//                        mCurrentMap.DoCustomAssembleImplementation(assembler, xMethodInfo);
//                        // No plugs, we need to compile the IL from the method
//                    }
//                    else
//                    {
//                        MethodBody xBody = xCurrentMethod.GetMethodBody();
//                        // todo: add better detection of implementation state
//                        if (xBody != null)
//                        {
//                            assembler.StackContents.Clear();
//                            var xReader = new ILReader(xCurrentMethod);
//                            #region let instructions prepare themselves
//                            while(xReader.Read())
//                            {
//                                mCurrentMap.ScanILCode(xReader, xMethodInfo, xMethodScanInfo);
//                            }
//                            #endregion
//                            xReader.Restart();
//                            var xInstructionInfos = new List<DebugSymbolsAssemblyTypeMethodInstruction>();

//                            // Section currently is dead code. Working on matching it up 
//                            // with contents from inside the read
//                            int[] xCodeOffsets = null;
//                            if (DebugMode == DebugMode.Source)
//                            {
//                                var xSymbolReader = GetSymbolReaderForAssembly(xCurrentMethod.DeclaringType.Assembly);
//                                if (xSymbolReader != null)
//                                {
//                                    var xSmbMethod =
//                                        xSymbolReader.GetMethod(new SymbolToken(xCurrentMethod.MetadataToken));
//                                    // This gets the Sequence Points.
//                                    // Sequence Points are spots that identify what the compiler/debugger says is a spot
//                                    // that a breakpoint can occur one. Essentially, an atomic source line in C#
//                                    if (xSmbMethod != null)
//                                    {
//                                        xCodeOffsets = new int[xSmbMethod.SequencePointCount];
//                                        var xCodeDocuments = new ISymbolDocument[xSmbMethod.SequencePointCount];
//                                        var xCodeLines = new int[xSmbMethod.SequencePointCount];
//                                        var xCodeColumns = new int[xSmbMethod.SequencePointCount];
//                                        var xCodeEndLines = new int[xSmbMethod.SequencePointCount];
//                                        var xCodeEndColumns = new int[xSmbMethod.SequencePointCount];
//                                        xSmbMethod.GetSequencePoints(xCodeOffsets, xCodeDocuments
//                                                                     , xCodeLines, xCodeColumns, xCodeEndLines,
//                                                                     xCodeEndColumns);
//                                    }
//                                }
//                            }

//                            // Scan each IL op in the method
//                            while (xReader.Read())
//                            {
//                                ExceptionHandlingClause xCurrentHandler = null;

//                                #region Exception handling support code

//                                // todo: add support for nested handlers using a stack or so..
//                                foreach (ExceptionHandlingClause xHandler in xBody.ExceptionHandlingClauses)
//                                {
//                                    if (xHandler.TryOffset > 0)
//                                    {
//                                        if (xHandler.TryOffset <= xReader.NextPosition &&
//                                            (xHandler.TryLength + xHandler.TryOffset) > xReader.NextPosition)
//                                        {
//                                            if (xCurrentHandler == null)
//                                            {
//                                                xCurrentHandler = xHandler;
//                                                continue;
//                                            }
//                                            else if (xHandler.TryOffset > xCurrentHandler.TryOffset &&
//                                                     (xHandler.TryLength + xHandler.TryOffset) <
//                                                     (xCurrentHandler.TryLength + xCurrentHandler.TryOffset))
//                                            {
//                                                // only replace if the current found handler is narrower
//                                                xCurrentHandler = xHandler;
//                                                continue;
//                                            }
//                                        }
//                                    }
//                                    if (xHandler.HandlerOffset > 0)
//                                    {
//                                        if (xHandler.HandlerOffset <= xReader.NextPosition &&
//                                            (xHandler.HandlerOffset + xHandler.HandlerLength) > xReader.NextPosition)
//                                        {
//                                            if (xCurrentHandler == null)
//                                            {
//                                                xCurrentHandler = xHandler;
//                                                continue;
//                                            }
//                                            else if (xHandler.HandlerOffset > xCurrentHandler.HandlerOffset &&
//                                                     (xHandler.HandlerOffset + xHandler.HandlerLength) <
//                                                     (xCurrentHandler.HandlerOffset + xCurrentHandler.HandlerLength))
//                                            {
//                                                // only replace if the current found handler is narrower
//                                                xCurrentHandler = xHandler;
//                                                continue;
//                                            }
//                                        }
//                                    }
//                                    if ((xHandler.Flags & ExceptionHandlingClauseOptions.Filter) > 0)
//                                    {
//                                        if (xHandler.FilterOffset > 0)
//                                        {
//                                            if (xHandler.FilterOffset <= xReader.NextPosition)
//                                            {
//                                                if (xCurrentHandler == null)
//                                                {
//                                                    xCurrentHandler = xHandler;
//                                                    continue;
//                                                }
//                                                else if (xHandler.FilterOffset > xCurrentHandler.FilterOffset)
//                                                {
//                                                    // only replace if the current found handler is narrower
//                                                    xCurrentHandler = xHandler;
//                                                    continue;
//                                                }
//                                            }
//                                        }
//                                    }
//                                }

//                                #endregion

//                                xMethodInfo.CurrentHandler = xCurrentHandler;
//                                xOp = GetOpFromType(mCurrentMap.GetOpForOpCode(xReader.OpCode), xReader, xMethodInfo);

//                                xOp.Assembler = assembler;
//                                new Comment("StackItems = " + assembler.StackContents.Count);
//                                foreach (var xStackContent in assembler.StackContents)
//                                {
//                                    new Comment("    " + xStackContent.Size);
//                                }

//                                // Create label for current point
//                                string xLabel = Op.GetInstructionLabel(xReader);
//                                if (xLabel.StartsWith("."))
//                                {
//                                    xLabel = DataMember.FilterStringForIncorrectChars(
//                                        Label.LastFullLabel + "__DOT__" + xLabel.Substring(1));
//                                }

//                                // Possibly emit Tracer call
//                                EmitTracer(xOp, xCurrentMethod.DeclaringType.Namespace, (int) xReader.Position,
//                                           xCodeOffsets, xLabel, assembler);

//                                if (mSymbols != null)
//                                {
//                                    var xMLSymbol = new MLDebugSymbol();
//                                    xMLSymbol.LabelName = xLabel;
//                                    int xStackSize = (from item in assembler.StackContents
//                                                      let xSize = (item.Size%4 == 0)
//                                                                      ? item.Size
//                                                                      : (item.Size + (4 - (item.Size%4)))
//                                                      select xSize).Sum();
//                                    xMLSymbol.StackDifference = xMethodInfo.LocalsSize + xStackSize;
//                                    try
//                                    {
//                                        xMLSymbol.AssemblyFile = xCurrentMethod.DeclaringType.Assembly.Location;
//                                    }
//                                    catch (NotSupportedException)
//                                    {
//                                        xMLSymbol.AssemblyFile = "DYNAMIC: " +
//                                                                 xCurrentMethod.DeclaringType.Assembly.FullName;
//                                    }
//                                    xMLSymbol.MethodToken = xCurrentMethod.MetadataToken;
//                                    xMLSymbol.TypeToken = xCurrentMethod.DeclaringType.MetadataToken;
//                                    xMLSymbol.ILOffset = (int) xReader.Position;
//                                    mSymbols.Add(xMLSymbol);
//                                }
//                                xOp.Assemble();
//                                //if (xInstructionInfo != null) {
//                                //    int xNewStack = (from item in mAssembler.StackContents
//                                //                     let xSize = (item.Size % 4 == 0) ? item.Size : (item.Size + (4 - (item.Size % 4)))
//                                //                     select xSize).Sum();
//                                //    xInstructionInfo.StackResult = xNewStack - xCurrentStack;
//                                //    xInstructionInfo.StackResultSpecified = true;
//                                //    xInstructionInfos.Add(xInstructionInfo);
//                                //}
//                            }
//                            if (mSymbols != null)
//                            {
//                                MLDebugSymbol[] xSymbols;
//                                xSymbols = mSymbols.ToArray();
//                            }
//                        }
//                        else
//                        {
//                            if ((xCurrentMethod.Attributes & MethodAttributes.PinvokeImpl) != 0)
//                            {
//                                LogMessage(LogSeverityEnum.Error,
//                                           "Method '{0}' not generated!",
//                                           xCurrentMethod.GetFullName());
//                                new Comment("Method not being generated yet, as it's handled by a PInvoke");
//                            }
//                            else
//                            {
//                                LogMessage(LogSeverityEnum.Error,
//                                           "Method '{0}' not generated!",
//                                           xCurrentMethod.GetFullName());
//                                new Comment("Method not being generated yet, as it's handled by an iCall");
//                            }
//                        }
//                    }
//                }
//                xOp = GetOpFromType(mCurrentMap.MethodFooterOp, null, xMethodInfo);
//                xOp.Assembler = assembler;
//                xOp.Assemble();
//                assembler.StackContents.Clear();
//            }
//            catch (Exception e)
//            {
//                LogMessage(LogSeverityEnum.Error, xCurrentMethod.GetFullName());
//                LogMessage(LogSeverityEnum.Warning, e.ToString());
//                throw;
//            }
//        }

//        private 
            
            
//            void Initialize()
//        {
//            mCurrentMap = GetOpCodeMap();
//            InitializePlugs(Plugs);
//            mCurrentMap.SetServiceProvider(this);
//            mCurrentMap.Initialize(new[] { mEntryPointAssembly });
//        }

//        private void CheckAssemblyForPlugAssemblies(Assembly aAssembly)
//        {
//            //If in the GAC, then ignore assembly
//            if (aAssembly.GlobalAssemblyCache)
//            {
//                return;
//            }

//            // todo: implement this again
//            // todo: try to get rid of the try..catch. find a way to detect dynamic assemblies.
//            try
//            {
//                //Search for related .config file
//                //string configFile = String.Intern(aAssembly.Location + ".cosmos-config");
//                //if (System.IO.File.Exists(configFile))
//                //{
//                //    //Load and parse all PlugAssemblies referred to in the .config file
//                //    foreach (Assembly xAssembly in GetAssembliesFromConfigFile(configFile))
//                //    {
//                //        LoadPlugAssembly(xAssembly);
//                //    }
//                //}
//            }
//            catch
//            {
//            }
//        }


//        private void InitializePlugs(IEnumerable<string> aPlugs)
//        {
//            if (mPlugMethods != null)
//            {
//                throw new Exception("PlugMethods list already initialized!");
//            }
//            if (mPlugFields != null)
//            {
//                throw new Exception("PlugFields list already initialized!");
//            }

//            mPlugMethods = new SortedList<string, MethodBase>();
//            mPlugFields = new SortedList<Type, Dictionary<string, PlugFieldAttribute>>(new TypeComparer());

//            //AppDomain.CurrentDomain.AssemblyLoad += CurrentDomain_AssemblyLoad;
//            //AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
//            foreach (var xAsm in AppDomain.CurrentDomain.GetAssemblies())
//            {
//                CheckAssemblyForPlugAssemblies(xAsm);
//            }
//            List<Assembly> xPlugs = new List<Assembly>();
//            var xComparer = new AssemblyEqualityComparer();

//            foreach (string s in aPlugs)
//            {
//                Assembly a = Assembly.LoadFrom(s);
//                a.GetTypes();
//                if (!xPlugs.Contains(a,
//                                     xComparer))
//                {
//                    xPlugs.Add(a);
//                }
//            }

//            foreach (var item in GetPlugAssemblies())
//            {
//                if (!xPlugs.Contains(item,
//                                     xComparer))
//                {
//                    xPlugs.Add(item);
//                }
//            }

//            foreach (Assembly xAssemblyDef in xPlugs)
//            {
//                LoadPlugAssembly(xAssemblyDef);
//            }
//        }

//        private IList<Assembly> GetPlugAssemblies()
//        {
//            var xResult = mCurrentMap.GetPlugAssemblies();
//            xResult.Add(typeof(CompilerHelper).Assembly);
//            return xResult;
//        }

//        public readonly bool RunningOnMono;

//        private void LoadPlugAssembly(Assembly aAssemblyDef)
//        {
//            foreach (var xType in (from item in aAssemblyDef.GetTypes()
//                                   let xCustomAttribs = item.GetCustomAttributes(typeof(PlugAttribute),
//                                                                                 false)
//                                   where xCustomAttribs != null && xCustomAttribs.Length > 0
//                                   select new KeyValuePair<Type, PlugAttribute>(item,
//                                                                                (PlugAttribute)xCustomAttribs[0])))
//            {
//                PlugAttribute xPlugAttrib = xType.Value;
//                if (xPlugAttrib.IsMonoOnly && !RunningOnMono)
//                {
//                    continue;
//                }
//                if (xPlugAttrib.IsMicrosoftdotNETOnly && RunningOnMono)
//                {
//                    continue;
//                }
//                Type xTypeRef = xPlugAttrib.Target;
//                if (xTypeRef == null)
//                {
//                    xTypeRef = Type.GetType(xPlugAttrib.TargetName,
//                                            true);
//                }

//                PlugFieldAttribute[] xTypePlugFields = xType.Key.GetCustomAttributes(typeof(PlugFieldAttribute),
//                                                                                     false) as PlugFieldAttribute[];
//                if (xTypePlugFields != null && xTypePlugFields.Length > 0)
//                {
//                    Dictionary<string, PlugFieldAttribute> xPlugFields;
//                    if (mPlugFields.ContainsKey(xTypeRef))
//                    {
//                        xPlugFields = mPlugFields[xTypeRef];
//                    }
//                    else
//                    {
//                        mPlugFields.Add(xTypeRef,
//                                        xPlugFields = new Dictionary<string, PlugFieldAttribute>());
//                    }
//                    foreach (var xPlugField in xTypePlugFields)
//                    {
//                        if (xPlugAttrib.IsMonoOnly && !RunningOnMono)
//                        {
//                            continue;
//                        }
//                        if (xPlugAttrib.IsMicrosoftdotNETOnly && RunningOnMono)
//                        {
//                            continue;
//                        }
//                        if (!xPlugFields.ContainsKey(xPlugField.FieldId))
//                        {
//                            xPlugFields.Add(xPlugField.FieldId,
//                                            xPlugField);
//                        }
//                    }
//                }

//                foreach (MethodBase xMethod in xType.Key.GetMethods(BindingFlags.Public | BindingFlags.Static))
//                {
//                    PlugMethodAttribute xPlugMethodAttrib = xMethod.GetCustomAttributes(typeof(PlugMethodAttribute),
//                                                                                        true).Cast<PlugMethodAttribute>().FirstOrDefault();
//                    string xSignature = String.Empty;
//                    if (xPlugMethodAttrib != null)
//                    {
//                        xSignature = xPlugMethodAttrib.Signature;
//                        if (!xPlugMethodAttrib.Enabled)
//                        {
//                            continue;
//                        }
//                        if (xPlugAttrib.IsMonoOnly && !RunningOnMono)
//                        {
//                            continue;
//                        }
//                        if (xPlugAttrib.IsMicrosoftdotNETOnly && RunningOnMono)
//                        {
//                            continue;
//                        }
//                        if (!String.IsNullOrEmpty(xSignature))
//                        {
//                            if (!mPlugMethods.ContainsKey(xSignature))
//                            {
//                                mPlugMethods.Add(xSignature,
//                                                 xMethod);
//                            }
//                            continue;
//                        }
//                    }
//                    foreach (MethodBase xOrigMethodDef in xTypeRef.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic))
//                    {
//                        string xStrippedSignature = GetStrippedMethodBaseFullName(xMethod,
//                                                                                  xOrigMethodDef);
//                        string xOrigStrippedSignature = GetStrippedMethodBaseFullName(xOrigMethodDef,
//                                                                                      null);
//                        if (xOrigStrippedSignature == xStrippedSignature)
//                        {
//                            if (!mPlugMethods.ContainsKey(MethodInfoLabelGenerator.GenerateLabelName(xOrigMethodDef)))
//                            {
//                                mPlugMethods.Add(MethodInfoLabelGenerator.GenerateLabelName(xOrigMethodDef),
//                                                 xMethod);
//                            }
//                        }
//                    }
//                    foreach (MethodBase xOrigMethodDef in xTypeRef.GetConstructors(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic))
//                    {
//                        string xStrippedSignature = GetStrippedMethodBaseFullName(xMethod,
//                                                                                  xOrigMethodDef);
//                        string xOrigStrippedSignature = GetStrippedMethodBaseFullName(xOrigMethodDef,
//                                                                                      null);
//                        if (xOrigStrippedSignature == xStrippedSignature)
//                        {
//                            if (mPlugMethods.ContainsKey(MethodInfoLabelGenerator.GenerateLabelName(xOrigMethodDef)))
//                            {
//                                System.Diagnostics.Debugger.Break();
//                            }
//                            mPlugMethods.Add(MethodInfoLabelGenerator.GenerateLabelName(xOrigMethodDef),
//                                             xMethod);
//                        }
//                    }
//                }
//            }
//        }

//        private void ScanMethods()
//        {
//            int xOldCount = 0;
//            do
//            {
//                xOldCount = mAllMethods.Count;
//                ScanMethods_OnePass();
//            } while (xOldCount != mAllMethods.Count);
            
//        }


//        private IDictionary<string, MethodBase> mPlugMethods;
//        private IDictionary<Type, Dictionary<string, PlugFieldAttribute>> mPlugFields;
//        private AssemblyCompilationInfo mCurrentAssemblyCompilationInfo = null;

//        /// <summary>
//        ///  contains the code for scanning for new methods, but just one pass.
//        /// </summary>
//        private void ScanMethods_OnePass()
//        {
//            var xEmptyDict = new Dictionary<string, object>();
//            for (int i = mNextMethodToScan; i < mAllMethods.Count; i++)
//            {
//                var xCurrentMethod = mAllMethods[i];
//                if (xCurrentMethod.IsAbstract)
//                {
//                    continue;
//                }
//                if(!mAssemblyInfos.TryGetValue(xCurrentMethod.DeclaringType.Assembly, out mCurrentAssemblyCompilationInfo))
//                {
//                    mCurrentAssemblyCompilationInfo = new AssemblyCompilationInfo
//                                                          {Assembly = xCurrentMethod.DeclaringType.Assembly};
//                    mAssemblyInfos.Add(mCurrentAssemblyCompilationInfo.Assembly, mCurrentAssemblyCompilationInfo);
//                }
//                try
//                {
//                    string xMethodName = Label.GetFullName(xCurrentMethod);
//                    TypeInformation xTypeInfo = null;
//                    if (!xCurrentMethod.IsStatic)
//                    {
//                        xTypeInfo = GetTypeInfo(xCurrentMethod.DeclaringType);
//                    }
//                    MethodInformation xMethodInfo;
//                    // using (mMethodsLocker.AcquireReaderLock())
//                    {
//                        xEmptyDict.Clear();
//                        xMethodInfo = GetMethodInfo(xCurrentMethod,
//                                                    xCurrentMethod,
//                                                    xMethodName,
//                                                    xTypeInfo,
//                                                    false, // debug mode
//                                                    xEmptyDict);
//                    }
//                    MethodBase xCustomImplementation = GetCustomMethodImplementation(xMethodName);
//                    if (xCustomImplementation != null)
//                    {
//                        try
//                        {
//                            AddMethod(xCustomImplementation);
//                        }
//                        catch (Exception e)
//                        {
//                            throw new Exception("Method " + xCurrentMethod.GetFullName() + " has called " + e.Message +
//                                                "! Probably it needs to be plugged");
//                        }
//                        //   using (mMethodsLocker.AcquireReaderLock())
//                        //{
//                        //    mMethods[xCurrentMethod].Implementation = xCustomImplementation;
//                        //}
//                        continue;
//                    }
//                    Type xOpType = mCurrentMap.GetOpForCustomMethodImplementation(xMethodName);
//                    if (xOpType != null)
//                    {
//                        Op xMethodOp = GetOpFromType(xOpType, null, xMethodInfo);
//                        if (xMethodOp != null)
//                        {
//                            continue;
//                        }
//                    }
//                    if (mCurrentMap.HasCustomAssembleImplementation(xMethodInfo))
//                    {
//                        mCurrentMap.ScanCustomAssembleImplementation(xMethodInfo);
//                        continue;
//                    }

//                    //xCurrentMethod.GetMethodImplementationFlags() == MethodImplAttributes.
//                    MethodBody xBody = xCurrentMethod.GetMethodBody();
//                    // todo: add better detection of implementation state
//                    if (xBody != null)
//                    {
//                        ILReader xReader = new ILReader(xCurrentMethod);
//                        var xInstructionInfos = new List<DebugSymbolsAssemblyTypeMethodInstruction>();
//                        while (xReader.Read())
//                        {
//                            SortedList<string, object> xInfo = new SortedList<string, object>();
//                            // using (mMethodsLocker.AcquireReaderLock())
//                            //{
//                            //    xInfo = mMethods[xCurrentMethod].Info;
//                            //}
//                            mCurrentMap.ScanILCode(xReader, xMethodInfo, xInfo);
//                            switch (xReader.OpCode)
//                            {
//                                case OpCodeEnum.Call:
//                                case OpCodeEnum.Callvirt:
//                                case OpCodeEnum.Newobj:
//                                case OpCodeEnum.Ldftn:
//                                    AddMethod(xReader.OperandValueMethod);
//                                    break;
//                                case OpCodeEnum.Initobj:
//                                case OpCodeEnum.Ldelema:
//                                    //Add(xReader.OperandValueType);
//                                    break;
//                                case OpCodeEnum.Stsfld:
//                                case OpCodeEnum.Ldsfld:
//                                case OpCodeEnum.Ldsflda:
//                                    AddStaticField(xReader.OperandValueField);
//                                    break;
//                                case OpCodeEnum.Ldtoken:
//                                    if (xReader.OperandValueType != null)
//                                    {
//                                        //RegisterType(xReader.OperandValueType);
//                                        break;
//                                    }
//                                    if (xReader.OperandValueField != null)
//                                    {
//                                        AddStaticField(xReader.OperandValueField);
//                                        break;
//                                    }
//                                    break;
//                            }
//                        }
//                    }
//                }
//                finally
//                {
//                    mCurrentAssemblyCompilationInfo = null;
//                }
//            }
//            mNextMethodToScan = mAllMethods.Count;
//        }

//        private Op GetOpFromType(Type aType, ILReader aReader, MethodInformation aMethodInfo)
//        {
//            var xResult = (Op)Activator.CreateInstance(aType, aReader, aMethodInfo);
//            xResult.SetServiceProvider(this);
//            return xResult;
//        }

//        private MethodBase GetCustomMethodImplementation(string aMethodName)
//        {
//            if (mPlugMethods.ContainsKey(aMethodName))
//            {
//                return mPlugMethods[aMethodName];
//            }
//            return null;
//        }

//        private void AddMethod(MethodBase aMethod)
//        {
//            if ((from item in mAllMethods
//                 where item.GetFullName() == aMethod.GetFullName()
//                 select item).Any())
//            {
//                return;
//            }
//            mAllMethods.Add(aMethod);
//            AssemblyCompilationInfo xAsmCompileInfo;
//            if (!mAssemblyInfos.TryGetValue(aMethod.DeclaringType.Assembly, out xAsmCompileInfo))
//            {
//                mAssemblyInfos.Add(aMethod.DeclaringType.Assembly,
//                                   xAsmCompileInfo=new AssemblyCompilationInfo {Assembly = aMethod.DeclaringType.Assembly});
//            }
//            xAsmCompileInfo.AddMethod(aMethod);
//        }


        
//        private void AddStaticField(FieldInfo aField)
//        {
//            if (mAllStaticFields.Contains(aField))
//            {
//                return;
//            }
//            mAllStaticFields.Add(aField);
//            AssemblyCompilationInfo xAsmCompileInfo;
//            if (!mAssemblyInfos.TryGetValue(aField.DeclaringType.Assembly, out xAsmCompileInfo))
//            {
//                mAssemblyInfos.Add(aField.DeclaringType.Assembly,
//                                   xAsmCompileInfo = new AssemblyCompilationInfo { Assembly = aField.DeclaringType.Assembly });
//            }
//            xAsmCompileInfo.AddStaticField(aField);
//        }

//        private void AddStandardMethods()
//        {
//            AddMethod(mEntryPointAssembly.EntryPoint.DeclaringType.GetMethod("Init", new Type[0]));
//            AddMethod(RuntimeEngineRefs.InitializeApplicationRef);
//            AddMethod(RuntimeEngineRefs.FinalizeApplicationRef);
//            AddMethod(typeof(Assembler.Assembler).GetMethod("PrintException"));
//            AddMethod(VTablesImplRefs.LoadTypeTableRef);
//            AddMethod(VTablesImplRefs.SetMethodInfoRef);
//            AddMethod(VTablesImplRefs.IsInstanceRef);
//            AddMethod(VTablesImplRefs.SetTypeInfoRef);
//            AddMethod(VTablesImplRefs.GetMethodAddressForTypeRef);
//            AddMethod(GCImplementationRefs.IncRefCountRef);
//            AddMethod(GCImplementationRefs.DecRefCountRef);
//            AddMethod(GCImplementationRefs.AllocNewObjectRef);
        
//        }

//        private static string GetStrippedMethodBaseFullName(MethodBase aMethod,
//                                                    MethodBase aRefMethod)
//        {
//            StringBuilder xBuilder = new StringBuilder(256);
//            string[] xParts = aMethod.ToString().Split(' ');
//            string[] xParts2 = xParts.Skip(1).ToArray();
//            MethodInfo xMethodInfo = aMethod as MethodInfo;
//            if (xMethodInfo != null)
//            {
//                xBuilder.Append(xMethodInfo.ReturnType.FullName);
//            }
//            else
//            {
//                if (aMethod is ConstructorInfo)
//                {
//                    xBuilder.Append(typeof(void).FullName);
//                }
//                else
//                {
//                    xBuilder.Append(xParts[0]);
//                }
//            }
//            xBuilder.Append("  ");
//            xBuilder.Append(".");
//            xBuilder.Append(aMethod.Name);
//            xBuilder.Append("(");
//            ParameterInfo[] xParams = aMethod.GetParameters();
//            bool xParamAdded = false;
//            for (int i = 0; i < xParams.Length; i++)
//            {
//                if (i == 0 && (aRefMethod != null && !aRefMethod.IsStatic))
//                {
//                    continue;
//                }
//                if (xParams[i].IsDefined(typeof(FieldAccessAttribute), true))
//                {
//                    continue;
//                }
//                if (xParamAdded)
//                {
//                    xBuilder.Append(", ");
//                }
//                xBuilder.Append(xParams[i].ParameterType.FullName);
//                xParamAdded = true;
//            }
//            xBuilder.Append(")");
//            return String.Intern(xBuilder.ToString());
//        }

//        private ISymbolReader GetSymbolReaderForAssembly(Assembly aAssembly)
//        {
//            try
//            {
//                return SymbolAccess.GetReaderForFile(aAssembly.Location);
//            }
//            catch (NotSupportedException)
//            {
//                return null;
//            }
//        }

//        protected void EmitTracer(Op aOp, string aNamespace, int aPos, int[] aCodeOffsets, string aLabel, Assembler.Assembler aAssembler)
//        {
//            // NOTE - These if statemens can be optimized down - but clarity is
//            // more importnat the optimizations would not offer much benefit

//            // Determine if a new DebugStub should be emitted
//            //bool xEmit = false;
//            // Skip NOOP's so we dont have breakpoints on them
//            //TODO: Each IL op should exist in IL, and descendants in IL.X86.
//            // Because of this we have this hack
//            if (aOp.ToString() == "Indy.IL2CPU.IL.X86.Nop")
//            {
//                return;
//            }
//            else if (DebugMode == DebugMode.None)
//            {
//                return;
//            }
//            else if (DebugMode == DebugMode.Source)
//            {
//                // If the current position equals one of the offsets, then we have
//                // reached a new atomic C# statement
//                if (aCodeOffsets != null)
//                {
//                    if (aCodeOffsets.Contains(aPos) == false)
//                    {
//                        return;
//                    }
//                }
//            }

//            // Check options for Debug Level
//            // Set based on TracedAssemblies
//            if (TraceAssemblies == TraceAssemblies.Cosmos || TraceAssemblies == TraceAssemblies.User)
//            {
//                if (aNamespace.StartsWith("System.", StringComparison.InvariantCultureIgnoreCase))
//                {
//                    return;
//                }
//                else if (aNamespace.ToLower() == "system")
//                {
//                    return;
//                }
//                else if (aNamespace.StartsWith("Microsoft.", StringComparison.InvariantCultureIgnoreCase))
//                {
//                    return;
//                }
//            }
//            if (TraceAssemblies == TraceAssemblies.User)
//            {
//                //TODO: Maybe an attribute that could be used to turn tracing on and off
//                //TODO: This doesnt match Cosmos.Kernel exact vs Cosmos.Kernel., so a user 
//                // could do Cosmos.KernelMine and it will fail. Need to fix this
//                if (aNamespace.StartsWith("Cosmos.Kernel", StringComparison.InvariantCultureIgnoreCase))
//                {
//                    return;
//                }
//                else if (aNamespace.StartsWith("Cosmos.Sys", StringComparison.InvariantCultureIgnoreCase))
//                {
//                    return;
//                }
//                else if (aNamespace.StartsWith("Cosmos.Hardware", StringComparison.InvariantCultureIgnoreCase))
//                {
//                    return;
//                }
//                else if (aNamespace.StartsWith("Indy.IL2CPU", StringComparison.InvariantCultureIgnoreCase))
//                {
//                    return;
//                }
//            }
//            // If we made it this far, emit the Tracer
//            mCurrentMap.EmitOpDebugHeader(aAssembler, 0, aLabel);
//        }

//        private List<MLDebugSymbol> mSymbols = new List<MLDebugSymbol>();

    }
}