| 1 |
// |
| 2 |
// Mono.CSharp.Debugger/MonoSymbolWriter.cs |
| 3 |
// |
| 4 |
// Author: |
| 5 |
// Martin Baulig ([email protected]) |
| 6 |
// |
| 7 |
// This is the default implementation of the System.Diagnostics.SymbolStore.ISymbolWriter |
| 8 |
// interface. |
| 9 |
// |
| 10 |
// (C) 2002 Ximian, Inc. http://www.ximian.com |
| 11 |
// |
| 12 |
|
| 13 |
// |
| 14 |
// Permission is hereby granted, free of charge, to any person obtaining |
| 15 |
// a copy of this software and associated documentation files (the |
| 16 |
// "Software"), to deal in the Software without restriction, including |
| 17 |
// without limitation the rights to use, copy, modify, merge, publish, |
| 18 |
// distribute, sublicense, and/or sell copies of the Software, and to |
| 19 |
// permit persons to whom the Software is furnished to do so, subject to |
| 20 |
// the following conditions: |
| 21 |
// |
| 22 |
// The above copyright notice and this permission notice shall be |
| 23 |
// included in all copies or substantial portions of the Software. |
| 24 |
// |
| 25 |
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| 26 |
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 27 |
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| 28 |
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE |
| 29 |
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION |
| 30 |
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
| 31 |
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 32 |
// |
| 33 |
|
| 34 |
using System; |
| 35 |
using System.Runtime.CompilerServices; |
| 36 |
using System.Collections.Generic; |
| 37 |
using System.IO; |
| 38 |
|
| 39 |
namespace Mono.CompilerServices.SymbolWriter |
| 40 |
{ |
| 41 |
public class MonoSymbolWriter |
| 42 |
{ |
| 43 |
List<SourceMethodBuilder> methods; |
| 44 |
List<SourceFileEntry> sources; |
| 45 |
List<CompileUnitEntry> comp_units; |
| 46 |
protected readonly MonoSymbolFile file; |
| 47 |
string filename; |
| 48 |
|
| 49 |
private SourceMethodBuilder current_method; |
| 50 |
Stack<SourceMethodBuilder> current_method_stack = new Stack<SourceMethodBuilder> (); |
| 51 |
|
| 52 |
public MonoSymbolWriter (string filename) |
| 53 |
{ |
| 54 |
this.methods = new List<SourceMethodBuilder> (); |
| 55 |
this.sources = new List<SourceFileEntry> (); |
| 56 |
this.comp_units = new List<CompileUnitEntry> (); |
| 57 |
this.file = new MonoSymbolFile (); |
| 58 |
|
| 59 |
this.filename = filename + ".mdb"; |
| 60 |
} |
| 61 |
|
| 62 |
public MonoSymbolFile SymbolFile { |
| 63 |
get { return file; } |
| 64 |
} |
| 65 |
|
| 66 |
public void CloseNamespace () |
| 67 |
{ } |
| 68 |
|
| 69 |
public void DefineLocalVariable (int index, string name) |
| 70 |
{ |
| 71 |
if (current_method == null) |
| 72 |
return; |
| 73 |
|
| 74 |
current_method.AddLocal (index, name); |
| 75 |
} |
| 76 |
|
| 77 |
public void DefineCapturedLocal (int scope_id, string name, string captured_name) |
| 78 |
{ |
| 79 |
file.DefineCapturedVariable (scope_id, name, captured_name, |
| 80 |
CapturedVariable.CapturedKind.Local); |
| 81 |
} |
| 82 |
|
| 83 |
public void DefineCapturedParameter (int scope_id, string name, string captured_name) |
| 84 |
{ |
| 85 |
file.DefineCapturedVariable (scope_id, name, captured_name, |
| 86 |
CapturedVariable.CapturedKind.Parameter); |
| 87 |
} |
| 88 |
|
| 89 |
public void DefineCapturedThis (int scope_id, string captured_name) |
| 90 |
{ |
| 91 |
file.DefineCapturedVariable (scope_id, "this", captured_name, |
| 92 |
CapturedVariable.CapturedKind.This); |
| 93 |
} |
| 94 |
|
| 95 |
public void DefineCapturedScope (int scope_id, int id, string captured_name) |
| 96 |
{ |
| 97 |
file.DefineCapturedScope (scope_id, id, captured_name); |
| 98 |
} |
| 99 |
|
| 100 |
public void DefineScopeVariable (int scope, int index) |
| 101 |
{ |
| 102 |
if (current_method == null) |
| 103 |
return; |
| 104 |
|
| 105 |
current_method.AddScopeVariable (scope, index); |
| 106 |
} |
| 107 |
|
| 108 |
public void MarkSequencePoint (int offset, SourceFileEntry file, int line, int column, |
| 109 |
bool is_hidden) |
| 110 |
{ |
| 111 |
if (current_method == null) |
| 112 |
return; |
| 113 |
|
| 114 |
current_method.MarkSequencePoint (offset, file, line, column, is_hidden); |
| 115 |
} |
| 116 |
|
| 117 |
public SourceMethodBuilder OpenMethod (ICompileUnit file, int ns_id, IMethodDef method) |
| 118 |
{ |
| 119 |
SourceMethodBuilder builder = new SourceMethodBuilder (file, ns_id, method); |
| 120 |
current_method_stack.Push (current_method); |
| 121 |
current_method = builder; |
| 122 |
methods.Add (current_method); |
| 123 |
return builder; |
| 124 |
} |
| 125 |
|
| 126 |
public void CloseMethod () |
| 127 |
{ |
| 128 |
current_method = (SourceMethodBuilder) current_method_stack.Pop (); |
| 129 |
} |
| 130 |
|
| 131 |
public SourceFileEntry DefineDocument (string url) |
| 132 |
{ |
| 133 |
SourceFileEntry entry = new SourceFileEntry (file, url); |
| 134 |
sources.Add (entry); |
| 135 |
return entry; |
| 136 |
} |
| 137 |
|
| 138 |
public SourceFileEntry DefineDocument (string url, byte[] guid, byte[] checksum) |
| 139 |
{ |
| 140 |
SourceFileEntry entry = new SourceFileEntry (file, url, guid, checksum); |
| 141 |
sources.Add (entry); |
| 142 |
return entry; |
| 143 |
} |
| 144 |
|
| 145 |
public CompileUnitEntry DefineCompilationUnit (SourceFileEntry source) |
| 146 |
{ |
| 147 |
CompileUnitEntry entry = new CompileUnitEntry (file, source); |
| 148 |
comp_units.Add (entry); |
| 149 |
return entry; |
| 150 |
} |
| 151 |
|
| 152 |
public int DefineNamespace (string name, CompileUnitEntry unit, |
| 153 |
string[] using_clauses, int parent) |
| 154 |
{ |
| 155 |
if ((unit == null) || (using_clauses == null)) |
| 156 |
throw new NullReferenceException (); |
| 157 |
|
| 158 |
return unit.DefineNamespace (name, using_clauses, parent); |
| 159 |
} |
| 160 |
|
| 161 |
public int OpenScope (int start_offset) |
| 162 |
{ |
| 163 |
if (current_method == null) |
| 164 |
return 0; |
| 165 |
|
| 166 |
current_method.StartBlock (CodeBlockEntry.Type.Lexical, start_offset); |
| 167 |
return 0; |
| 168 |
} |
| 169 |
|
| 170 |
public void CloseScope (int end_offset) |
| 171 |
{ |
| 172 |
if (current_method == null) |
| 173 |
return; |
| 174 |
|
| 175 |
current_method.EndBlock (end_offset); |
| 176 |
} |
| 177 |
|
| 178 |
public void OpenCompilerGeneratedBlock (int start_offset) |
| 179 |
{ |
| 180 |
if (current_method == null) |
| 181 |
return; |
| 182 |
|
| 183 |
current_method.StartBlock (CodeBlockEntry.Type.CompilerGenerated, |
| 184 |
start_offset); |
| 185 |
} |
| 186 |
|
| 187 |
public void CloseCompilerGeneratedBlock (int end_offset) |
| 188 |
{ |
| 189 |
if (current_method == null) |
| 190 |
return; |
| 191 |
|
| 192 |
current_method.EndBlock (end_offset); |
| 193 |
} |
| 194 |
|
| 195 |
public void StartIteratorBody (int start_offset) |
| 196 |
{ |
| 197 |
current_method.StartBlock (CodeBlockEntry.Type.IteratorBody, |
| 198 |
start_offset); |
| 199 |
} |
| 200 |
|
| 201 |
public void EndIteratorBody (int end_offset) |
| 202 |
{ |
| 203 |
current_method.EndBlock (end_offset); |
| 204 |
} |
| 205 |
|
| 206 |
public void StartIteratorDispatcher (int start_offset) |
| 207 |
{ |
| 208 |
current_method.StartBlock (CodeBlockEntry.Type.IteratorDispatcher, |
| 209 |
start_offset); |
| 210 |
} |
| 211 |
|
| 212 |
public void EndIteratorDispatcher (int end_offset) |
| 213 |
{ |
| 214 |
current_method.EndBlock (end_offset); |
| 215 |
} |
| 216 |
|
| 217 |
public void DefineAnonymousScope (int id) |
| 218 |
{ |
| 219 |
file.DefineAnonymousScope (id); |
| 220 |
} |
| 221 |
|
| 222 |
public void WriteSymbolFile (Guid guid) |
| 223 |
{ |
| 224 |
foreach (SourceMethodBuilder method in methods) |
| 225 |
method.DefineMethod (file); |
| 226 |
|
| 227 |
try { |
| 228 |
// We mmap the file, so unlink the previous version since it may be in use |
| 229 |
File.Delete (filename); |
| 230 |
} catch { |
| 231 |
// We can safely ignore |
| 232 |
} |
| 233 |
using (FileStream fs = new FileStream (filename, FileMode.Create, FileAccess.Write)) { |
| 234 |
file.CreateSymbolFile (guid, fs); |
| 235 |
} |
| 236 |
} |
| 237 |
} |
| 238 |
} |