X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fsymbolwriter.cs;h=5159f73d0bfa97257b8ddbb4a305a6a7123db94b;hb=2d23bfcbce7a3f7e54dcd5911adb88b244baca35;hp=b42b0e2dd72ea647b72bf24743528ff3469ce67d;hpb=da4f9e9b2afb23791029d0bb09d78b868aabd870;p=mono.git

diff --git a/mcs/mcs/symbolwriter.cs b/mcs/mcs/symbolwriter.cs
index b42b0e2dd72..5159f73d0bf 100644
--- a/mcs/mcs/symbolwriter.cs
+++ b/mcs/mcs/symbolwriter.cs
@@ -4,101 +4,262 @@
 // Author:
 //   Martin Baulig (martin@ximian.com)
 //
-// (C) 2003 Ximian, Inc.
+// Copyright 2003 Ximian, Inc.
+// Copyright 2003-2008 Novell, Inc.
 //
 
 using System;
-using System.Collections;
 using System.Reflection;
 using System.Reflection.Emit;
 
 using Mono.CompilerServices.SymbolWriter;
 
 namespace Mono.CSharp {
-	public class SymbolWriter : MonoSymbolWriter {
-		delegate int GetILOffsetFunc (ILGenerator ig);
-		delegate Guid GetGuidFunc (ModuleBuilder mb);
+	public static class SymbolWriter
+	{
+		public static bool HasSymbolWriter {
+			get { return symwriter != null; }
+		}
+
+		private static SymbolWriterImpl symwriter;
+
+		class SymbolWriterImpl : MonoSymbolWriter {
+#if !NET_4_0
+			delegate int GetILOffsetFunc (ILGenerator ig);
+			GetILOffsetFunc get_il_offset_func;
+#endif
+			delegate Guid GetGuidFunc (ModuleBuilder mb);
+
+			GetGuidFunc get_guid_func;
+
+			ModuleBuilder module_builder;
+
+			public SymbolWriterImpl (ModuleBuilder module_builder, string filename)
+				: base (filename)
+			{
+				this.module_builder = module_builder;
+			}
+
+			public int GetILOffset (ILGenerator ig)
+			{
+#if NET_4_0
+				return ig.ILOffset;
+#else
+				return get_il_offset_func (ig);
+#endif
+			}
+
+			public void WriteSymbolFile ()
+			{
+				Guid guid = get_guid_func (module_builder);
+				WriteSymbolFile (guid);
+			}
 
-		GetILOffsetFunc get_il_offset_func;
-		GetGuidFunc get_guid_func;
+			public bool Initialize ()
+			{
+				MethodInfo mi;
+#if !NET_4_0
+				mi = typeof (ILGenerator).GetMethod (
+					"Mono_GetCurrentOffset",
+					BindingFlags.Static | BindingFlags.NonPublic);
+				if (mi == null)
+					return false;
 
-		ModuleBuilder module_builder;
+				get_il_offset_func = (GetILOffsetFunc) System.Delegate.CreateDelegate (
+					typeof (GetILOffsetFunc), mi);
+#endif
 
-		protected SymbolWriter (ModuleBuilder module_builder, string filename)
-			: base (filename)
+				mi = typeof (ModuleBuilder).GetMethod (
+					"Mono_GetGuid",
+					BindingFlags.Static | BindingFlags.NonPublic);
+				if (mi == null)
+					return false;
+
+				get_guid_func = (GetGuidFunc) System.Delegate.CreateDelegate (
+					typeof (GetGuidFunc), mi);
+
+				Location.DefineSymbolDocuments (this);
+
+				return true;
+			}
+		}
+
+		public static void DefineLocalVariable (string name, LocalBuilder builder)
 		{
-			this.module_builder = module_builder;
+			if (symwriter != null) {
+				int index = MonoDebuggerSupport.GetLocalIndex (builder);
+				symwriter.DefineLocalVariable (index, name);
+			}
 		}
 
-		bool Initialize ()
+		public static SourceMethodBuilder OpenMethod (ICompileUnit file, int ns_id,
+							      IMethodDef method)
 		{
-			MethodInfo mi = typeof (ILGenerator).GetMethod (
-				"Mono_GetCurrentOffset",
-				BindingFlags.Static | BindingFlags.NonPublic);
-			if (mi == null)
-				return false;
+			if (symwriter != null)
+				return symwriter.OpenMethod (file, ns_id, method);
+			else
+				return null;
+		}
 
-			get_il_offset_func = (GetILOffsetFunc) System.Delegate.CreateDelegate (
-				typeof (GetILOffsetFunc), mi);
+		public static void CloseMethod ()
+		{
+			if (symwriter != null)
+				symwriter.CloseMethod ();
+		}
 
-			mi = typeof (ModuleBuilder).GetMethod (
-				"Mono_GetGuid",
-				BindingFlags.Static | BindingFlags.NonPublic);
-			if (mi == null)
-				return false;
+		public static int OpenScope (ILGenerator ig)
+		{
+			if (symwriter != null) {
+				int offset = symwriter.GetILOffset (ig);
+				return symwriter.OpenScope (offset);
+			} else {
+				return -1;
+			}
+		}
+
+		public static void CloseScope (ILGenerator ig)
+		{
+			if (symwriter != null) {
+				int offset = symwriter.GetILOffset (ig);
+				symwriter.CloseScope (offset);
+			}
+		}
 
-			get_guid_func = (GetGuidFunc) System.Delegate.CreateDelegate (
-				typeof (GetGuidFunc), mi);
+		public static int DefineNamespace (string name, CompileUnitEntry source,
+						   string[] using_clauses, int parent)
+		{
+			if (symwriter != null)
+				return symwriter.DefineNamespace (name, source, using_clauses, parent);
+			else
+				return -1;
+		}
 
-			Location.DefineSymbolDocuments (this);
+#region Terrania additions
+		public static void DefineAnonymousScope (int id)
+		{
+			if (symwriter != null)
+				symwriter.DefineAnonymousScope (id);
+		}
 
-			return true;
+		public static void DefineScopeVariable (int scope, LocalBuilder builder)
+		{
+			if (symwriter != null) {
+				int index = MonoDebuggerSupport.GetLocalIndex (builder);
+				symwriter.DefineScopeVariable (scope, index);
+			}
 		}
 
-		public void DefineLocalVariable (string name, LocalBuilder builder)
+		public static void DefineScopeVariable (int scope)
 		{
-			SignatureHelper sighelper = SignatureHelper.GetLocalVarSigHelper (
-				module_builder);
-			sighelper.AddArgument (builder.LocalType);
-			byte[] signature = sighelper.GetSignature ();
+			if (symwriter != null)
+				symwriter.DefineScopeVariable (scope, -1);
+		}
 
-			int index = MonoDebuggerSupport.GetLocalIndex (builder);
+		public static void DefineCapturedLocal (int scope_id, string name,
+							string captured_name)
+		{
+			if (symwriter != null)
+				symwriter.DefineCapturedLocal (scope_id, name, captured_name);
+		}
 
-			DefineLocalVariable (index, name, signature);
+		public static void DefineCapturedParameter (int scope_id, string name,
+							    string captured_name)
+		{
+			if (symwriter != null)
+				symwriter.DefineCapturedParameter (scope_id, name, captured_name);
 		}
 
-		public int OpenScope (ILGenerator ig)
+		public static void DefineCapturedThis (int scope_id, string captured_name)
 		{
-			int offset = get_il_offset_func (ig);
-			return OpenScope (offset);
+			if (symwriter != null)
+				symwriter.DefineCapturedThis (scope_id, captured_name);
 		}
 
-		public void CloseScope (ILGenerator ig)
+		public static void DefineCapturedScope (int scope_id, int id, string captured_name)
 		{
-			int offset = get_il_offset_func (ig);
-			CloseScope (offset);
+			if (symwriter != null)
+				symwriter.DefineCapturedScope (scope_id, id, captured_name);
 		}
 
-		public void MarkSequencePoint (ILGenerator ig, int row, int column)
+		public static void OpenCompilerGeneratedBlock (EmitContext ec)
 		{
-			int offset = get_il_offset_func (ig);
-			MarkSequencePoint (offset, row, column);
+			if (symwriter != null) {
+				int offset = symwriter.GetILOffset (ec.ig);
+				symwriter.OpenCompilerGeneratedBlock (offset);
+			}
 		}
 
-		public void WriteSymbolFile ()
+		public static void CloseCompilerGeneratedBlock (EmitContext ec)
 		{
-			Guid guid = get_guid_func (module_builder);
-			WriteSymbolFile (guid);
+			if (symwriter != null) {
+				int offset = symwriter.GetILOffset (ec.ig);
+				symwriter.CloseCompilerGeneratedBlock (offset);
+			}
 		}
 
-		public static SymbolWriter GetSymbolWriter (ModuleBuilder module,
-							    string filename)
+		public static void StartIteratorBody (EmitContext ec)
 		{
-			SymbolWriter writer = new SymbolWriter (module, filename);
-			if (!writer.Initialize ())
-				return null;
+			if (symwriter != null) {
+				int offset = symwriter.GetILOffset (ec.ig);
+				symwriter.StartIteratorBody (offset);
+			}
+		}
 
-			return writer;
+		public static void EndIteratorBody (EmitContext ec)
+		{
+			if (symwriter != null) {
+				int offset = symwriter.GetILOffset (ec.ig);
+				symwriter.EndIteratorBody (offset);
+			}
+		}
+
+		public static void StartIteratorDispatcher (EmitContext ec)
+		{
+			if (symwriter != null) {
+				int offset = symwriter.GetILOffset (ec.ig);
+				symwriter.StartIteratorDispatcher (offset);
+			}
+		}
+
+		public static void EndIteratorDispatcher (EmitContext ec)
+		{
+			if (symwriter != null) {
+				int offset = symwriter.GetILOffset (ec.ig);
+				symwriter.EndIteratorDispatcher (offset);
+			}
+		}
+#endregion
+
+		public static void MarkSequencePoint (ILGenerator ig, Location loc)
+		{
+			if (symwriter != null) {
+				SourceFileEntry file = loc.SourceFile.SourceFileEntry;
+				int offset = symwriter.GetILOffset (ig);
+				symwriter.MarkSequencePoint (
+					offset, file, loc.Row, loc.Column, loc.Hidden);
+			}
+		}
+
+		public static void WriteSymbolFile ()
+		{
+			if (symwriter != null)
+				symwriter.WriteSymbolFile ();
+		}
+
+		public static bool Initialize (ModuleBuilder module, string filename)
+		{
+			symwriter = new SymbolWriterImpl (module, filename);
+			if (!symwriter.Initialize ()) {
+				symwriter = null;
+				return false;
+			}
+
+			return true;
+		}
+
+		public static void Reset ()
+		{
+			symwriter = null;
 		}
 	}
 }