Don't print null on exit

[mono.git] / mcs / mcs / symbolwriter.cs

diff --git a/mcs/mcs/symbolwriter.cs b/mcs/mcs/symbolwriter.cs
index f5a3adff420d697a5caa6ca21a96ae682b4d6401..5159f73d0bfa97257b8ddbb4a305a6a7123db94b 100644 (file)
--- a/mcs/mcs/symbolwriter.cs
+++ b/mcs/mcs/symbolwriter.cs
@@ -4,11 +4,11 @@
 // 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;
 
@@ -23,11 +23,13 @@ namespace Mono.CSharp {
 
                private static SymbolWriterImpl symwriter;
 
-               protected class SymbolWriterImpl : MonoSymbolWriter {
+               class SymbolWriterImpl : MonoSymbolWriter {
+#if !NET_4_0
                        delegate int GetILOffsetFunc (ILGenerator ig);
+                       GetILOffsetFunc get_il_offset_func;
+#endif
                        delegate Guid GetGuidFunc (ModuleBuilder mb);
 
-                       GetILOffsetFunc get_il_offset_func;
                        GetGuidFunc get_guid_func;
 
                        ModuleBuilder module_builder;
@@ -40,7 +42,11 @@ namespace Mono.CSharp {
 
                        public int GetILOffset (ILGenerator ig)
                        {
+#if NET_4_0
+                               return ig.ILOffset;
+#else
                                return get_il_offset_func (ig);
+#endif
                        }
 
                        public void WriteSymbolFile ()
@@ -51,7 +57,9 @@ namespace Mono.CSharp {
 
                        public bool Initialize ()
                        {
-                               MethodInfo mi = typeof (ILGenerator).GetMethod (
+                               MethodInfo mi;
+#if !NET_4_0
+                               mi = typeof (ILGenerator).GetMethod (
                                        "Mono_GetCurrentOffset",
                                        BindingFlags.Static | BindingFlags.NonPublic);
                                if (mi == null)
@@ -59,6 +67,7 @@ namespace Mono.CSharp {
 
                                get_il_offset_func = (GetILOffsetFunc) System.Delegate.CreateDelegate (
                                        typeof (GetILOffsetFunc), mi);
+#endif
 
                                mi = typeof (ModuleBuilder).GetMethod (
                                        "Mono_GetGuid",
@@ -83,13 +92,13 @@ namespace Mono.CSharp {
                        }
                }
 
-               public static void OpenMethod (ISourceFile file, ISourceMethod method,
-                                              int start_row, int start_column,
-                                              int end_row, int end_column)
+               public static SourceMethodBuilder OpenMethod (ICompileUnit file, int ns_id,
+                                                             IMethodDef method)
                {
                        if (symwriter != null)
-                               symwriter.OpenMethod (file, method, start_row, start_column,
-                                                     end_row, end_column);
+                               return symwriter.OpenMethod (file, ns_id, method);
+                       else
+                               return null;
                }
 
                public static void CloseMethod ()
@@ -116,7 +125,7 @@ namespace Mono.CSharp {
                        }
                }
 
-               public static int DefineNamespace (string name, SourceFileEntry source,
+               public static int DefineNamespace (string name, CompileUnitEntry source,
                                                   string[] using_clauses, int parent)
                {
                        if (symwriter != null)
@@ -125,11 +134,109 @@ namespace Mono.CSharp {
                                return -1;
                }
 
-               public static void MarkSequencePoint (ILGenerator ig, int row, int column)
+#region Terrania additions
+               public static void DefineAnonymousScope (int id)
+               {
+                       if (symwriter != null)
+                               symwriter.DefineAnonymousScope (id);
+               }
+
+               public static void DefineScopeVariable (int scope, LocalBuilder builder)
+               {
+                       if (symwriter != null) {
+                               int index = MonoDebuggerSupport.GetLocalIndex (builder);
+                               symwriter.DefineScopeVariable (scope, index);
+                       }
+               }
+
+               public static void DefineScopeVariable (int scope)
+               {
+                       if (symwriter != null)
+                               symwriter.DefineScopeVariable (scope, -1);
+               }
+
+               public static void DefineCapturedLocal (int scope_id, string name,
+                                                       string captured_name)
+               {
+                       if (symwriter != null)
+                               symwriter.DefineCapturedLocal (scope_id, name, captured_name);
+               }
+
+               public static void DefineCapturedParameter (int scope_id, string name,
+                                                           string captured_name)
+               {
+                       if (symwriter != null)
+                               symwriter.DefineCapturedParameter (scope_id, name, captured_name);
+               }
+
+               public static void DefineCapturedThis (int scope_id, string captured_name)
+               {
+                       if (symwriter != null)
+                               symwriter.DefineCapturedThis (scope_id, captured_name);
+               }
+
+               public static void DefineCapturedScope (int scope_id, int id, string captured_name)
+               {
+                       if (symwriter != null)
+                               symwriter.DefineCapturedScope (scope_id, id, captured_name);
+               }
+
+               public static void OpenCompilerGeneratedBlock (EmitContext ec)
                {
                        if (symwriter != null) {
+                               int offset = symwriter.GetILOffset (ec.ig);
+                               symwriter.OpenCompilerGeneratedBlock (offset);
+                       }
+               }
+
+               public static void CloseCompilerGeneratedBlock (EmitContext ec)
+               {
+                       if (symwriter != null) {
+                               int offset = symwriter.GetILOffset (ec.ig);
+                               symwriter.CloseCompilerGeneratedBlock (offset);
+                       }
+               }
+
+               public static void StartIteratorBody (EmitContext ec)
+               {
+                       if (symwriter != null) {
+                               int offset = symwriter.GetILOffset (ec.ig);
+                               symwriter.StartIteratorBody (offset);
+                       }
+               }
+
+               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, row, column);
+                               symwriter.MarkSequencePoint (
+                                       offset, file, loc.Row, loc.Column, loc.Hidden);
                        }
                }
 
@@ -149,5 +256,10 @@ namespace Mono.CSharp {
 
                        return true;
                }
+
+               public static void Reset ()
+               {
+                       symwriter = null;
+               }
        }
 }