public override CompilationUnit VisitCompilationUnit(CompilationUnit cUnit){
if (cUnit == null) return null;
if (cUnit.Compilation != null){
SpecSharpCompilerOptions coptions = cUnit.Compilation.CompilerParameters as SpecSharpCompilerOptions;
if (coptions != null) this.inCompatibilityMode = coptions.Compatibility;
}
return base.VisitCompilationUnit(cUnit);
}
public static TypeNode GetTypeTemplateByName(CompilationUnit template, string name)
{
for (int i = 0, n = ((Namespace)template.Nodes[0]).Types.Count; i < n; i++)
{
TypeNode tn = ((Namespace)template.Nodes[0]).Types[i];
if (tn.Name.Name == name)
return tn;
}
throw new ArgumentException("Type node '" + name + "' not found");
}
public CompilationUnit ParseCompilationUnit(string source, string fname, CompilerParameters parameters, ErrorNodeList errors, AuthoringSink sink){
Guid dummy = Parser.dummyGuid;
Document document = new Document(fname, 1, source, dummy, dummy, dummy);
this.errors = errors;
this.scanner = new Scanner(document, errors, parameters as SpecSharpCompilerOptions);
this.currentToken = Token.None;
this.errors = errors;
this.ProcessOptions(parameters as SpecSharpCompilerOptions);
CompilationUnit cu = new CompilationUnit(Identifier.For(fname));
cu.Compilation = new Compilation(this.module, new CompilationUnitList(cu), parameters, null);
cu.SourceContext = new SourceContext(document);
this.ParseCompilationUnit(cu, false, true, sink);//This overload is only called for intellisense, not the background error check.
cu.PragmaWarnInformation = this.scanner.pragmaInformation;
this.errors = null;
this.scanner = null;
return cu;
}
void ConstructCompilationUnit(){
CompilationUnitSnippet cu = new CompilationUnitSnippet();
this.compilationUnit = cu;
this.compilation.CompilationUnits.Add(cu);
cu.Compilation = this.compilation;
cu.Name = new Identifier(this.inputLine.Substring(5));
string snippetText = this.ReadString();
cu.SourceContext.Document = this.currentDocument = this.compiler.CreateDocument(cu.Name.ToString(), 1, snippetText);
cu.SourceContext.EndPos = snippetText.Length;
cu.ParserFactory = new Microsoft.SpecSharp.ParserFactory();
}
public EventingVisitor(Action<CompilationUnit> visitCompilationUnit) { VisitedCompilationUnit += visitCompilationUnit; } public event Action<CompilationUnit> VisitedCompilationUnit; public override CompilationUnit VisitCompilationUnit(CompilationUnit cUnit) { if (VisitedCompilationUnit != null) VisitedCompilationUnit(cUnit); return base.VisitCompilationUnit(cUnit); }
CompilationUnit CreateCompilationUnit(Module module, TypeNode type) {
CompilationUnit cu = new CompilationUnit();
cu.Namespaces = new NamespaceList();
cu.TargetModule = module;
this.cunit = cu;
this.module = module;
Namespace ns = new Namespace(Identifier.Empty, Identifier.Empty, new AliasDefinitionList(), new UsedNamespaceList(), new NamespaceList(), new TypeNodeList());
cu.Namespaces.Add(ns);
ns.UsedNamespaces.Add(new UsedNamespace(Identifier.For("System")));
ns.UsedNamespaces.Add(new UsedNamespace(Identifier.For("System.Xml")));
ns.UsedNamespaces.Add(new UsedNamespace(Identifier.For("Microsoft.Comega"))); // XmlSerializationWriter
CreateSerializerFor(type);
return cu;
}
public virtual CompilationUnit VisitCompilationUnit(CompilationUnit cUnit)
{
if (cUnit == null) return null;
cUnit.Nodes = this.VisitNodeList(cUnit.Nodes);
return cUnit;
}
public override CompilationUnit VisitCompilationUnit(CompilationUnit cUnit)
{
if (cUnit == null) return null;
this.FindTypesToBeDuplicated(cUnit.Nodes);
return base.VisitCompilationUnit((CompilationUnit)cUnit.Clone());
}
internal void ParseCompilationUnit(CompilationUnit cu, bool omitBodies, bool ignoreDocComments, AuthoringSink sink){
if (cu == null) throw new ArgumentNullException("cu");
this.sink = sink;
Namespace ns = new Namespace(Identifier.Empty, Identifier.Empty, new AliasDefinitionList(), new UsedNamespaceList(), new NamespaceList(), new TypeNodeList());
ns.SourceContext = cu.SourceContext;
cu.Nodes = new NodeList(ns);
this.omitBodies = omitBodies || this.parsingContractAssembly;
this.scanner.ignoreDocComments = ignoreDocComments;
this.scanner.sink = sink;
this.GetNextToken();
cu.PreprocessorDefinedSymbols = this.scanner.PreprocessorDefinedSymbols;
tryAgain:
this.ParseExternalAliasDirectives(ns, Parser.AttributeOrNamespaceOrTypeDeclarationStart|Token.Using|Token.LastIdentifier|Parser.EndOfFile);
this.ParseUsingDirectives(ns, Parser.AttributeOrNamespaceOrTypeDeclarationStart|Token.Extern|Token.LastIdentifier|Parser.EndOfFile);
if (this.currentToken == Token.Extern){
this.HandleError(Error.ExternAfterElements);
goto tryAgain;
}
this.ParseNamespaceMemberDeclarations(ns, Parser.EndOfFile);
cu.PragmaWarnInformation = this.scanner.pragmaInformation;
this.scanner.sink = null;
this.sink = null;
}
public bool ParseStatementTemplate(string templateName, System.Reflection.Assembly assembly)
{
this.cuStatements = ParseBaseTemplate(templateName, assembly);
return (this.cuStatements != null);
}
public bool ParseExpressionTemplate(string templateName, System.Reflection.Assembly assembly)
{
this.cuExprs = ParseBaseTemplate(templateName, assembly);
return (this.cuExprs != null);
}
public CompilationUnit CodeGen(Compilation compilation)
{
try
{
// Debugging message
/*
for (int c = 0, nc = compilation.CompilationUnits.Length; c < nc; c++)
{
Namespace ns = (Namespace)compilation.CompilationUnits[c].Nodes[0];
Console.WriteLine("X" + ns.Name.ToString() + "X");
for (int i = 0, n = ns.Types.Length; i < n; i++)
{
TypeNode tn = (TypeNode)ns.Types[i];
Console.WriteLine("\t" + tn.Name.ToString());
}
}
*/
// END
this.cZing = compilation;
Templates.module = compilation.TargetModule;
Templates.InitializeTemplates();
// Scan the Zing AST for interesting high-level information.
MemberList globals = CollectGlobals();
TypeNodeList classes = CollectClasses();
// Compile the "base" template and get the interesting nodes from it.
cuBase = Templates.GetApplicationTemplate(compilation.TargetModule, options, globals.Count > 0, HeapUsed());
Debug.Assert(((Namespace)cuBase.Nodes[0]).Types.Count == 0);
Debug.Assert(((Namespace)cuBase.Nodes[0]).NestedNamespaces.Count == 1);
Debug.Assert(((Namespace)cuBase.Nodes[0]).NestedNamespaces[0].Types.Count == 1);
appClass = (Class)((Namespace)cuBase.Nodes[0]).NestedNamespaces[0].Types[0];
// Begin transforming the output
SetSourceStrings(compilation);
SetExceptionList();
// for each Zing type definition, call a helper to splice it into the
// generated compilation unit.
for (int c = 0, nc = cZing.CompilationUnits.Count; c < nc; c++)
{
for (int i = 0, n = ((Namespace)cZing.CompilationUnits[c].Nodes[0]).Types.Count; i < n; i++)
{
TypeNode tn = (TypeNode)((Namespace)cZing.CompilationUnits[c].Nodes[0]).Types[i];
if (tn is Interface)
GenerateInterface((Interface)tn);
else if (tn is Class)
GenerateClass((Class)tn);
else if (tn is EnumNode)
GenerateEnum((EnumNode)tn);
else if (tn is Range)
GenerateRange((Range)tn);
else if (tn is Set)
GenerateSet((Set)tn);
else if (tn is Chan)
GenerateChan((Chan)tn);
else if (tn is Struct)
GenerateStruct((Struct)tn);
else if (tn is ZArray)
GenerateArray((ZArray)tn);
else
throw new ApplicationException("Unknown Zing type: " + tn.GetType().ToString());
}
}
GenerateTypeChoiceHelper();
// NOTE: this must be done after processing the classes because we turn off
// the "static" flag on the globals during processing which confuses GenerateClass.
ProcessGlobals(globals);
return cuBase;
}
finally
{
Templates.module = null;
Templates.ReleaseTemplates();
}
}
public static void ReleaseTemplates()
{
cuParts = null;
cuExpressions = null;
cuStatements = null;
cuProperties = null;
}
public static void InitializeTemplates()
{
// Compile the templates from which we'll duplicate nodes later.
cuParts = Templates.CompileTemplate("TemplateParts");
cuExpressions = Templates.CompileTemplate("TemplateExprs");
cuStatements = Templates.CompileTemplate("TemplateStmts");
cuProperties = Templates.CompileTemplate("TemplateProps");
}
public override CompilationUnit VisitCompilationUnit(CompilationUnit cUnit) {
this.writer.WriteStartElement("CompilationUnit");
this.writer.WriteAttributeString("file", cUnit.Name.Name);
CompilationUnit result = base.VisitCompilationUnit(cUnit);
this.writer.WriteEndElement(); // Namespace
return result;
}
void IParser.ParseCompilationUnit(CompilationUnit cu){
this.ParseCompilationUnit(cu, false, this.scanner.ignoreDocComments, null);
}
public void ParseCompilationUnit(CompilationUnit cu, bool omitBodies, bool ignoreDocComments){
this.ParseCompilationUnit(cu, omitBodies, ignoreDocComments, null);
}
public override CompilationUnit ParseCompilationUnit(string fname, string source, ErrorNodeList errors, Compilation compilation, AuthoringSink sink){
this.parsingStatement = false;
if (fname == null || source == null || errors == null || compilation == null){Debug.Assert(false); return null;}
if (compilation != null && compilation.CompilerParameters is SpecSharpCompilerOptions)
this.allowSpecSharpExtensions = !((SpecSharpCompilerOptions)compilation.CompilerParameters).Compatibility;
CompilationUnit cu;
#if Xaml
if (fname.Length > 5 && string.Compare(fname, fname.Length-5, ".xaml", 0, 5, true, CultureInfo.InvariantCulture) == 0){
Document xamlDocument = Microsoft.XamlCompiler.Compiler.CreateXamlDocument(fname, 1, new DocumentText(source));
Microsoft.XamlCompiler.ErrorHandler xamlErrorHandler = new Microsoft.XamlCompiler.ErrorHandler(errors);
Microsoft.XamlCompiler.Compiler xamlCompiler =
new Microsoft.XamlCompiler.Compiler(xamlDocument, compilation.TargetModule, xamlErrorHandler, new ParserFactory(), compilation.CompilerParameters as CompilerOptions);
cu = xamlCompiler.GetCompilationUnit();
}else{
#endif
Parser p = new Parser(compilation.TargetModule);
cu = p.ParseCompilationUnit(source, fname, compilation.CompilerParameters, errors, sink);
if (cu != null) cu.Compilation = compilation;
this.parsingStatement = p.parsingStatement;
#if Xaml
}
#endif
this.partialCompilationUnit = cu;
return cu;
}
public void ParseCompilationUnit(CompilationUnit compilationUnit){
CompilationUnitSnippet cuSnippet = compilationUnit as CompilationUnitSnippet;
if (cuSnippet == null || cuSnippet.Compilation == null){Debug.Assert(false); return;}
XamlSnippet xamlSnippet = new XamlSnippet();
xamlSnippet.CodeModule = cuSnippet.Compilation.TargetModule;
xamlSnippet.ErrorHandler = new Microsoft.XamlCompiler.ErrorHandler(this.errorNodes);
xamlSnippet.Options = this.options;
xamlSnippet.ParserFactory = new ParserFactory();
xamlSnippet.XamlDocument = cuSnippet.SourceContext.Document;
cuSnippet.Nodes = new NodeList(xamlSnippet);
}
public override void Resolve(CompilationUnit partialCompilationUnit){
if (partialCompilationUnit == null){Debug.Assert(false); return;}
TrivialHashtable scopeFor = new TrivialHashtable();
Scoper scoper = new Scoper(scopeFor);
scoper.currentModule = this.currentSymbolTable;
scoper.VisitCompilationUnit(partialCompilationUnit);
ErrorHandler errorHandler = new ErrorHandler(new ErrorNodeList(0));
TrivialHashtable ambiguousTypes = new TrivialHashtable();
TrivialHashtable referencedLabels = new TrivialHashtable();
Looker looker = new Looker(null, errorHandler, scopeFor, ambiguousTypes, referencedLabels);
looker.currentAssembly = (looker.currentModule = this.currentSymbolTable) as AssemblyNode;
looker.identifierInfos = this.identifierInfos = new NodeList();
looker.identifierPositions = this.identifierPositions = new Int32List();
looker.identifierLengths = this.identifierLengths = new Int32List();
looker.identifierContexts = this.identifierContexts = new Int32List();
looker.identifierScopes = this.identifierScopes = new ScopeList();
looker.allScopes = this.allScopes = new ScopeList();
looker.VisitCompilationUnit(partialCompilationUnit);
//Walk IR inferring types and resolving overloads
Resolver resolver = new Resolver(errorHandler, new TypeSystem(errorHandler));
resolver.currentAssembly = (resolver.currentModule = this.currentSymbolTable) as AssemblyNode;
resolver.Visit(partialCompilationUnit);
}
public override CompilationUnit VisitCompilationUnit(CompilationUnit cUnit)
{
CompilationUnit retCUnit = base.VisitCompilationUnit(cUnit);
if (cUnit != null && cUnit.Name != null && this.WeakPurityAnalyzer != null)
{
Console.Out.WriteLine("*** Declared Pure:{0}, Pure: {1}, Methods {3}, {2}",
this.WeakPurityAnalyzer.numberOfDeclaredPure,
this.WeakPurityAnalyzer.numberOfPures, cUnit.Name, this.WeakPurityAnalyzer.numberOfMethods);
}
return retCUnit;
}
public override CompilationUnit VisitCompilationUnit(CompilationUnit cUnit) {
this.cUnit = cUnit;
if (this.ErrorHandler != null)
this.ErrorHandler.SetPragmaWarnInformation(cUnit.PragmaWarnInformation);
CompilationUnit retCUnit = base.VisitCompilationUnit(cUnit);
if (this.ErrorHandler != null)
this.ErrorHandler.ResetPragmaWarnInformation();
return retCUnit;
}
public override void DetermineIfNonNullCheckingIsDesired(CompilationUnit cUnit){
SpecSharpCompilerOptions soptions = this.currentOptions as SpecSharpCompilerOptions;
if (soptions != null && soptions.Compatibility) return;
this.NonNullChecking = !(this.currentPreprocessorDefinedSymbols != null && this.currentPreprocessorDefinedSymbols.ContainsKey("NONONNULLTYPECHECK"));
}
/// <summary>
/// Updates the state of the drop down bars to match the current contents of the text editor window. Call this initially and every time
/// the cursor position changes.
/// </summary>
/// <param name="textView">The editor window</param>
/// <param name="line">The line on which the cursor is now positioned</param>
/// <param name="col">The column on which the cursor is now position</param>
public void SynchronizeDropdowns(IVsTextView textView, int line, int col){
this.textView = textView;
string fname = this.languageService.GetFileName(textView); if (fname == null) return;
LanguageService.Project proj = this.languageService.GetProjectFor(fname); if (proj == null) return;
object indx = proj.IndexForFileName[Identifier.For(fname).UniqueKey]; if (!(indx is int)) return;
int index = (int)indx;
if (index >= proj.parseTrees.Length) return;
CompilationUnit cu = proj.parseTrees[index] as CompilationUnit;
if (cu == null) return;
AuthoringHelper helper = this.languageService.GetAuthoringHelper();
TypeNodeList types = this.dropDownTypes;
TypeNodeList sortedTypes = this.sortedDropDownTypes;
if (cu != this.currentCompilationUnit){
this.currentCompilationUnit = cu;
//Need to reconstruct the type lists. First get the types in text order.
types = this.dropDownTypes = new TypeNodeList();
this.PopulateTypeList(types, cu.Namespaces);
//Now sort by full text name.
int n = types.Length;
if (n == 0) return;
sortedTypes = this.sortedDropDownTypes = new TypeNodeList(n);
int[] dropDownTypeGlyphs = this.dropDownTypeGlyphs = new int[n];
for (int i = 0; i < n; i++){
TypeNode t = types[i];
if (t == null){Debug.Assert(false); continue;}
string tName = t.FullName;
int glyph = dropDownTypeGlyphs[sortedTypes.Length] = helper.GetGlyph(t);
sortedTypes.Add(t);
for (int j = i-1; j >= 0; j--){
if (string.Compare(tName, sortedTypes[j].FullName) >= 0) break;
sortedTypes[j+1] = sortedTypes[j];
sortedTypes[j] = t;
dropDownTypeGlyphs[j+1] = dropDownTypeGlyphs[j];
dropDownTypeGlyphs[j] = glyph;
}
}
this.selectedType = -1;
}
//Find the type matching the given source position
int newType = 0;
for (int i = 0, n = types.Length; i < n; i++){
TypeNode t = types[i];
if (t.SourceContext.StartLine > line+1 || (t.SourceContext.StartLine == line+1 && t.SourceContext.StartColumn > col+1)){
if (i > 0) t = types[i-1];
}else if (i < n-1)
continue;
for (int j = 0; j < n; j++){
if (sortedTypes[j] != t) continue;
newType = j;
break;
}
break;
}
MemberList members = this.dropDownMembers;
MemberList sortedMembers = this.sortedDropDownMembers;
if (newType != this.selectedType){
TypeNode t = sortedTypes[newType];
if (t.Members == null) return;
//Need to reconstruct the member list. First get the members in text order.
members = t.Members;
int n = members == null ? 0 : members.Length;
MemberList newMembers = this.dropDownMembers = new MemberList(n);
//Now sort them
sortedMembers = this.sortedDropDownMembers = new MemberList(n);
string[] memSignatures = this.dropDownMemberSignatures = new string[n];
int[] dropDownMemberGlyphs = this.dropDownMemberGlyphs = new int[n];
for (int i = 0; i < n; i++){
Member mem = members[i];
if (mem == null) continue;
string memSignature = this.languageService.errorHandler.GetUnqualifiedMemberSignature(mem);
if (memSignature == null) continue;
memSignatures[sortedMembers.Length] = memSignature;
int glyph = dropDownMemberGlyphs[sortedMembers.Length] = helper.GetGlyph(mem);
newMembers.Add(mem);
sortedMembers.Add(mem);
for (int j = i-1; j >= 0; j--){
if (string.Compare(memSignature, memSignatures[j]) >= 0) break;
memSignatures[j+1] = memSignatures[j];
memSignatures[j] = memSignature;
sortedMembers[j+1] = sortedMembers[j];
sortedMembers[j] = mem;
dropDownMemberGlyphs[j+1] = dropDownMemberGlyphs[j];
dropDownMemberGlyphs[j] = glyph;
}
}
this.selectedMember = -1;
}
//Find the member matching the given source position
members = this.dropDownMembers;
int newMember = 0;
for (int i = 0, n = sortedMembers.Length; i < n; i++){
Member mem = members[i];
if (mem == null) continue;
if (mem.SourceContext.StartLine > line+1 || (mem.SourceContext.StartLine == line+1 && mem.SourceContext.StartColumn > col+1)){
if (i > 0) mem = members[i-1];
}else if (i < n-1)
continue;
for (int j = 0; j < n; j++){
if (sortedMembers[j] != mem) continue;
newMember = j;
break;
}
break;
}
if (this.dropDownBar == null) return;
if (this.selectedType != newType){
this.selectedType = newType;
this.dropDownBar.RefreshCombo(TypeAndMemberDropdownBars.DropClasses, newType);
}
if (this.selectedMember != newMember) {
this.selectedMember = newMember;
this.dropDownBar.RefreshCombo(TypeAndMemberDropdownBars.DropMethods, newMember);
}
}
internal SerializationProvider(CompilationUnit cunit) {
this.cunit = cunit;
this.module = cunit.TargetModule;
Init();
}
public abstract void ParseCompilationUnit(CompilationUnit compilationUnit);
