public void Write(MethodBody body)
        {
            var method_token = body.Method.MetadataToken;
            var sym_token = new SymbolToken (method_token.ToInt32 ());

            var instructions = CollectInstructions (body);
            if (instructions.Count == 0 && !body.HasVariables)
                return;

            writer.OpenMethod (sym_token);

            DefineSequencePoints (instructions);

            if (body.Scope != null)
                WriteScope (body, body.Scope);
            else
            if (body.HasVariables)
            {
                var start_offset = 0;
                var end_offset = body.CodeSize;

                writer.OpenScope  (start_offset);
                DefineVariables   (body, body.Variables, start_offset, end_offset);
                writer.CloseScope (end_offset);
            }

            if (body.IteratorType != null)
                DefineIteratorType   (sym_token, body.IteratorType.Name);

            if (body.iterator_scopes != null)
                DefineIteratorScopes (sym_token, body.IteratorScopes, body.CodeSize);

            writer.CloseMethod ();
        }

		void CreateScopes (MethodBody body, ScopeCollection scopes, SymbolToken localVarToken)
		{
			foreach (Scope s in scopes) {
				int startOffset = s.Start.Offset;
				int endOffset = s.End == body.Instructions.Outside ?
					body.Instructions[body.Instructions.Count - 1].Offset + 1 :
					s.End.Offset;

				m_writer.OpenScope (startOffset);
				m_writer.UsingNamespace (body.Method.DeclaringType.Namespace);
				m_writer.OpenNamespace (body.Method.DeclaringType.Namespace);

				int start = body.Instructions.IndexOf (s.Start);
				int end = s.End == body.Instructions.Outside ?
					body.Instructions.Count - 1 :
					body.Instructions.IndexOf (s.End);

				ArrayList instructions = CollectSequencePoints (body, start, end);
				DefineSequencePoints (instructions);

				CreateLocalVariable (s, startOffset, endOffset, localVarToken);

				CreateScopes (body, s.Scopes, localVarToken);
				m_writer.CloseNamespace ();

				m_writer.CloseScope (endOffset);
			}
		}

		public ISymbolMethod GetMethod(SymbolToken method, int version) {
			ISymUnmanagedMethod unMethod;
			int hr = reader.GetMethodByVersion((uint)method.GetToken(), version, out unMethod);
			if (hr == E_FAIL)
				return null;
			Marshal.ThrowExceptionForHR(hr);
			return unMethod == null ? null : new SymbolMethod(unMethod);
		}

	public virtual void DefineField
				(SymbolToken parent, String name,
				 FieldAttributes attributes, 
				 byte[] signature, 
				 SymAddressKind addrKind, 
				 int addr1, int addr2, int addr3)
			{
				throw new NotSupportedException();
			}

 public int GetMethodByVersion(SymbolToken methodToken, int version, out ISymUnmanagedMethod retVal)
 {
     var hr = _reader.GetMethodByVersion(methodToken, version, out retVal);
     if (retVal != null)
     {
         retVal = new SymMethod(this, retVal);
     }
     return hr;
 }

        public void Write(MethodBody body)
        {
            var method_token = body.Method.MetadataToken;
            var sym_token = new SymbolToken (method_token.ToInt32 ());

            writer.OpenMethod (sym_token);
            DefineSequencePoints (body);
            DefineVariables (body);
            writer.CloseMethod ();
        }

 private ISymUnmanagedMethod GetSymMethod(SymbolToken token)
 {
     try
     {
         return _comReader.GetMethod(token);
     }
     catch
     {
         return null;
     }
 }

		public void DefineLocalVariable2 (string name,
										  FieldAttributes attributes,
										  SymbolToken sigToken,
										  SymAddressKind addrKind,
										  int addr1,
										  int addr2,
										  int addr3,
										  int startOffset,
										  int endOffset)
		{
			((ISymUnmanagedWriter2)m_writer).DefineLocalVariable2 (name, (int)attributes, sigToken, (int)addrKind, addr1, addr2, addr3, startOffset, endOffset);
		}

		void DefineVariables (MethodBody body, int start_offset, int end_offset)
		{
			if (!body.HasVariables)
				return;

			var sym_token = new SymbolToken (body.LocalVarToken.ToInt32 ());

			var variables = body.Variables;
			for (int i = 0; i < variables.Count; i++) {
				var variable = variables [i];
				CreateLocalVariable (variable, sym_token, start_offset, end_offset);
			}
		}

 void CreateLocalVariable(VariableDebugInformation variable, SymbolToken local_var_token, int start_offset, int end_offset)
 {
     writer.DefineLocalVariable2 (
         variable.Name,
         variable.Attributes,
         local_var_token,
         SymAddressKind.ILOffset,
         variable.Index,
         0,
         0,
         start_offset,
         end_offset);
 }

 public static ISymbolMethod GetSymReader(this MethodBase method)
 {
     var reader = method.Module.GetSymReader();
     if (reader == null)
     {
         return null;
     }
     else
     {
         var token = new SymbolToken(method.MetadataToken);
         return reader.GetMethod(token);
     }
 }

        public void Write(MethodDebugInformation info)
        {
            var method_token = info.method.MetadataToken;
            var sym_token = new SymbolToken (method_token.ToInt32 ());

            writer.OpenMethod (sym_token);

            if (!info.sequence_points.IsNullOrEmpty ())
                DefineSequencePoints (info.sequence_points);

            if (info.scope != null)
                DefineScope (info.scope, info);

            writer.CloseMethod ();
        }

		public void Write (MethodBody body)
		{
			var method_token = body.Method.MetadataToken;
			var sym_token = new SymbolToken (method_token.ToInt32 ());

			var instructions = CollectInstructions (body);
			if (instructions.Count == 0)
				return;

			var start_offset = 0;
			var end_offset = body.CodeSize;

			writer.OpenMethod (sym_token);
			writer.OpenScope (start_offset);

			DefineSequencePoints (instructions);
			DefineVariables (body, start_offset, end_offset);

			writer.CloseScope (end_offset);
			writer.CloseMethod ();
		}

        public bool TryGetFunctionByLocation(SourceLocation location, out SymbolToken token)
        {
            token = default(SymbolToken);

            try
            {
                var document = _comReader.GetDocument(location.FilePath.FullPath, default(Guid), default(Guid), default(Guid));
                if (document == null)
                    return false;

                var method = _comReader.GetMethodFromDocumentPosition(document, location.Line, location.Column);
                if (method == null)
                    return false;

                token = method.GetToken();
                return true;
            }
            catch (COMException)
            {
                return false;
            }
        }

 /// <include file='doc\SymWriter.uex' path='docs/doc[@for="SymbolWriter.OpenMethod"]/*' />
 public void OpenMethod(SymbolToken method)
 {
     m_target.OpenMethod(method);
 }

 /// <include file='doc\SymWriter.uex' path='docs/doc[@for="SymbolWriter.DefineLocalVariable1"]/*' />
 public void DefineLocalVariable([MarshalAs(UnmanagedType.LPWStr)] String name,
                                 int attributes,
                                 SymbolToken sigToken,
                                 int addressKind,
                                 int addr1,
                                 int addr2,
                                 int addr3,
                                 int startOffset,
                                 int endOffset)
 {
     ((ISymUnmanagedWriter2)m_target).DefineLocalVariable2(name, attributes, sigToken,
                                  addressKind, addr1, addr2, addr3, startOffset, endOffset);
 }

 /// <include file='doc\SymWriter.uex' path='docs/doc[@for="SymbolWriter.DefineField"]/*' />
 public void DefineField(SymbolToken parent,
                         String name,
                         FieldAttributes attributes,
                         byte[] signature,
                         SymAddressKind addressKind,
                         int addr1,
                         int addr2,
                         int addr3)
 {
     m_target.DefineField(parent, name, (int)attributes, signature.Length, signature,
                          (int)addressKind, addr1, addr2, addr3);
 }

 /// <include file='doc\SymWriter.uex' path='docs/doc[@for="SymbolWriter.DefineConstant1"]/*' />
 public void DefineConstant([MarshalAs(UnmanagedType.LPWStr)] String name,
                           Object value,
                           SymbolToken sigToken)
 {
     ((ISymUnmanagedWriter2)m_target).DefineConstant2(name, value, sigToken);
 }

		public void OpenMethod (SymbolToken method)
		{
			m_writer.OpenMethod (method);
		}

        void DefineIteratorType(SymbolToken method_token, string name)
        {
            var buffer = new PE.ByteBuffer ();
            buffer.WriteByte (4);
            buffer.WriteByte (1);
            buffer.Align     (4);
            buffer.WriteByte (4);
            buffer.WriteByte (4);
            buffer.Align	 (4);

            var length = 10 + (uint) name.Length * 2;
            while (length % 4 > 0)
                length++;

            buffer.WriteUInt32 (length);
            buffer.WriteBytes (System.Text.Encoding.Unicode.GetBytes (name));
            buffer.WriteByte (0);
            buffer.Align	 (4);

            writer.SetSymAttribute (method_token, "MD2", buffer.length, buffer.buffer);
        }