public void PrintCompileUnits()
{
Message("Reading {0}, version {1}.{2}.", File.FileName, File.MajorVersion,
File.MinorVersion);
for (int i = 0; i < File.CompileUnitCount; i++)
{
if (CompileUnits.Count > 0)
{
if (!CompileUnits.ContainsKey(i + 1))
{
continue;
}
}
CompileUnitEntry unit = File.GetCompileUnit(i + 1);
SourceFileEntry file = unit.SourceFile;
Message("Compile unit {0}: ({1}) {2}", unit.Index, file.Index, file.FileName);
foreach (SourceFileEntry include in unit.IncludeFiles)
{
Message(" Include: ({0}) {1}", include.Index, include.FileName);
}
}
}
public void Close()
{
MonoSymbolWriter writer = new MonoSymbolWriter(moduleBuilder.FullyQualifiedName);
foreach (Method method in methods.Values)
{
if (method.document != null)
{
if (method.document.source == null)
{
method.document.source = new SourceFileEntry(writer.SymbolFile, method.document.url);
}
ICompileUnit file = new CompileUnitEntry(writer.SymbolFile, method.document.source);
SourceMethodBuilder smb = writer.OpenMethod(file, 0, method);
for (int i = 0; i < method.offsets.Length; i++)
{
smb.MarkSequencePoint(method.offsets[i], method.document.source, method.lines[i], method.columns[i], false);
}
for (int i = 0; i < method.variables.Count; i++)
{
writer.DefineLocalVariable(i, method.variables[i]);
}
writer.CloseMethod();
}
}
writer.WriteSymbolFile(moduleBuilder.ModuleVersionId);
}
public SourceMethod(CompileUnitEntry file, MethodDef method, Location start)
{
this.file = file;
this.method = method;
this.StartLine = start.line;
lines = new ArrayList();
MarkLocation(start.line, 0);
}
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);
}
}
public override void DefineSymbolInfo(MonoSymbolWriter symwriter)
{
base.DefineSymbolInfo(symwriter);
comp_unit = symwriter.DefineCompilationUnit(SourceFileEntry);
if (include_files != null)
{
foreach (SourceFile include in include_files.Values)
{
include.DefineSymbolInfo(symwriter);
comp_unit.AddFile(include.SourceFileEntry);
}
}
}
SourceFile GetSourceFile(Document document)
{
string url = document.Url;
SourceFile file = m_documents [url] as SourceFile;
if (file != null)
{
return(file);
}
SourceFileEntry entry = m_writer.DefineDocument(url);
CompileUnitEntry comp_unit = m_writer.DefineCompilationUnit(entry);
file = new SourceFile(comp_unit, entry);
m_documents [url] = file;
return(file);
}
protected void CheckCompileUnit(CompileUnitEntry unit)
{
SourceFileEntry file = unit.SourceFile;
SourceFileEntry file2 = File.GetSourceFile(file.Index);
if ((file2 == null) || (file != file2))
{
throw new MonoSymbolFileException(
"Invalid source file reference in compile unit {0}.", unit.Index);
}
Debug(" Compile unit {0}: {1} {2} {3}", unit.Index, file, file2, file == file2);
if (unit.Namespaces == null)
{
throw new MonoSymbolFileException(
"Invalid name space table in compile unit {0}.", unit.Index);
}
}
public void EndSourceFile()
{
current_source = null;
}
public void BeginSourceFile(string filename)
{
SourceFileEntry file = DefineDocument(filename, null, null);
current_source = DefineCompilationUnit(file);
}
public int AddCompileUnit(CompileUnitEntry entry)
{
comp_units.Add (entry);
return comp_units.Count;
}
public SourceFile(CompileUnitEntry comp_unit, SourceFileEntry entry)
{
this.comp_unit = comp_unit;
this.entry = entry;
}
public int DefineNamespace(string name, CompileUnitEntry unit,
string[] using_clauses, int parent)
{
if ((unit == null) || (using_clauses == null))
throw new NullReferenceException ();
return unit.DefineNamespace (name, using_clauses, parent);
}
public CompileUnitEntry DefineCompilationUnit(SourceFileEntry source)
{
CompileUnitEntry entry = new CompileUnitEntry (file, source);
comp_units.Add (entry);
return entry;
}
public CompileUnitEntry GetCompileUnit(int index)
{
if ((index < 1) || (index > ot.CompileUnitCount))
throw new ArgumentException ();
if (reader == null)
throw new InvalidOperationException ();
lock (this) {
CompileUnitEntry unit;
if (compile_unit_hash.TryGetValue (index, out unit))
return unit;
long old_pos = reader.BaseStream.Position;
reader.BaseStream.Position = ot.CompileUnitTableOffset +
CompileUnitEntry.Size * (index - 1);
unit = new CompileUnitEntry (this, reader);
compile_unit_hash.Add (index, unit);
reader.BaseStream.Position = old_pos;
return unit;
}
}
public MethodEntry DefineMethod(CompileUnitEntry comp_unit, int token,
ScopeVariable[] scope_vars, LocalVariableEntry[] locals,
LineNumberEntry[] lines, CodeBlockEntry[] code_blocks,
string real_name, MethodEntry.Flags flags,
int namespace_id)
{
if (reader != null)
throw new InvalidOperationException ();
MethodEntry method = new MethodEntry (
this, comp_unit, token, scope_vars, locals, lines, code_blocks,
real_name, flags, namespace_id);
AddMethod (method);
return method;
}
public SourceFile(CompileUnitEntry comp_unit, SourceFileEntry entry)
{
this.comp_unit = comp_unit;
this.entry = entry;
}
public SymbolDocumentWriterImpl(CompileUnitEntry comp_unit)
{
this.comp_unit = comp_unit;
}
