public virtual CompilationUnitList VisitCompilationUnitList(CompilationUnitList compUnits, CompilationUnitList changes, CompilationUnitList deletions, CompilationUnitList insertions){
if (changes == null || deletions == null || insertions == null) return compUnits;
int n = compUnits == null ? 0 : compUnits.Count;
if (n > changes.Count){Debug.Assert(false); n = changes.Count;}
if (n > deletions.Count){Debug.Assert(false); n = deletions.Count;}
if (n > insertions.Count){Debug.Assert(false); n = insertions.Count;}
if (compUnits != null)
for (int i = 0; i < n; i++)
compUnits[i] = this.VisitCompilationUnit(compUnits[i], changes[i], deletions[i], insertions[i]);
CompilationUnitList result = new CompilationUnitList(insertions.Count-n);
for (int i = n, m = insertions.Count; i < m; i++)
result.Add(insertions[i]);
return result;
}
//---------------------------------------------------------------------------------
public override Compilation CreateCompilation(Module targetModule, CompilationUnitList compilationUnits, CompilerParameters compilerParameters, Scope globalScope)
{
return(new ZonnonCompilation(targetModule, compilationUnits, compilerParameters, globalScope));
// return base.CreateCompilation (targetModule,compilationUnits,compilerParameters,globalScope);
}
public virtual Differences VisitCompilationUnitList(CompilationUnitList list1, CompilationUnitList list2,
out CompilationUnitList changes, out CompilationUnitList deletions, out CompilationUnitList insertions){
changes = list1 == null ? null : list1.Clone();
deletions = list1 == null ? null : list1.Clone();
insertions = list1 == null ? new CompilationUnitList() : list1.Clone();
//^ assert insertions != null;
Differences differences = new Differences();
//Compare definitions that have matching key attributes
TrivialHashtable matchingPosFor = new TrivialHashtable();
TrivialHashtable matchedNodes = new TrivialHashtable();
for (int j = 0, n = list2 == null ? 0 : list2.Count; j < n; j++){
//^ assert list2 != null;
CompilationUnit nd2 = list2[j];
if (nd2 == null || nd2.Name == null) continue;
matchingPosFor[nd2.Name.UniqueIdKey] = j;
insertions.Add(null);
}
for (int i = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){
//^ assert list1 != null && changes != null && deletions != null;
CompilationUnit nd1 = list1[i];
if (nd1 == null || nd1.Name == null) continue;
object pos = matchingPosFor[nd1.Name.UniqueIdKey];
if (!(pos is int)) continue;
//^ assert pos != null;
//^ assume list2 != null; //since there was entry int matchingPosFor
int j = (int)pos;
CompilationUnit nd2 = list2[j];
//^ assume nd2 != null;
//nd1 and nd2 have the same key attributes and are therefore treated as the same entity
matchedNodes[nd1.UniqueKey] = nd1;
matchedNodes[nd2.UniqueKey] = nd2;
//nd1 and nd2 may still be different, though, so find out how different
Differences diff = this.VisitCompilationUnit(nd1, nd2);
if (diff == null){Debug.Assert(false); continue;}
if (diff.NumberOfDifferences != 0){
changes[i] = diff.Changes as CompilationUnit;
deletions[i] = diff.Deletions as CompilationUnit;
insertions[i] = diff.Insertions as CompilationUnit;
insertions[n+j] = nd1; //Records the position of nd2 in list2 in case the change involved a permutation
Debug.Assert(diff.Changes == changes[i] && diff.Deletions == deletions[i] && diff.Insertions == insertions[i]);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
continue;
}
changes[i] = null;
deletions[i] = null;
insertions[i] = null;
insertions[n+j] = nd1; //Records the position of nd2 in list2 in case the change involved a permutation
}
//Find deletions
for (int i = 0, n = list1 == null ? 0 : list1.Count; i < n; i++){
//^ assert list1 != null && changes != null && deletions != null;
CompilationUnit nd1 = list1[i];
if (nd1 == null) continue;
if (matchedNodes[nd1.UniqueKey] != null) continue;
changes[i] = null;
deletions[i] = nd1;
insertions[i] = null;
differences.NumberOfDifferences += 1;
}
//Find insertions
for (int j = 0, n = list1 == null ? 0 : list1.Count, m = list2 == null ? 0 : list2.Count; j < m; j++){
//^ assert list2 != null;
CompilationUnit nd2 = list2[j];
if (nd2 == null) continue;
if (matchedNodes[nd2.UniqueKey] != null) continue;
insertions[n+j] = nd2; //Records nd2 as an insertion into list1, along with its position in list2
differences.NumberOfDifferences += 1; //REVIEW: put the size of the tree here?
}
if (differences.NumberOfDifferences == 0){
changes = null;
deletions = null;
insertions = null;
}
return differences;
}
public virtual void VisitCompilationUnitList(CompilationUnitList compilationUnits)
{
if (compilationUnits == null) return;
for (int i = 0, n = compilationUnits.Count; i < n; i++)
this.Visit(compilationUnits[i]);
}
public virtual CompilationUnitList VisitCompilationUnitList(CompilationUnitList compilationUnits){
if (compilationUnits == null) return null;
for (int i = 0, n = compilationUnits.Count; i < n; i++)
compilationUnits[i] = (CompilationUnit)this.Visit(compilationUnits[i]);
return compilationUnits;
}
public virtual void ConstructSymbolTable(Compilation compilation, ErrorNodeList errors, TrivialHashtable scopeFor){
if (compilation == null || scopeFor == null){Debug.Assert(false); return;}
this.CurrentCompilation = compilation;
Module symbolTable = compilation.TargetModule = this.CreateModule(compilation.CompilerParameters, errors, compilation);
Scoper scoper = new Scoper(scopeFor);
scoper.currentModule = symbolTable;
ErrorHandler errorHandler = new ErrorHandler(errors);
Looker looker = new Looker(this.GetGlobalScope(symbolTable), errorHandler, scopeFor);
// begin change by drunje
SpecSharpCompilerOptions options = compilation.CompilerParameters as SpecSharpCompilerOptions;
if (options != null)
looker.AllowPointersToManagedStructures = options.AllowPointersToManagedStructures;
// end change by drunje
looker.currentAssembly = (looker.currentModule = symbolTable) as AssemblyNode;
looker.ignoreMethodBodies = true;
Scope globalScope = compilation.GlobalScope = this.GetGlobalScope(symbolTable);
CompilationUnitList sources = compilation.CompilationUnits;
if (sources == null) return;
int n = sources.Count;
for (int i = 0; i < n; i++){
CompilationUnitSnippet compilationUnitSnippet = sources[i] as CompilationUnitSnippet;
if (compilationUnitSnippet == null){Debug.Assert(false); continue;}
compilationUnitSnippet.ChangedMethod = null;
Document doc = compilationUnitSnippet.SourceContext.Document;
if (doc == null || doc.Text == null){Debug.Assert(false); continue;}
IParserFactory factory = compilationUnitSnippet.ParserFactory;
if (factory == null){Debug.Assert(false); return;}
IParser p = factory.CreateParser(doc.Name, doc.LineNumber, doc.Text, symbolTable, errors, compilation.CompilerParameters);
if (p is ResgenCompilerStub) continue;
if (p == null){Debug.Assert(false); continue;}
Parser specSharpParser = p as Parser;
if (specSharpParser == null)
p.ParseCompilationUnit(compilationUnitSnippet);
else
specSharpParser.ParseCompilationUnit(compilationUnitSnippet, true, false);
//TODO: this following is a good idea only if the files will not be frequently reparsed from source
//StringSourceText stringSourceText = doc.Text.TextProvider as StringSourceText;
//if (stringSourceText != null && stringSourceText.IsSameAsFileContents)
// doc.Text.TextProvider = new CollectibleSourceText(doc.Name, doc.Text.Length);
//else if (doc.Text.TextProvider != null)
// doc.Text.TextProvider.MakeCollectible();
}
CompilationUnitList compilationUnits = new CompilationUnitList();
for (int i = 0; i < n; i++){
CompilationUnit cUnit = sources[i];
compilationUnits.Add(scoper.VisitCompilationUnit(cUnit));
}
for (int i = 0; i < n; i++){
CompilationUnit cUnit = compilationUnits[i];
if (cUnit == null) continue;
looker.VisitCompilationUnit(cUnit);
}
//Run resolver over symbol table so that custom attributes on member signatures are known and can be used
//to error check the the given file.
TypeSystem typeSystem = new TypeSystem(errorHandler);
Resolver resolver = new Resolver(errorHandler, typeSystem);
resolver.currentAssembly = (resolver.currentModule = symbolTable) as AssemblyNode;
for (int i = 0; i < n; i++) {
CompilationUnit cUnit = compilationUnits[i];
if (cUnit == null) continue;
resolver.VisitCompilationUnit(cUnit);
}
this.CurrentCompilation = null;
}
public virtual CompilationUnitList VisitCompilationUnitList(CompilationUnitList cUnits1, CompilationUnitList cUnits2)
{
if (cUnits1 == null) return null;
for (int i = 0, n = cUnits1.Count, m = cUnits2 == null ? 0 : cUnits2.Count; i < n; i++)
{
//^ assert cUnits2 != null;
if (i >= m)
cUnits1[i] = (CompilationUnit)this.VisitCompilationUnit(cUnits1[i], null);
else
cUnits1[i] = (CompilationUnit)this.VisitCompilationUnit(cUnits1[i], cUnits2[i]);
}
return cUnits1;
}
public virtual Compilation CreateCompilation(Module targetModule, CompilationUnitList compilationUnits, System.CodeDom.Compiler.CompilerParameters compilerParameters, Scope globalScope){
return new Compilation(targetModule, compilationUnits, compilerParameters, globalScope);
}
public virtual Compilation CloneCompilationUnits()
{
Compilation clone = (Compilation)base.Clone();
CompilationUnitList cus = this.CompilationUnits;
if(cus != null)
{
clone.CompilationUnits = cus = new CompilationUnitList(cus);
for(int i = 0, n = cus.Count; i < n; i++)
{
CompilationUnit cu = cus[i];
if(cu == null)
continue;
cus[i] = cu = (CompilationUnit)cu.Clone();
cu.Compilation = clone;
cu.Nodes = null;
}
}
return clone;
}
public Compilation(Module targetModule, CompilationUnitList compilationUnits, System.CodeDom.Compiler.CompilerParameters compilerParameters, Scope globalScope)
: base(NodeType.Compilation)
{
this.CompilationUnits = compilationUnits;
this.TargetModule = targetModule;
this.CompilerParameters = compilerParameters;
this.GlobalScope = globalScope;
}
/// <summary>
/// Parses all of the CompilationUnitSnippets in the given compilation, ignoring method bodies. Then resolves all type expressions.
/// The resulting types can be retrieved from the module in compilation.TargetModule. The base types, interfaces and
/// member signatures will all be resolved and on an equal footing with imported, already compiled modules and assemblies.
/// </summary>
public override void ConstructSymbolTable(Compilation compilation, ErrorNodeList errors)
{
if (compilation == null) { Debug.Assert(false); return; }
Module symbolTable = compilation.TargetModule = this.CreateModule(compilation.CompilerParameters, errors, compilation);
TrivialHashtable scopeFor = new TrivialHashtable();
Scoper scoper = new Scoper(scopeFor);
scoper.currentModule = symbolTable;
ErrorHandler errorHandler = new ErrorHandler(errors);
TypeSystem typeSystem = new TypeSystem(errorHandler); // LJW: added typeSystem
Looker looker = new Looker(this.GetGlobalScope(symbolTable), errorHandler, scopeFor, typeSystem);
looker.currentAssembly = (looker.currentModule = symbolTable) as AssemblyNode;
looker.ignoreMethodBodies = true;
compilation.GlobalScope = this.GetGlobalScope(symbolTable);
CompilationUnitList sources = compilation.CompilationUnits;
if (sources == null) { Debug.Assert(false); return; }
int n = sources.Count;
for (int i = 0; i < n; i++)
{
CompilationUnitSnippet compilationUnitSnippet = sources[i] as CompilationUnitSnippet;
if (compilationUnitSnippet == null) { Debug.Assert(false); continue; }
compilationUnitSnippet.ChangedMethod = null;
Document doc = compilationUnitSnippet.SourceContext.Document;
if (doc == null || doc.Text == null) { Debug.Assert(false); continue; }
IParserFactory factory = compilationUnitSnippet.ParserFactory;
if (factory == null) { Debug.Assert(false); return; }
IParser p = factory.CreateParser(doc.Name, doc.LineNumber, doc.Text, symbolTable, errors, compilation.CompilerParameters);
if (p is ResgenCompilerStub) continue;
if (p == null) { Debug.Assert(false); continue; }
Parser zingParser = p as Parser;
if (zingParser == null)
p.ParseCompilationUnit(compilationUnitSnippet);
else
zingParser.ParseCompilationUnit(compilationUnitSnippet, true, true, null);
StringSourceText stringSourceText = doc.Text.TextProvider as StringSourceText;
if (stringSourceText != null && stringSourceText.IsSameAsFileContents)
doc.Text.TextProvider = new CollectibleSourceText(doc.Name, doc.Text.Length);
else if (doc.Text.TextProvider != null)
doc.Text.TextProvider.MakeCollectible();
}
CompilationUnitList compilationUnits = new CompilationUnitList();
for (int i = 0; i < n; i++)
{
CompilationUnit cUnit = sources[i];
compilationUnits.Add(scoper.VisitCompilationUnit(cUnit));
}
for (int i = 0; i < n; i++)
{
CompilationUnit cUnit = compilationUnits[i];
if (cUnit == null) continue;
looker.VisitCompilationUnit(cUnit);
}
}
public EventingVisitor(Action<CompilationUnitList> visitCompilationUnitList) { VisitedCompilationUnitList += visitCompilationUnitList; } public event Action<CompilationUnitList> VisitedCompilationUnitList; public override CompilationUnitList VisitCompilationUnitList(CompilationUnitList compilationUnits) { if (VisitedCompilationUnitList != null) VisitedCompilationUnitList(compilationUnits); return base.VisitCompilationUnitList(compilationUnits); }
