Expression IContractDeserializer.ParseContract (MethodContract mc, string text, ErrorNodeList errs) { Expression expression = null; currentMethodContract = mc; currentMethod = null; currentType = null; if (mc != null){ currentMethod = mc.DeclaringMethod; currentType = currentMethod.DeclaringType; } try{ Parser.ParseContract(this.assembly, text, out expression); }catch (Exception e){ ErrorNodeList eList = errs != null ? errs : this.ErrorList; if (eList != null){ #if OLDERRORS ErrorHandler eh = new ErrorHandler(eList); eh.HandleError(mc,System.Compiler.Error.GenericError,"Deserializer error: " + e.Message); #else this.assembly.MetadataImportErrors.Add(e); #endif } throw e; } return expression; }
//IDebugExpressionEvaluator public HRESULT Parse( [In,MarshalAs(UnmanagedType.LPWStr)] string pszExpression, PARSEFLAGS flags, uint radix, out string pbstrErrorMessages, out uint perrorCount, out IDebugParsedExpression ppparsedExpression ) { HRESULT hr = (HRESULT)HResult.S_OK; perrorCount = 0; pbstrErrorMessages = null; ppparsedExpression = null; ErrorNodeList errors = new ErrorNodeList(); Module symbolTable = new Module(); Document doc = this.cciEvaluator.ExprCompiler.CreateDocument(null, 1, pszExpression); IParser exprParser = this.cciEvaluator.ExprCompiler.CreateParser(doc.Name, doc.LineNumber, doc.Text, symbolTable, errors, null); Expression parsedExpression = exprParser.ParseExpression(); perrorCount = (uint)errors.Count; if (perrorCount > 0) pbstrErrorMessages = errors[0].GetMessage(); else ppparsedExpression = new BaseParsedExpression(pszExpression, parsedExpression, this); return hr; }
public override CompilerResults CompileAssemblyFromDomBatch(CompilerParameters options, CodeCompileUnit[] compilationUnits, ErrorNodeList errorNodes) { if (options == null) { Debug.Assert(false); return null; } this.Options = options; int n = compilationUnits == null ? 0 : compilationUnits.Length; if (options.OutputAssembly == null || options.OutputAssembly.Length == 0) { for (int i = 0; i < n; i++) { CodeSnippetCompileUnit csu = compilationUnits[i] as CodeSnippetCompileUnit; if (csu == null || csu.LinePragma == null || csu.LinePragma.FileName == null) continue; this.SetOutputFileName(options, csu.LinePragma.FileName); break; } } CompilerResults results = new CompilerResults(options.TempFiles); AssemblyNode assem = this.CreateAssembly(options, errorNodes); Compilation compilation = new Compilation(assem, new CompilationUnitList(n), options, this.GetGlobalScope(assem)); CodeDomTranslator cdt = new CodeDomTranslator(); SnippetParser sp = new SnippetParser(this, assem, errorNodes, options); for (int i = 0; i < n; i++) { CompilationUnit cu = cdt.Translate(this, compilationUnits[i], assem, errorNodes); sp.Visit(cu); compilation.CompilationUnits.Add(cu); cu.Compilation = compilation; } this.CompileParseTree(compilation, errorNodes); this.ProcessErrors(options, results, errorNodes); if (results.NativeCompilerReturnValue == 0) this.SetEntryPoint(compilation, results); // The following line is different from the base class method... this.SaveOrLoadAssembly(this.targetModule as AssemblyNode, options, results, errorNodes); return results; }
//IDebugExpressionEvaluator public HRESULT Parse( [In, MarshalAs(UnmanagedType.LPWStr)] string pszExpression, PARSEFLAGS flags, uint radix, out string pbstrErrorMessages, out uint perrorCount, out IDebugParsedExpression ppparsedExpression ) { HRESULT hr = (HRESULT)HResult.S_OK; perrorCount = 0; pbstrErrorMessages = null; ppparsedExpression = null; ErrorNodeList errors = new ErrorNodeList(); Module symbolTable = new Module(); Document doc = this.cciEvaluator.ExprCompiler.CreateDocument(null, 1, pszExpression); IParser exprParser = this.cciEvaluator.ExprCompiler.CreateParser(doc.Name, doc.LineNumber, doc.Text, symbolTable, errors, null); Expression parsedExpression = exprParser.ParseExpression(); perrorCount = (uint)errors.Count; if (perrorCount > 0) { pbstrErrorMessages = errors[0].GetMessage(); } else { ppparsedExpression = new BaseParsedExpression(pszExpression, parsedExpression, this); } return(hr); }
public Parser(Document doc, ErrorNodeList errors) { this.doc = doc; this.errors = errors; this.errorHandler = new ErrorHandler(errors); this.scanner = this.CreateScanner(doc, errors); }
private void Init(){ ErrorNodeList tempErrors = new ErrorNodeList(); ErrorHandler tempErrorHandler = new ErrorHandler(tempErrors); tempTypeSystem = new TypeSystem(tempErrorHandler); // Here we ignore the errors generated by this temporary checker on purpose! tempChecker = new Checker(tempErrorHandler, tempTypeSystem, null, null, null); if (errorHandler == null) { errors = new ErrorNodeList(); errorHandler = new ErrorHandler(errors); } }
public Checker(ErrorHandler errorHandler, TypeSystem typeSystem, TrivialHashtable scopeFor, TrivialHashtable ambiguousTypes, TrivialHashtable referencedLabels) : base(errorHandler) { this.typeSystem = typeSystem; this.Errors = errorHandler == null ? null : errorHandler.Errors; this.scopeFor = scopeFor; this.ambiguousTypes = ambiguousTypes; this.referencedLabels = referencedLabels; this.MayNotReferenceThisFromFieldInitializer = true; this.allowedExceptions = new TypeNodeList(); this.useGenerics = TargetPlatform.UseGenerics; this.AllowPropertiesIndexersAsRef = true; }
void WriteOutAnyErrors() { for (int i = 0, n = this.errors == null ? 0 : this.errors.Count; i < n; i++) { ErrorNode e = this.errors[i]; if (e != null) { Console.WriteLine(e.GetMessage()); } } this.errors = new ErrorNodeList(); }
/// <summary> /// return the level of the most severe error. /// </summary> /// <param name="errors"></param> /// <returns></returns> static public int ErrorSeverity(ErrorNodeList errors) { int severity = int.MaxValue; for (int i = 0; i < errors.Count; i++) { ErrorNode e = errors[i]; if (e == null) { continue; } if (e.Severity < 0) { continue; } severity = severity > e.Severity ? e.Severity : severity; } return(severity); }
/// <summary> /// Walks the supplied System.CodeDom.CodeCompileUnit and produces a corresponding CompilationUnit. /// Enters declarations into the supplied Module and errors into the supplied ErrorNodeList. /// Calls back to the supplied compiler to resolve assembly references and to create appropriate documents for code snippets. /// </summary> /// <param name="compiler">Called upon to resolve assembly references and to create Documents for snippets.</param> /// <param name="compilationUnit">The root of the CodeDOM tree to be translated into an IR CompileUnit.</param> /// <param name="targetModule">The module or assembly to which the compilation unit will be compiled.</param> /// <param name="errorNodes">Errors in the CodeDOM tree that are found during translation are added to this list.</param> /// <returns></returns> public CompilationUnit Translate(Compiler compiler, CodeCompileUnit compilationUnit, Module targetModule, ErrorNodeList errorNodes){ Debug.Assert(compiler != null); Debug.Assert(compilationUnit != null); Debug.Assert(targetModule != null); Debug.Assert(errorNodes != null); this.compiler = compiler; this.errorNodes = errorNodes; this.targetModule = targetModule; CodeSnippetCompileUnit cscu = compilationUnit as CodeSnippetCompileUnit; CompilationUnit cunit = cscu != null ? new CompilationUnitSnippet() : new CompilationUnit(); this.Translate(compilationUnit.AssemblyCustomAttributes, targetModule.Attributes); StringCollection references = compilationUnit.ReferencedAssemblies; if (references != null && references.Count > 0){ AssemblyReferenceList arefs = targetModule.AssemblyReferences; TrivialHashtable alreadyReferencedAssemblies = new TrivialHashtable(); for (int i = 0, n = arefs.Count; i < n; i++) alreadyReferencedAssemblies[arefs[i].Assembly.UniqueKey] = this; foreach (string rAssemblyName in references) compiler.AddAssemblyReferenceToModule(null, targetModule, rAssemblyName, null, errorNodes, alreadyReferencedAssemblies, false); } Namespace defaultNamespace = new Namespace(Identifier.Empty, Identifier.Empty, null, null, new NamespaceList(), null); NamespaceList nspaceList = defaultNamespace.NestedNamespaces; CodeNamespaceCollection nspaces = compilationUnit.Namespaces; if (nspaces != null) foreach (CodeNamespace cns in nspaces) nspaceList.Add(this.Translate(cns)); if (cscu == null) return cunit; Document doc = null; if (cscu.LinePragma == null) doc = compiler.CreateDocument(targetModule.Name, 1, cscu.Value); else{ doc = compiler.CreateDocument(cscu.LinePragma.FileName, cscu.LinePragma.LineNumber, cscu.Value); cunit.Name = Identifier.For(cscu.LinePragma.FileName); } cunit.SourceContext = new SourceContext(doc); defaultNamespace.SourceContext = cunit.SourceContext; return cunit; }
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; }
private IDebugProperty EvaluateExpression(uint evalFlags, uint timeout, IDebugContext context, String resultType) { if (this.debugContext == null) { this.debugContext = new DebugEnvironment(); } this.debugContext.context = context; BlockScope scope = new DebugBlockScope(this.debugContext); ErrorNodeList errors = new ErrorNodeList(); if (this.cciExpr.compiledExpression == null) { this.cciExpr.compiledExpression = (Expression)this.cciExpr.EE.ExprCompiler.CompileParseTree(this.cciExpr.ParsedExpr, scope, new Module(), errors); if (errors.Count > 0) { this.cciExpr.compiledExpression = null; } } if (this.cciExpr.compiledExpression != null) { StackFrame currentFrame = new StackFrame(); IDebugMethodSymbol methodSym = this.debugContext.context.GetContainer() as CDebugMethodSymbol; if (methodSym != null) { IDebugFieldSymbol thisSymbol = methodSym.GetThis(); if (thisSymbol != null) { currentFrame.thisObject = new Literal(thisSymbol.GetValue(null), ((MethodScope )scope.BaseClass).ThisType); } else { currentFrame.thisObject = null; } currentFrame.parameters[0] = currentFrame.thisObject; IEnumSymbol locals = methodSym.GetLocals(); if (locals != null) { for (int i = 0; ; i++) { if (locals.Current == null) { break; } Field localField = new DebugFieldNode(this.debugContext, locals.Current, new Identifier(locals.Current.Name), null, null, i); currentFrame.locals[i] = localField.GetValue(null); locals.MoveNext(); } } IEnumSymbol param = methodSym.GetParameters(); if (param != null) { for (int i = 1; ; i++) { if (param.Current == null) { break; } Field paramField = new DebugFieldNode(this.debugContext, param.Current, new Identifier(param.Current.Name), null, null, i); currentFrame.parameters[i] = paramField.GetValue(null); param.MoveNext(); } } } if (this.cciExpr.EE.ExprEvaluator == null) { this.cciExpr.EE.ExprEvaluator = new Evaluator(); } this.cciExpr.EE.ExprEvaluator.stackFrame = currentFrame; Literal resultExpr = this.cciExpr.EE.ExprEvaluator.VisitExpression(this.cciExpr.compiledExpression) as Literal; if (resultExpr != null) { if (resultExpr.Value is IDebugValue && resultExpr.Type is IDebugInfo) //already wrapped for use by debugger { return(this.cciExpr.EE.MakeProperty(this.cciExpr.Expr, ((IDebugInfo)resultExpr.Type).GetDebugType, (IDebugValue)resultExpr.Value, null)); } else if (resultExpr.Value is IDebugValue) { return(this.cciExpr.EE.MakeProperty(this.cciExpr.Expr, ((IDebugValue)resultExpr.Value).RuntimeType(), (IDebugValue)resultExpr.Value, null)); } if (resultExpr.Value != null) { return(new ExpressionEvalProperty(this.cciExpr.Expr, resultExpr.Type.FullName, resultExpr.Value.ToString(), resultExpr, this.cciExpr.EE)); } } else { return(new ExpressionEvalProperty(this.cciExpr.Expr, String.Empty, "Error Evaluating Expression.", null, this.cciExpr.EE)); } } else if (errors.Count > 0) { return(new ExpressionEvalProperty(this.cciExpr.Expr, String.Empty, errors[0].GetMessage(), null, this.cciExpr.EE)); } return(new ExpressionEvalProperty(this.cciExpr.Expr, String.Empty, "Unknown Compiler Error.", null, this.cciExpr.EE)); }
public ErrorHandler(ErrorNodeList errors){ Debug.Assert(errors != null); this.Errors = errors; }
internal void ReportErrors(ErrorNodeList errors) { TextSpan firstError = new TextSpan(); int errorMax = this.service.Preferences.MaxErrorMessages; this.taskProvider.ClearErrors(); for (int i = 0, n = errors.Length; i < n; i++ ) { ErrorNode enode = errors[i]; SourceContext ctx = enode.SourceContext; Severity severity = enode.Severity > 0 ? Severity.SevError : Severity.SevWarning; string message = enode.GetMessage(this.service.culture); if (message == null) return; //set error TextSpan span; span.iStartLine = ctx.StartLine-1; span.iStartIndex = ctx.StartColumn-1; span.iEndLine = ctx.EndLine-1; span.iEndIndex = ctx.EndColumn-1; // Don't do multi-line squiggles, instead just squiggle to the // end of the first line. if (span.iEndLine > span.iStartLine) { span.iEndLine = span.iStartLine; this.textLines.GetLengthOfLine(span.iStartLine, out span.iEndIndex); } if (TextSpanHelper.TextSpanIsEmpty( firstError) && (severity > Severity.SevWarning)) { firstError = span; } this.taskProvider.AddTask(this.CreateErrorTaskItem(span, message, severity)); //check error count if (i == errorMax) { string maxMsg = UIStrings.GetString(UIStringNames.MaxErrorsReached); TaskItem error = this.CreateErrorTaskItem(span, maxMsg, Severity.SevWarning); this.taskProvider.AddTask(error); break; } } this.taskProvider.RefreshTaskWindow(); }
private static int RunTest(string suiteName, string test, StringBuilder actualOutput, ArrayList compilerParameters, ArrayList testCaseParameters, bool xamlSuite) { Microsoft.SpecSharp.Compiler compiler = new Microsoft.SpecSharp.Compiler(); compiler.CompileAsXaml = xamlSuite; CompilerOptions options = new Microsoft.SpecSharp.SpecSharpCompilerOptions(); if (compilerParameters != null) { ErrorNodeList compilerParameterErrors = new ErrorNodeList(0); compiler.ParseCompilerParameters(options, (string[])compilerParameters.ToArray(typeof(string)), compilerParameterErrors, false); for (int i = 0, n = compilerParameterErrors.Count; i < n; i++) { ErrorNode err = compilerParameterErrors[i]; Console.WriteLine(err.GetMessage()); } } options.OutputAssembly = "assembly for suite " + suiteName + " test case " + main.assemblyNameCounter++; options.GenerateExecutable = true; options.MayLockFiles = true; options.GenerateInMemory = true; // Code that is not marked as unsafe should be verifiable. This catches cases where the compiler generates bad IL. if (!options.AllowUnsafeCode) { options.Evidence = new System.Security.Policy.Evidence(new object[] { new System.Security.Policy.Zone(System.Security.SecurityZone.Internet) }, null); } CompilerResults results = compiler.CompileAssemblyFromSource(options, test); foreach (CompilerError e in results.Errors) { Console.Write('('); Console.Write(e.Line); Console.Write(','); Console.Write(e.Column); Console.Write("): "); string warningString = null; string errorString = null; if (e.IsWarning) { if (!e.ErrorNumber.StartsWith("CS") || e.ErrorNumber.Length == 6) { if (warningString == null) { warningString = compiler.GetWarningString(); } Console.Write(warningString, e.ErrorNumber); } } else { if (!e.ErrorNumber.StartsWith("CS") || e.ErrorNumber.Length == 6) { if (errorString == null) { errorString = compiler.GetErrorString(); } Console.Write(errorString, e.ErrorNumber); } } Console.WriteLine(e.ErrorText); } if (results.NativeCompilerReturnValue != 0) { return(0); } object returnVal = null; try{ if (testCaseParameters == null) { if (results.CompiledAssembly.EntryPoint.GetParameters().Length == 0) { returnVal = results.CompiledAssembly.EntryPoint.Invoke(null, null); } else { returnVal = results.CompiledAssembly.EntryPoint.Invoke(null, new object[] { new string[0] }); } } else { returnVal = results.CompiledAssembly.EntryPoint.Invoke(null, new object[] { (string[])testCaseParameters.ToArray(typeof(string)) }); } }catch (System.Reflection.TargetInvocationException e) { throw e.InnerException; } if (returnVal is int) { return((int)returnVal); } return(0); }
public IParser CreateParser(string fileName, int lineNumber, DocumentText text, Module symbolTable, ErrorNodeList errorNodes, CompilerParameters options){ return new XamlParserStub(errorNodes, options as CompilerOptions); }
/// <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){ this.ConstructSymbolTable(compilation, errors, new TrivialHashtable()); }
public abstract CompilationUnit ParseCompilationUnit(String source, string fname, CompilerParameters parameters, ErrorNodeList errors, AuthoringSink sink);
private IDebugProperty EvaluateExpression(uint evalFlags, uint timeout, IDebugContext context, String resultType){ if (this.debugContext == null) this.debugContext = new DebugEnvironment(); this.debugContext.context = context; BlockScope scope = new DebugBlockScope(this.debugContext); ErrorNodeList errors = new ErrorNodeList(); if (this.cciExpr.compiledExpression == null){ this.cciExpr.compiledExpression = (Expression)this.cciExpr.EE.ExprCompiler.CompileParseTree(this.cciExpr.ParsedExpr, scope, new Module(), errors); if (errors.Count > 0) this.cciExpr.compiledExpression = null; } if (this.cciExpr.compiledExpression != null){ StackFrame currentFrame = new StackFrame(); IDebugMethodSymbol methodSym = this.debugContext.context.GetContainer() as CDebugMethodSymbol; if (methodSym != null){ IDebugFieldSymbol thisSymbol = methodSym.GetThis(); if (thisSymbol != null) currentFrame.thisObject = new Literal(thisSymbol.GetValue(null), ((MethodScope ) scope.BaseClass).ThisType); else currentFrame.thisObject = null; currentFrame.parameters[0] = currentFrame.thisObject; IEnumSymbol locals = methodSym.GetLocals(); if (locals != null){ for (int i=0; ; i++){ if (locals.Current == null) break; Field localField = new DebugFieldNode(this.debugContext, locals.Current, new Identifier(locals.Current.Name), null, null, i); currentFrame.locals[i] = localField.GetValue(null); locals.MoveNext(); } } IEnumSymbol param = methodSym.GetParameters(); if (param != null){ for (int i=1; ; i++){ if (param.Current == null) break; Field paramField = new DebugFieldNode(this.debugContext, param.Current, new Identifier(param.Current.Name), null, null, i); currentFrame.parameters[i] = paramField.GetValue(null); param.MoveNext(); } } } if (this.cciExpr.EE.ExprEvaluator == null) this.cciExpr.EE.ExprEvaluator = new Evaluator(); this.cciExpr.EE.ExprEvaluator.stackFrame = currentFrame; Literal resultExpr = this.cciExpr.EE.ExprEvaluator.VisitExpression(this.cciExpr.compiledExpression) as Literal; if (resultExpr != null){ if (resultExpr.Value is IDebugValue && resultExpr.Type is IDebugInfo) //already wrapped for use by debugger return this.cciExpr.EE.MakeProperty(this.cciExpr.Expr, ((IDebugInfo)resultExpr.Type).GetDebugType, (IDebugValue)resultExpr.Value, null); else if(resultExpr.Value is IDebugValue) return this.cciExpr.EE.MakeProperty(this.cciExpr.Expr, ((IDebugValue)resultExpr.Value).RuntimeType(), (IDebugValue)resultExpr.Value, null); if (resultExpr.Value != null) return new ExpressionEvalProperty(this.cciExpr.Expr, resultExpr.Type.FullName, resultExpr.Value.ToString(), resultExpr, this.cciExpr.EE); } else return new ExpressionEvalProperty(this.cciExpr.Expr, String.Empty, "Error Evaluating Expression.", null, this.cciExpr.EE); } else if (errors.Count > 0){ return new ExpressionEvalProperty(this.cciExpr.Expr, String.Empty, errors[0].GetMessage(), null, this.cciExpr.EE); } return new ExpressionEvalProperty(this.cciExpr.Expr, String.Empty, "Unknown Compiler Error.", null, this.cciExpr.EE); }
public virtual void ResolveSymbolTable(Compilation/*!*/ parsedCompilation, ErrorNodeList/*!*/ errors, out TrivialHashtable scopeFor){ scopeFor = new TrivialHashtable(); if (parsedCompilation == null) { Debug.Assert(false); return; } if (errors == null){Debug.Assert(false); return;} Scoper scoper = new Scoper(scopeFor); scoper.currentModule = parsedCompilation.TargetModule; scoper.VisitCompilation(parsedCompilation); ErrorHandler errorHandler = new ErrorHandler(errors); TrivialHashtable ambiguousTypes = new TrivialHashtable(); TrivialHashtable referencedLabels = new TrivialHashtable(); Looker looker = new Looker(null, errorHandler, scopeFor, ambiguousTypes, referencedLabels); // begin change by drunje SpecSharpCompilerOptions options = parsedCompilation.CompilerParameters as SpecSharpCompilerOptions; if (options != null) looker.AllowPointersToManagedStructures = options.AllowPointersToManagedStructures; // end change by drunje looker.currentAssembly = (looker.currentModule = parsedCompilation.TargetModule) as AssemblyNode; looker.VisitCompilation(parsedCompilation); }
protected override void SaveCompilation(Compilation compilation, AssemblyNode assem, CompilerParameters options, CompilerResults results, ErrorNodeList errorNodes) { CompilerOptions ccioptions = options as CompilerOptions; if (ccioptions != null && ccioptions.EmitSourceContextsOnly) { SourceContextWriter.Write(compilation, assem, options); if (ccioptions.XMLDocFileName != null && ccioptions.XMLDocFileName.Length > 0) assem.WriteDocumentation(new StreamWriter(ccioptions.XMLDocFileName)); } else{ base.SaveCompilation (compilation, assem, options, results, errorNodes); } }
/// <summary> /// Resolves all type expressions in the given (already parsed) compilation. /// The base types, interfaces and member signatures will all be on an equal footing with signatures from imported, /// already compiled modules and assemblies. /// </summary> public override void ResolveSymbolTable(Compilation/*!*/ parsedCompilation, ErrorNodeList/*!*/ errors){ TrivialHashtable scopeFor; this.ResolveSymbolTable(parsedCompilation, errors, out scopeFor); }
public override void ProcessErrors(CompilerParameters options, CompilerResults results, ErrorNodeList errorNodes) { if(errorNodes != null && (options is SpecSharpCompilerOptions && ((SpecSharpCompilerOptions)options).RunProgramVerifier)) errorNodes.Sort(0, errorNodes.Count); // sort the Boogie errors to make test deterministic base.ProcessErrors(options, results, errorNodes); }
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 IParser CreateParser(string fileName, int lineNumber, DocumentText text, Module symbolTable, ErrorNodeList errorNodes, CompilerParameters options){ Document document = Compiler.CreateSpecSharpDocument(fileName, lineNumber, text); return new Parser(document, errorNodes, symbolTable, options as SpecSharpCompilerOptions); }
public ErrorHandler(ErrorNodeList errors) : base(errors){ }
public Parser(Document document, ErrorNodeList errors, Module symbolTable, SpecSharpCompilerOptions options){ this.scanner = new Scanner(document, errors, options); this.ProcessOptions(options); this.errors = errors; this.module = symbolTable; }
public ErrorHandler(ErrorNodeList errors) { Debug.Assert(errors != null); this.Errors = errors; }
public XamlParserStub(ErrorNodeList errorNodes, CompilerOptions options){ this.errorNodes = errorNodes; this.options = options; }
public SnippetParser(Compiler defaultCompiler, ErrorNodeList errorNodes) { this.DefaultCompiler = defaultCompiler; this.ErrorNodes = errorNodes; this.CurrentStatementList = new StatementList(0); }
static int Main(string[] args) { if (0 < args.Length && args[0] == "/break") { string[] newArgs = new string[args.Length - 1]; Array.Copy(args, 1, newArgs, 0, newArgs.Length); args = newArgs; System.Diagnostics.Debugger.Break(); } int rc = 0; bool includeStandardResponseFile = true; string fileName = null; int n = args == null ? 0 : args.Length; bool testsuite = false; for (int i = 0; i < n; i++) { string arg = args[i]; if (arg == null || arg.Length < 1) { continue; } char ch = arg[0]; if (ch == '/') { if (arg == "/noconfig" || arg == "/nostdlib") { includeStandardResponseFile = false; } } else if (ch == '-') { if (arg == "-noconfig" || arg == "-nostdlib") { includeStandardResponseFile = false; } } else if (ch != '@') { fileName = arg; if (BetterPath.GetExtension(fileName) == ".suite") { testsuite = true; } } } if (includeStandardResponseFile) { int nFiles = 2; string globalPath = Path.GetDirectoryName(typeof(object).Assembly.Location); string globalResponseFile = Path.Combine(globalPath, "csc.rsp"); if (!File.Exists(globalResponseFile)) { globalResponseFile = null; nFiles--; } string localPath = Directory.GetCurrentDirectory(); string localResponseFile = Path.Combine(localPath, "csc.rsp"); if (!File.Exists(localResponseFile)) { localResponseFile = null; nFiles--; } if (nFiles > 0) { string[] newArgs = new string[n + nFiles]; int i = 0; if (globalResponseFile != null) { newArgs[i++] = "@" + globalResponseFile; } if (localResponseFile != null) { newArgs[i++] = "@" + localResponseFile; } for (int j = 0; j < n; j++) { newArgs[i + j] = args[j]; } args = newArgs; } } Microsoft.SpecSharp.SpecSharpCompilerOptions options = new Microsoft.SpecSharp.SpecSharpCompilerOptions(); options.TempFiles = new TempFileCollection(Directory.GetCurrentDirectory(), true); options.GenerateExecutable = true; options.MayLockFiles = true; options.CompileAndExecute = testsuite; ErrorNodeList errors = new ErrorNodeList(0); Microsoft.SpecSharp.Compiler compiler = new Microsoft.SpecSharp.Compiler(); string[] fileNames = compiler.ParseCompilerParameters(options, args, errors); if (options.DisplayCommandLineHelp) { System.Resources.ResourceManager rm = new System.Resources.ResourceManager("ssc.Messages", typeof(main).Module.Assembly); Console.WriteLine(rm.GetString("UsageTitle", null)); Console.WriteLine(options.GetOptionHelp()); return(0); } if (testsuite) { // fileNames has expanded wildcards. bool suiteSuccess = true; foreach (string file in fileNames) { suiteSuccess &= main.RunSuite(file); } if (suiteSuccess) { return(0); } return(1); } string fatalErrorString = null; n = errors.Count; for (int i = 0; i < n; i++) { ErrorNode e = errors[i]; if (e == null) { continue; } rc++; if (fatalErrorString == null) { fatalErrorString = compiler.GetFatalErrorString(); } Console.Write(fatalErrorString, e.Code.ToString("0000")); Console.WriteLine(e.GetMessage()); } if (rc > 0) { return(1); } switch (options.TargetPlatform) { case PlatformType.notSpecified: if (options.NoStandardLibrary && (options.StandardLibraryLocation == null || options.StandardLibraryLocation.Length == 0)) { Microsoft.SpecSharp.TargetPlatform.SetToV2(options.TargetPlatformLocation); } break; case PlatformType.v1: Microsoft.SpecSharp.TargetPlatform.SetToV1(options.TargetPlatformLocation); break; case PlatformType.v11: Microsoft.SpecSharp.TargetPlatform.SetToV1_1(options.TargetPlatformLocation); break; case PlatformType.v2: Microsoft.SpecSharp.TargetPlatform.SetToV2(options.TargetPlatformLocation); break; default: if (options.TargetPlatformLocation != null) //TODO: assert not null { Microsoft.SpecSharp.TargetPlatform.SetToPostV1_1(options.TargetPlatformLocation); } break; } compiler.UpdateRuntimeAssemblyLocations(options); CompilerResults results; if (fileNames.Length == 1) { if (options.EmitManifest) { results = compiler.CompileAssemblyFromFile(options, fileNames[0], new ErrorNodeList(), true); } else { results = compiler.CompileModuleFromFile(options, fileNames[0]); } } else { if (options.EmitManifest) { results = compiler.CompileAssemblyFromFileBatch(options, fileNames); } else { results = compiler.CompileModuleFromFileBatch(options, fileNames); } } string errorString = null; string warningString = null; foreach (CompilerError e in results.Errors) { if (e.FileName != null && e.FileName.Length > 0) { Console.Write(main.GetPath(e.FileName, options)); Console.Write('('); Console.Write(e.Line); Console.Write(','); Console.Write(e.Column); Console.Write("): "); } if (e.IsWarning) { if (!e.ErrorNumber.StartsWith("CS") || e.ErrorNumber.Length == 6) { if (warningString == null) { warningString = compiler.GetWarningString(); } Console.Write(warningString, e.ErrorNumber); } } else { if (!e.ErrorNumber.StartsWith("CS") || e.ErrorNumber.Length == 6) { rc++; //REVIEW: include related location errors? if (errorString == null) { errorString = compiler.GetErrorString(); } Console.Write(errorString, e.ErrorNumber); } } Console.WriteLine(e.ErrorText); } if (rc > 0) { return(1); } if ((rc = results.NativeCompilerReturnValue) == 0 && options.CompileAndExecute && results.CompiledAssembly != null && results.CompiledAssembly.EntryPoint != null) { if (results.CompiledAssembly.EntryPoint.GetParameters().Length == 0) { results.CompiledAssembly.EntryPoint.Invoke(null, null); } else { results.CompiledAssembly.EntryPoint.Invoke(null, new object[] { new string[0] }); } } if (rc > 0) { return(1); } return(0); }
// public override CompilationUnitSnippet CreateCompilationUnitSnippet(string fileName, int lineNumber, DocumentText text, Compilation compilation) // { // // return new ZonnonCompilationUnit(); // return base.CreateCompilationUnitSnippet (fileName, lineNumber, text, compilation); // } //--------------------------------------------------------------------------------- #region FrameworkOverrides public override CompilerResults CompileAssemblyFromIR(Compilation compilation, ErrorNodeList errorNodes) { ((ZonnonCompilation)compilation).init(); return(base.CompileAssemblyFromIR(compilation, errorNodes)); }
public TypeSystem(ErrorHandler errorHandler){ this.ErrorHandler = errorHandler; if (errorHandler != null) this.Errors = errorHandler.Errors; this.useGenerics = TargetPlatform.UseGenerics; }
// The function overrides the one from System.Compiler.Copiler class. // As written in the comment to the function, it // // "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." public override void ConstructSymbolTable(Compilation compilation, ErrorNodeList errors) { if (compilation == null) { Debug.Assert(false); return; } ((ZonnonCompilation)compilation).init(); ////////////////////////////// // RM: We're using out own tree for all the helpers /*RM * Module symbolTable = compilation.TargetModule = * this.CreateModule(compilation.CompilerParameters, errors, compilation); * * TrivialHashtable scopeFor = new TrivialHashtable(); * ErrorHandler eh = new ErrorHandler(errors); * TypeSystem typeSystem = new TypeSystem(eh); * * Scoper scoper = new Scoper(scopeFor); * scoper.currentModule = symbolTable; * * Looker looker = new Looker(this.GetGlobalScope(symbolTable), eh, scopeFor, typeSystem, null, null); * looker.currentAssembly = (looker.currentModule = symbolTable) as AssemblyNode; * looker.ignoreMethodBodies = true; * * Scope globalScope = compilation.GlobalScope = this.GetGlobalScope(symbolTable); * * CompilationUnitList sources = compilation.CompilationUnits; * if ( sources == null ) { Debug.Assert(false); return; } * * int n = sources.Length; * 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; } * * p.ParseCompilationUnit(compilationUnitSnippet); * * 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(); * } * * try * { * * Parser.ConvertTree(compilation.CompilationUnits[0]); * } * catch (Exception ex) * { * ERROR.InternalCompilerError("Compiler has experienced an exception processing the AST\n" + * ex.ToString() +"\n" + ex.StackTrace); * } * ((ZonnonCompilation)compilation).init(); ////////////////////////////// * * // TODO: need work here. E.g. the loops are not needed. * 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); * } * */ }
internal virtual Scanner CreateScanner(Document doc, ErrorNodeList errors) { return(new Scanner(doc, errors)); }
public AuthoringScope ParseSource(string text, int line, int col, string fname, AuthoringSink asink, ParseReason reason){ this.currentAst = null; Compilation compilation = this.GetCompilationFor(fname); Debug.Assert(compilation != null, "no compilation for: "+fname); this.currentSymbolTable = compilation.TargetModule; switch (reason){ case ParseReason.CollapsibleRegions: case ParseReason.CompleteWord: case ParseReason.MatchBraces: case ParseReason.HighlightBraces: case ParseReason.MemberSelect: case ParseReason.MemberSelectExplicit: case ParseReason.MethodTip: case ParseReason.QuickInfo: case ParseReason.Autos:{ return this.ParsePartialCompilationUnit(fname, text, line, col, asink, reason); } case ParseReason.Check:{ ErrorNodeList errors = new ErrorNodeList(); this.ParseAndAnalyzeCompilationUnit(fname, text, line, col, errors, compilation, asink); this.ReportErrors(fname, errors, asink); return this.GetAuthoringScope(); } } return null; }
public SnippetParser(IParserFactory/*!*/ defaultParserFactory, Module symbolTable, ErrorNodeList errorNodes, CompilerParameters options) { this.DefaultParserFactory = defaultParserFactory; this.ErrorNodes = errorNodes; this.SymbolTable = symbolTable; this.Options = options; this.CurrentStatementList = new StatementList(0); //^ base(); }
public virtual void ReportErrors(string fileName, ErrorNodeList errors, AuthoringSink sink){ if (sink == null) return; for (int n = errors.Count, i = n-1; i >= 0; i--){ //Scan backwards so that early errors trump later errors ErrorNode enode = errors[i]; if (enode == null || enode.Severity < 0) continue; //TODO: suppress warnings of level > set in options SourceContext context = enode.SourceContext; if (context.Document == null) continue; if (context.Document.Name != fileName) continue; sink.AddError(enode); } }
public override void CompileParseTree(Compilation compilation, ErrorNodeList errorNodes) { if (compilation == null) { Debug.Assert(false, "wrong compilation"); return; } CONTEXT.useComputeMath = ((ZonnonCompilerParameters)compilation.CompilerParameters).UseComputeMath; // Before the actual back-end compilation takes place, // we perform the Zonnon-tree to CCI-tree conversion. // Notice that we do that for the overall tree (i.e., for all sources) // and store the resulting CCI tree to CompilationUnits[0], // but do not spread subtrees to corresponding CompilationUnits. ERROR.errCount = 0; Parser.ConvertTree(compilation.CompilationUnits[0]); bool mainCompilationFailed = ERROR.errCount > 0; // ERROR.EndOfMessages(); // Module symbolTable = compilation.TargetModule; // compilation.GlobalScope = this.GetGlobalScope(symbolTable); ZonnonCompilerParameters options = compilation.CompilerParameters as ZonnonCompilerParameters; if (options == null) { options = new ZonnonCompilerParameters(); } // Walk IR looking up names #if DEBUG if (options.Debug) { System.Console.Write("Scoper is working..."); } #endif ErrorHandler eh = new ErrorHandler(errorNodes); TrivialHashtable ambiguousTypes = new TrivialHashtable(); TrivialHashtable referencedLabels = new TrivialHashtable(); TrivialHashtable scopeFor = new TrivialHashtable(); TypeSystem typeSystem = new TypeSystem(eh); Scoper scoper = new Scoper(scopeFor); scoper.VisitCompilation(compilation); #if DEBUG if (options.Debug) { System.Console.WriteLine("Done."); System.Console.Write("Looker is working... "); } #endif Looker looker = new Looker(compilation.GlobalScope, eh, scopeFor, typeSystem, ambiguousTypes, referencedLabels); looker.VisitCompilation(compilation); // Walk IR inferring types and resolving overloads if (!mainCompilationFailed) // Resolve only if no errors { Resolver resolver = new Resolver(eh, typeSystem); resolver.VisitCompilation(compilation); // Walk IR checking for semantic errors and repairing it so that it the next walk will work Checker checker = new Checker(eh, typeSystem, ambiguousTypes, referencedLabels); checker.VisitCompilation(compilation); // Walk IR reducing it to nodes that have predefined mappings to MD+IL Normalizer normalizer = new Normalizer(typeSystem); normalizer.VisitCompilation(compilation); Analyzer analyzer = new Analyzer(typeSystem, compilation); analyzer.VisitCompilation(compilation); } #if DEBUG if (options.Debug) { System.Console.WriteLine("Done."); } #endif }
public abstract void ParseAndAnalyzeCompilationUnit(string fname, string source, int line, int col, ErrorNodeList errors, Compilation compilation, AuthoringSink sink);
public override IParser CreateParser(string fileName, int lineNumber, DocumentText text, Module symbolTable, ErrorNodeList errors, CompilerParameters options) { // Document document = this.CreateDocument(fileName, lineNumber, text); // return new Parser(symbolTable, document, errorNodes); // Document document = this.CreateDocument(fileName, lineNumber, text); Parser parser = new Parser(document, errors, symbolTable, options as ZonnonCompilerParameters); //Parser.debug = options is ZonnonCompilerParameters ? ((ZonnonCompilerParameters)options).Debug : false; //Parser.debugT = options is ZonnonCompilerParameters ? ((ZonnonCompilerParameters)options).DebugT : false; return(parser); }
public abstract CompilationUnit ParseCompilationUnit(string fname, string source, ErrorNodeList errors, Compilation compilation, AuthoringSink sink);
internal Class CreateSerializerFor(TypeNode type, ErrorHandler errorHandler) { this.errorHandler = errorHandler; this.errors = errorHandler.Errors; return CreateSerializerFor(type); }
void WriteOutAnyErrors(){ for (int i = 0, n = this.errors == null ? 0 : this.errors.Count; i < n; i++){ ErrorNode e = this.errors[i]; if (e != null) Console.WriteLine(e.GetMessage()); } this.errors = new ErrorNodeList(); }
public Type GetSerializer(XmlSerializer caller, Type t, ref string rootName, ref string rootNamespace) { // start again with clean error list - do NOT return errors from the temporary checker. errors = new ErrorNodeList(); errorHandler = new ErrorHandler(errors); TypeNode type = TypeNode.GetTypeNode(t); string nspace = GetSerializerNamespace(type); string serializerClassName = GetSerializerName(type); string fullName = nspace + ((nspace != "" && nspace != null) ? "." : "") + serializerClassName; // Structural types have no container element name. if (!IsStructuralType(type) && !(type is EnumNode)) { if (rootName == null) { Identifier name = Checker.GetDefaultElementName(type); rootName = name.Name; if (rootNamespace == null && name.Prefix != null) { rootNamespace = name.Prefix.Name; } } } if (caller.GetType().FullName == fullName) return caller.GetType(); AssemblyNode assembly = AssemblyNode.GetAssembly(t.Assembly, cache, false, true); // see if we can find a serializer in the same assembly as the given type. TypeNode serializerType = assembly.GetType(Identifier.For(nspace), Identifier.For(serializerClassName)); if (serializerType != null) { Type result = serializerType.GetRuntimeType(); Debug.Assert(result != null, "GetRuntimeType() failed on " + serializerType.FullName); return result; } System.Reflection.Assembly sasm = (System.Reflection.Assembly)genCache[t]; if (sasm == null) { ComegaCompilerOptions options = new ComegaCompilerOptions(); options.OutputAssembly = type.Name + "Serializer.dll"; options.GenerateExecutable = false; options.ModuleKind = ModuleKindFlags.DynamicallyLinkedLibrary; if (DumpOption == null) { DumpOption = System.Environment.GetEnvironmentVariable("DEBUG_SERIALIZER"); if (DumpOption == null) DumpOption = ""; } options.GenerateInMemory = (DumpOption == ""); options.DumpTree = (DumpOption != ""); options.IncludeDebugInformation = (DumpOption != ""); options.TempFiles = new TempFileCollection(Directory.GetCurrentDirectory(), true); string writerAssembly = typeof(XmlSerializationWriter).Assembly.Location; options.ReferencedAssemblies.Add(writerAssembly); string xmlAssembly = typeof(XmlTextReader).Assembly.Location; options.ReferencedAssemblies.Add(xmlAssembly); Compiler compiler = new Compiler(); Module module = compiler.CreateModule(options, errors); CompilationUnit cu = CreateCompilationUnit(module, type); // so we can find all the structural types already defined in the assembly // associated with the type we are building the serializer for. cu.TargetModule.AssemblyReferences.Add(new AssemblyReference(assembly)); CompilerResults results = compiler.CompileAssemblyFromIR(options, cu, errors); if (errors.Length > 0) { throw new XmlSerializerException(errors[0].GetMessage()); } else if (results.Errors.Count>0) { throw new XmlSerializerException(results.Errors[0].ErrorText); } else { sasm = results.CompiledAssembly; if (sasm == null) throw new XmlSerializerException(RuntimeError.SerializationAssembly); genCache[t] = sasm; } } Type instanceType = sasm.GetType(fullName, false, false); if (instanceType == null) throw new XmlSerializerException(RuntimeError.SerializationClass, fullName); return instanceType; }
public XmlDocument Compile(string text, ErrorNodeList errors) { return new Parser(new Document("InMemoryString", new DocumentText(text)), errors).ParseDocument(); }