internal SymVariable(ISymUnmanagedVariable variable)
        {
            // We should not wrap null instances
            if (variable == null)
                throw new ArgumentNullException("variable");

            m_unmanagedVariable = variable;
        }

 internal SymbolVariable(ISymUnmanagedVariable unmanagedVariable)
 {
     if (unmanagedVariable == null)
     {
         throw new ArgumentNullException("unmanagedVariable");
     }
     this.unmanagedVariable = unmanagedVariable;
 }

		public ISymbolVariable[] GetGlobalVariables() {
			uint numVars;
			reader.GetGlobalVariables(0, out numVars, null);
			var unVars = new ISymUnmanagedVariable[numVars];
			reader.GetGlobalVariables((uint)unVars.Length, out numVars, unVars);
			var vars = new ISymbolVariable[numVars];
			for (uint i = 0; i < numVars; i++)
				vars[i] = new SymbolVariable(unVars[i]);
			return vars;
		}

		public ISymbolVariable[] GetParameters() {
			uint numVars;
			method.GetParameters(0, out numVars, null);
			var unVars = new ISymUnmanagedVariable[numVars];
			method.GetParameters((uint)unVars.Length, out numVars, unVars);
			var vars = new ISymbolVariable[numVars];
			for (uint i = 0; i < numVars; i++)
				vars[i] = new SymbolVariable(unVars[i]);
			return vars;
		}

        public ISymbolVariable[] GetVariables()
        {
            int cVars = 0;
            uint i;
            m_unmanagedNamespace.GetVariables(0, out cVars, null);
            var unmanagedVariables = new ISymUnmanagedVariable[cVars];
            m_unmanagedNamespace.GetVariables(cVars, out cVars, unmanagedVariables);

            var Variables = new ISymbolVariable[cVars];
            for (i = 0; i < cVars; i++)
            {
                Variables[i] = new SymVariable(unmanagedVariables[i]);
            }
            return Variables;
        }

        internal override int GetLocals(int bufferLength, out int count, ISymUnmanagedVariable[] locals)
        {
            var mdReader = SymMethod.MetadataReader;
            var scope = mdReader.GetLocalScope(_handle);

            var handles = scope.GetLocalVariables();

            int i = 0;
            foreach (var handle in handles)
            {
                if (i >= bufferLength)
                {
                    break;
                }

                locals[i++] = new SymVariable(SymMethod, handle);
            }

            count = (bufferLength == 0) ? handles.Count : i;
            return HResult.S_OK;
        }

		public SymbolVariable(ISymUnmanagedVariable variable) {
			this.variable = variable;
		}

        //
        // Gather the local details in a scope and then recurse to child scopes
        //
        private void ProbeScopeForLocals(List<ILLocalVariable> variables, ISymUnmanagedScope scope)
        {
            int localCount;
            ThrowExceptionForHR(scope.GetLocalCount(out localCount));

            ISymUnmanagedVariable[] locals = new ISymUnmanagedVariable[localCount];
            ThrowExceptionForHR(scope.GetLocals(localCount, out localCount, locals));

            for (int i = 0; i < localCount; i++)
            {
                var local = locals[i];

                int slot;
                ThrowExceptionForHR(local.GetAddressField1(out slot));

                int nameLength;
                ThrowExceptionForHR(local.GetName(0, out nameLength, null));

                // nameLength includes terminating '\0'
                char[] nameBuffer = new char[nameLength];
                ThrowExceptionForHR(local.GetName(nameLength, out nameLength, nameBuffer));

                int attributes;
                ThrowExceptionForHR(local.GetAttributes(out attributes));

                variables.Add(new ILLocalVariable() { Slot = slot, Name = new String(nameBuffer, 0, nameLength - 1), CompilerGenerated = (attributes & 0x1) != 0 });
            }

            int childrenCount;
            ThrowExceptionForHR(scope.GetChildren(0, out childrenCount, null));

            ISymUnmanagedScope[] children = new ISymUnmanagedScope[childrenCount];
            ThrowExceptionForHR(scope.GetChildren(childrenCount, out childrenCount, children));

            for (int i = 0; i < childrenCount; i++)
            {
                ProbeScopeForLocals(variables, children[i]);
            }
        }

        public ISymbolVariable[] GetVariables(SymbolToken parent)
        {
            int cVars = 0;
            uint i;
            m_reader.GetVariables(parent, 0, out cVars, null);
            ISymUnmanagedVariable[] unmanagedVariables = new ISymUnmanagedVariable[cVars];
            m_reader.GetVariables(parent, cVars, out cVars, unmanagedVariables);
            SymVariable[] variables = new SymVariable[cVars];

            for (i = 0; i < cVars; i++)
            {
                variables[i] = new SymVariable(unmanagedVariables[i]);
            }
            return variables;
        }

 public int GetParameters(int cParams, out int pcParams, ISymUnmanagedVariable[] parms)
 {
     throw new NotImplementedException();
 }

		public ISymbolVariable[] GetVariables(SymbolToken parent) {
			uint numVars;
			reader.GetVariables((uint)parent.GetToken(), 0, out numVars, null);
			var unVars = new ISymUnmanagedVariable[numVars];
			reader.GetVariables((uint)parent.GetToken(), (uint)unVars.Length, out numVars, unVars);
			var vars = new ISymbolVariable[numVars];
			for (uint i = 0; i < numVars; i++)
				vars[i] = new SymbolVariable(unVars[i]);
			return vars;
		}

            static void _PrintLocals(ICorDebugILFrame ilframe, ISymUnmanagedScope unmScope, uint ip, System.IO.TextWriter writer)
            {
                int varcount;
                unmScope.GetLocalCount(out varcount);
                ISymUnmanagedVariable[] vars = new ISymUnmanagedVariable[varcount];
                unmScope.GetLocals(varcount, out varcount, vars);

                for (int iv = 0; iv < varcount; iv++)
                {
                    ISymUnmanagedVariable var = vars[iv];
                    string varname;
                    {
                        int namelen;
                        var.GetName(0, out namelen, null);
                        StringBuilder sbName = new StringBuilder(namelen);
                        var.GetName(sbName.Capacity, out namelen, sbName);
                        namelen--; // Remove nul.
                        sbName.Length = namelen;
                        varname = sbName.ToString();
                    }
                    string valstr;
                    {
                        int field1;
                        var.GetAddressField1(out field1);
                        ICorDebugValue pvalue;
                        ilframe.GetLocalVariable((uint)field1, out pvalue);
                        valstr = ToString(pvalue);
                    }
                    writer.WriteLine("{0}={1}", varname, valstr);
                }

                int cChildren;
                unmScope.GetChildren(0, out cChildren, null);
                ISymUnmanagedScope[] children = new ISymUnmanagedScope[cChildren];
                unmScope.GetChildren(children.Length, out cChildren, children);
                for (int ic = 0; ic < cChildren; ic++)
                {
                    _PrintLocals(ilframe, children[ic], ip, writer);
                }

            }

		public static ISymUnmanagedVariable[] GetLocals(this ISymUnmanagedScope symScope)
		{
			uint count;
			symScope.GetLocals(0, out count, new ISymUnmanagedVariable[0]);
			ISymUnmanagedVariable[] locals = new ISymUnmanagedVariable[count];
			symScope.GetLocals(count, out count, locals);
			return locals;
		}

        public ISymbolVariable[] GetLocals()
        {
            int count;
            m_target.GetLocals(0, out count, null);
            ISymUnmanagedVariable[] uVariables = new ISymUnmanagedVariable[count];
            m_target.GetLocals(count, out count, uVariables);

            int i;
            ISymbolVariable[] variables = new ISymbolVariable[count];
            for (i = 0; i < count; i++)
            {
                variables[i] = new SymVariable(uVariables[i]);
            }
            return variables;
        }

 internal override int GetLocals(int bufferLength, out int count, ISymUnmanagedVariable[] locals)
 {
     // C# and VB never define any locals in the root scope 
     count = 0;
     return HResult.S_OK;
 }

		public static void GetLocals(this ISymUnmanagedScope instance, uint cLocals, out uint pcLocals, ISymUnmanagedVariable[] locals)
		{
			instance.__GetLocals(cLocals, out pcLocals, locals);
			ProcessOutParameter(locals);
		}

        /// <summary>
        /// Emits scope debugging symbols based on <c>ISymUnmanagedScope</c> insatnce, representing
        /// scope from new assembly.
        /// </summary>
        /// <param name="smScope">Scope from new version of changed assembly.</param>
        /// <param name="placeholder">Placeholder translation for local variables.</param>
        public void EmitScope(ISymUnmanagedScope smScope, Dictionary<int, int> placeholder)
        {
            if(State != WriterState.Building){
                throw new TranslatingException("ISym* interfaces were not initialized.");
            }
            uint scStartOffset = smScope.__GetStartOffset();
            uint scEndOffset = smScope.__GetEndOffset();
            mWriter.OpenScope(scStartOffset);

            uint localsCount = smScope.__GetLocalCount();
            if(localsCount > 0){
                uint read;
                ISymUnmanagedVariable[] variables = new ISymUnmanagedVariable[localsCount];
                smScope.__GetLocals(localsCount,out read,variables);
                for (int i = 0; i < localsCount; i++) {
                    byte[] signature = variables[i].GetSignature();
                    Signature sig = new Signature(signature);
                    sig.Migrate(translator);
                    signature = sig.Compress();

                    string name = variables[i].GetName();
                    uint addr1 = 0;//variables[i].GetAddressField1();
                    uint addr2 = 0;//variables[i].GetAddressField2();
                    uint addr3 = 0;//variables[i].GetAddressField3();
                    uint addrKind = variables[i].GetAddressKind();//variables[i].GetAddressKind();
                    if((variables[i].GetAttributes() & 1) != 1)
                    {
                        addr1 = variables[i].GetAddressField1();
                        addrKind = variables[i].GetAddressKind();
                        if (placeholder != null && placeholder.ContainsKey((int)addr1))
                        {
                            addr1 = (uint)placeholder[(int)addr1];
                        }
                    }
                    uint varStartOffset = scStartOffset;
                    uint varEndOffset = scEndOffset;
                    uint attributes = variables[i].GetAttributes();

                    IntPtr pName = Marshal.StringToCoTaskMemUni(name);
                    IntPtr pSig = Marshal.AllocCoTaskMem(signature.Length);
                    Marshal.Copy(signature,0,pSig,signature.Length);

                    try{
                        mWriter.DefineLocalVariable(pName,attributes,(uint)signature.Length,pSig,addrKind,
                                                    addr1,addr2,addr3,varStartOffset,varEndOffset);
                    } finally {
                        Marshal.FreeCoTaskMem(pSig);
                        Marshal.FreeCoTaskMem(pName);
                    }
                }
            }
            ISymUnmanagedScope[] subScopes = smScope.GetChildren();
            foreach(ISymUnmanagedScope subScope in subScopes){
                EmitScope(subScope,placeholder);
            }
            mWriter.CloseScope(scEndOffset);
        }

 internal SymVariable(ISymUnmanagedVariable variable)
 {
     m_unmanagedVariable = variable;
 }

 public int GetGlobalVariables(int cVars, out int pcVars, ISymUnmanagedVariable[] vars)
 {
     throw new NotImplementedException();
 }

 public int GetLocals(int cLocals, out int pcLocals, ISymUnmanagedVariable[] locals)
 {
     return _scope.GetLocals(cLocals, out pcLocals, locals);
 }