internal PdbWriter(ISymbolWriter writer, ModuleDefinition module, string pdb)
 {
     m_writer = writer;
     m_module = module;
     m_documents = new Hashtable ();
     m_pdb = pdb;
 }

 internal void EmitLineNumberInfo(ISymbolWriter symWriter)
 {
     for (int i = 0; i < this.m_DocumentCount; i++)
     {
         this.m_Documents[i].EmitLineNumberInfo(symWriter);
     }
 }

 /// <summary>
 /// </summary>
 /// <param name="filename">
 /// </param>
 public static void Convert(string filename, ISymbolWriter symbolWriter)
 {
     using (var stream = File.OpenRead(filename))
     {
         var funcs = PdbFile.LoadFunctions(stream, true);
         Convert(funcs, symbolWriter);
     }
 }

 /// <summary>
 /// </summary>
 /// <param name="filename">
 /// </param>
 /// <param name="symbolWriter">
 /// </param>
 internal Converter(string filename, ISymbolWriter symbolWriter)
 {
     this.symbolWriter = symbolWriter;
     using (var stream = File.OpenRead(filename))
     {
         foreach (var pdbFunc in PdbFile.LoadFunctions(stream, true))
         {
             funcs[pdbFunc.token] = pdbFunc;
         }
     }
 }

 internal virtual void EmitLocalSymInfo(ISymbolWriter symWriter)
 {
     int num;
     for (num = 0; num < this.m_iLocalSymCount; num++)
     {
         symWriter.DefineLocalVariable(this.m_strName[num], FieldAttributes.PrivateScope, this.m_ubSignature[num], SymAddressKind.ILOffset, this.m_iLocalSlot[num], 0, 0, this.m_iStartOffset[num], this.m_iEndOffset[num]);
     }
     for (num = 0; num < this.m_iNameSpaceCount; num++)
     {
         symWriter.UsingNamespace(this.m_namespace[num]);
     }
 }

 internal void EmitLineNumberInfo(ISymbolWriter symWriter)
 {
     if (this.m_iLineNumberCount != 0)
     {
         int[] destinationArray = new int[this.m_iLineNumberCount];
         Array.Copy(this.m_iOffsets, destinationArray, this.m_iLineNumberCount);
         int[] numArray2 = new int[this.m_iLineNumberCount];
         Array.Copy(this.m_iLines, numArray2, this.m_iLineNumberCount);
         int[] numArray3 = new int[this.m_iLineNumberCount];
         Array.Copy(this.m_iColumns, numArray3, this.m_iLineNumberCount);
         int[] numArray4 = new int[this.m_iLineNumberCount];
         Array.Copy(this.m_iEndLines, numArray4, this.m_iLineNumberCount);
         int[] numArray5 = new int[this.m_iLineNumberCount];
         Array.Copy(this.m_iEndColumns, numArray5, this.m_iLineNumberCount);
         symWriter.DefineSequencePoints(this.m_document, destinationArray, numArray2, numArray3, numArray4, numArray5);
     }
 }

 internal void EmitScopeTree(ISymbolWriter symWriter)
 {
     for (int i = 0; i < this.m_iCount; i++)
     {
         if (this.m_ScopeActions[i] == ScopeAction.Open)
         {
             symWriter.OpenScope(this.m_iOffsets[i]);
         }
         else
         {
             symWriter.CloseScope(this.m_iOffsets[i]);
         }
         if (this.m_localSymInfos[i] != null)
         {
             this.m_localSymInfos[i].EmitLocalSymInfo(symWriter);
         }
     }
 }

		internal void GenerateDebugInfo (ISymbolWriter symbolWriter)
		{
			if (ilgen != null && ilgen.HasDebugInfo) {
				SymbolToken token = new SymbolToken (GetToken().Token);
				symbolWriter.OpenMethod (token);
				symbolWriter.SetSymAttribute (token, "__name", System.Text.Encoding.UTF8.GetBytes (Name));
				ilgen.GenerateDebugInfo (symbolWriter);
				symbolWriter.CloseMethod ();
			}
		}

		internal void GenerateDebugInfo (ISymbolWriter symbolWriter)
		{
			symbolWriter.OpenNamespace (this.Namespace);

			if (methods != null) {
				for (int i = 0; i < num_methods; ++i) {
					MethodBuilder metb = (MethodBuilder) methods[i]; 
					metb.GenerateDebugInfo (symbolWriter);
				}
			}

			if (ctors != null) {
				foreach (ConstructorBuilder ctor in ctors)
					ctor.GenerateDebugInfo (symbolWriter);
			}
			
			symbolWriter.CloseNamespace ();

			if (subtypes != null) {
				for (int i = 0; i < subtypes.Length; ++i)
					subtypes [i].GenerateDebugInfo (symbolWriter);
			}
		}

		internal void GenerateDebugInfo (ISymbolWriter symbolWriter)
		{
			if (sequencePointLists != null) {
				SequencePointList first = (SequencePointList) sequencePointLists [0];
				SequencePointList last = (SequencePointList) sequencePointLists [sequencePointLists.Count - 1];
				symbolWriter.SetMethodSourceRange (first.Document, first.StartLine, first.StartColumn, last.Document, last.EndLine, last.EndColumn);
				
				foreach (SequencePointList list in sequencePointLists)
					symbolWriter.DefineSequencePoints (list.Document, list.GetOffsets(), list.GetLines(), list.GetColumns(), list.GetEndLines(), list.GetEndColumns());
				
				if (locals != null) {
					foreach (LocalBuilder local in locals) {
						if (local.Name != null && local.Name.Length > 0) {
							SignatureHelper sighelper = SignatureHelper.GetLocalVarSigHelper (module as ModuleBuilder);
							sighelper.AddArgument (local.LocalType);
							byte[] signature = sighelper.GetSignature ();
							symbolWriter.DefineLocalVariable (local.Name, FieldAttributes.Public, signature, SymAddressKind.ILOffset, local.position, 0, 0, local.StartOffset, local.EndOffset);
						}
					}
				}
				sequencePointLists = null;
			}
		}

		internal ModuleBuilder (AssemblyBuilder assb, string name, string fullyqname, bool emitSymbolInfo, bool transient) {
			this.name = this.scopename = name;
			this.fqname = fullyqname;
			this.assembly = this.assemblyb = assb;
			this.transient = transient;
			// to keep mcs fast we do not want CryptoConfig wo be involved to create the RNG
			guid = Guid.FastNewGuidArray ();
			// guid = Guid.NewGuid().ToByteArray ();
			table_idx = get_next_table_index (this, 0x00, true);
			name_cache = new Hashtable ();
			us_string_cache = new Dictionary<string, int> (512);

			basic_init (this);

			CreateGlobalType ();

			if (assb.IsRun) {
				TypeBuilder tb = new TypeBuilder (this, TypeAttributes.Abstract, 0xFFFFFF); /*last valid token*/
				Type type = tb.CreateType ();
				set_wrappers_type (this, type);
			}

			if (emitSymbolInfo) {
#if MOONLIGHT
				symbolWriter = new Mono.CompilerServices.SymbolWriter.SymbolWriterImpl (this);
#else
				Assembly asm = Assembly.LoadWithPartialName ("Mono.CompilerServices.SymbolWriter");
				if (asm == null)
					throw new TypeLoadException ("The assembly for default symbol writer cannot be loaded");

				Type t = asm.GetType ("Mono.CompilerServices.SymbolWriter.SymbolWriterImpl", true);
				symbolWriter = (ISymbolWriter) Activator.CreateInstance (t, new object[] { this });
#endif
				string fileName = fqname;
				if (assemblyb.AssemblyDir != null)
					fileName = Path.Combine (assemblyb.AssemblyDir, fileName);
				symbolWriter.Initialize (IntPtr.Zero, fileName, true);
			}
		}

        internal virtual void EmitLocalSymInfo(ISymbolWriter symWriter)
        {
            int         i;

            for (i = 0; i < m_iLocalSymCount; i ++)
            {
                symWriter.DefineLocalVariable(
                            m_strName[i],
                            FieldAttributes.PrivateScope,  
                            m_ubSignature[i],
                            SymAddressKind.ILOffset,
                            m_iLocalSlot[i],
                            0,          // addr2 is not used yet
                            0,          // addr3 is not used
                            m_iStartOffset[i],
                            m_iEndOffset[i]);
            }
            for (i = 0; i < m_iNameSpaceCount; i ++)
            {
                symWriter.UsingNamespace(m_namespace[i]);
            }
        }

        internal void Init(
            String             strModuleName,
            String             strFileName,
            ISymbolWriter      writer)
        {
            m_moduleData = new ModuleBuilderData(this, strModuleName, strFileName);
            m_TypeBuilderList = new ArrayList();    
            m_iSymWriter = writer;

            if (writer != null)
            {
                // Set the underlying writer for the managed writer
                // that we're using.  Note that this function requires
                // unmanaged code access.
                new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
                writer.SetUnderlyingWriter(m_pInternalSymWriter);
            }
        }

 internal void SetSymWriter(ISymbolWriter writer)
 {
     m_iSymWriter = writer;
 }

 public void SaveSymbols(string outputDirectory, ISymbolWriter writer)
 {
     SaveSymbols (outputDirectory);
     m_controller.Writer.SymbolWriter = writer;
 }

 public static IConverter GetConverter(string filename, ISymbolWriter symbolWriter)
 {
     return new Converter(filename, symbolWriter);
 }

		public PerformRewrite (ISymbolWriter sym, RewriterOptions options)
		{
			this.sym = sym;
			this.options = options;
		}

        [System.Security.SecurityCritical] // auto-generated
        #endif
        internal void EmitLineNumberInfo(ISymbolWriter symWriter)
        {
            int[]       iOffsetsTemp;
            int[]       iLinesTemp;
            int[]       iColumnsTemp;
            int[]       iEndLinesTemp;
            int[]       iEndColumnsTemp;

            if (m_iLineNumberCount == 0)
                return;
            // reduce the array size to be exact
            iOffsetsTemp = new int [m_iLineNumberCount];
            Array.Copy(m_iOffsets, iOffsetsTemp, m_iLineNumberCount);

            iLinesTemp = new int [m_iLineNumberCount];
            Array.Copy(m_iLines, iLinesTemp, m_iLineNumberCount);

            iColumnsTemp = new int [m_iLineNumberCount];
            Array.Copy(m_iColumns, iColumnsTemp, m_iLineNumberCount);

            iEndLinesTemp = new int [m_iLineNumberCount];
            Array.Copy(m_iEndLines, iEndLinesTemp, m_iLineNumberCount);

            iEndColumnsTemp = new int [m_iLineNumberCount];
            Array.Copy(m_iEndColumns, iEndColumnsTemp, m_iLineNumberCount);

            symWriter.DefineSequencePoints(m_document, iOffsetsTemp, iLinesTemp, iColumnsTemp, iEndLinesTemp, iEndColumnsTemp); 
        }

        /// <summary>
        /// </summary>
        /// <param name="symbolWriter">
        /// </param>
        /// <param name="function">
        /// </param>
        /// <returns>
        /// </returns>
        private SourceFile GetSourceFile(ISymbolWriter symbolWriter, PdbFunction function)
        {
            var name = (from l in function.lines where l.file != null select l.file.name).First();

            SourceFile file;
            if (this.files.TryGetValue(name, out file))
            {
                return file;
            }

            var entry = symbolWriter.DefineDocument(name);
            var unit = symbolWriter.DefineCompilationUnit(entry);

            file = new SourceFile(unit, entry);
            this.files.Add(name, file);
            return file;
        }

 internal void CreateSymWriter()
 {
     _symbolWriter = _myModule.GetSymWriter();
 }