public static object Parse(SeekableStreamReader reader, SourceFile sourceFile, ModuleContainer module, ParserSession session, Report report, int lineModifier = 0, int colModifier = 0) { var file = new CompilationSourceFile(module, sourceFile); module.AddTypeContainer(file); object parser = null; if (sourceFile.FileType == SourceFileType.CSharp) { CSharpParser csParser = new CSharpParser(reader, file, report, session); csParser.Lexer.Line += lineModifier; csParser.Lexer.Column += colModifier; csParser.Lexer.sbag = new SpecialsBag(); csParser.parse(); parser = csParser; } else { PlayScriptParser psParser = new PlayScriptParser(reader, file, report, session); psParser.parsing_playscript = sourceFile.PsExtended; psParser.Lexer.Line += lineModifier; psParser.Lexer.Column += colModifier; psParser.Lexer.sbag = new SpecialsBag(); psParser.parse(); parser = psParser; } return(parser); }
public void Parse(SeekableStreamReader reader, CompilationSourceFile file, ModuleContainer module) { file.NamespaceContainer = new NamespaceContainer(null, module, null, file); CSharpParser parser = new CSharpParser(reader, file); parser.parse(); }
/// <summary> /// Parses the code and generate the compiled units. /// </summary> /// <param name="_code">The source code that is being parsed.</param> /// <returns>Zero if success, otherwise a non-zero value would return.</returns> /// <remarks> /// For more information about compiled units, please refer to <see cref="System.CodeDom.CodeCompileUnit"/>. /// </remarks> /// <seealso cref="System.CodeDom.CodeCompileUnit"/> public int Parse(string _code) { MemoryStream memoryStream = new MemoryStream(Encoding.ASCII.GetBytes(_code)); CSharpParser parser = new CSharpParser(null, memoryStream, null); int ret = parser.parse(); codeCompileUnit__ = parser.Builder.CurrCompileUnit; return(ret); }
public static void Parse(SeekableStreamReader reader, SourceFile sourceFile, ModuleContainer module, ParserSession session, Report report) { var file = new CompilationSourceFile(module, sourceFile); module.AddTypeContainer(file); CSharpParser parser = new CSharpParser(reader, file, report, session); parser.parse(); }
public CSharpParser Parse(SeekableStreamReader reader, SourceFile sourceFile, ModuleContainer module) { var file = new CompilationSourceFile(module, sourceFile); module.AddTypeContainer(file); CSharpParser parser = new CSharpParser(reader, file); parser.Lexer.sbag = new SpecialsBag(); parser.parse(); return(parser); }
public static void Parse(SeekableStreamReader reader, SourceFile source, ModuleContainer module, ParserSession session, Report report) { // Create the compilation source CompilationSourceFile file = new CompilationSourceFile(module, source); // Add to module module.AddTypeContainer(file); // Create the parser and run CSharpParser parser = new CSharpParser(reader, file, report, session); parser.parse(); }
public static CompilerCompilationUnit ParseFile(string[] args, Stream input, string inputFile, ReportPrinter reportPrinter) { lock (parseLock) { try { // Driver d = Driver.Create (args, false, null, reportPrinter); // if (d == null) // return null; var r = new Report(reportPrinter); CommandLineParser cmd = new CommandLineParser(r, Console.Out); var setting = cmd.ParseArguments(args); if (setting == null || r.Errors > 0) { return(null); } setting.Version = LanguageVersion.V_5; CompilerContext ctx = new CompilerContext(setting, r); var files = new List <CompilationSourceFile> (); var unit = new CompilationSourceFile(inputFile, inputFile, 0); var module = new ModuleContainer(ctx); unit.NamespaceContainer = new NamespaceContainer(null, module, null, unit); files.Add(unit); Location.Initialize(files); // TODO: encoding from driver SeekableStreamReader reader = new SeekableStreamReader(input, Encoding.UTF8); RootContext.ToplevelTypes = module; CSharpParser parser = new CSharpParser(reader, unit); parser.Lexer.TabSize = 1; parser.Lexer.sbag = new SpecialsBag(); parser.LocationsBag = new LocationsBag(); parser.UsingsBag = new UsingsBag(); parser.parse(); return(new CompilerCompilationUnit() { ModuleCompiled = RootContext.ToplevelTypes, LocationsBag = parser.LocationsBag, UsingsBag = parser.UsingsBag, SpecialsBag = parser.Lexer.sbag, LastYYValue = parser.LastYYVal }); } finally { Reset(); } } }
public static CSharpParser Parse(SeekableStreamReader reader, SourceFile sourceFile, ModuleContainer module, ParserSession session, Report report, int lineModifier = 0, int colModifier = 0) { var file = new CompilationSourceFile(module, sourceFile); module.AddTypeContainer(file); CSharpParser parser = new CSharpParser(reader, file, report, session); parser.Lexer.Line += lineModifier; parser.Lexer.Column += colModifier; parser.Lexer.sbag = new SpecialsBag(); parser.parse(); return(parser); }
public static void Parse(SeekableStreamReader reader, SourceFile sourceFile, ModuleContainer module, ParserSession session, Report report) { var file = new CompilationSourceFile(module, sourceFile); module.AddTypeContainer(file); if (sourceFile.FileType == SourceFileType.CSharp) { CSharpParser parser = new CSharpParser(reader, file, session); parser.parse(); } else { PlayScriptParser parser = new PlayScriptParser(reader, file, session); parser.parsing_playscript = sourceFile.PsExtended; parser.parse(); } }
public void Simple() { //string content = @"class A { }"; string content = @" class Foo { void Bar () { completionList.Add (""delegate"" + sb, ""md-keyword"", GettextCatalog.GetString (""Creates anonymous delegate.""), ""delegate"" + sb + "" {"" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent + TextEditorProperties.IndentString + ""|"" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent +""};""); } }" ; var stream = new MemoryStream(Encoding.UTF8.GetBytes(content)); var ctx = new CompilerContext(new CompilerSettings(), new Report(new AssertReportPrinter())); ModuleContainer module = new ModuleContainer(ctx); CSharpParser parser = new CSharpParser( new SeekableStreamReader(stream, Encoding.UTF8), new CompilationUnit("name", "path", 0), module); RootContext.ToplevelTypes = module; Location.AddFile(ctx.Report, "asdfas"); Location.Initialize(); parser.LocationsBag = new LocationsBag(); parser.parse(); var m = module.Types[0].Methods[0] as Method; var s = m.Block.FirstStatement; var o = s.loc.Column; module.Accept(new TestVisitor()); }
public void Parse(string filename) { CSharpParser parser; ArrayList defines = new ArrayList(); Stream input; int id; if (fileIDs [filename] == null) { fileIDs [filename] = (object)files; id = (int)fileIDs [filename]; fileNames [id] = filename; files++; } else { id = (int)fileIDs [filename]; } try { input = File.OpenRead(filename); } catch { Console.WriteLine("Source file '" + filename + "' could not be opened"); return; } StreamReader reader = new StreamReader(input); parser = new CSharpParser(reader, filename, defines, db, id); //parser.yacc_verbose = yacc_verbose; try { parser.parse(); } catch (Exception ex) { Console.WriteLine("Compilation aborted: " + ex); } finally { input.Close(); } }
public void Simple() { //string content = @"class A { }"; string content = @" class Foo { void Bar () { completionList.Add (""delegate"" + sb, ""md-keyword"", GettextCatalog.GetString (""Creates anonymous delegate.""), ""delegate"" + sb + "" {"" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent + TextEditorProperties.IndentString + ""|"" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent +""};""); } }" ; var stream = new MemoryStream(Encoding.UTF8.GetBytes(content)); var ctx = new CompilerContext(new CompilerSettings(), new AssertReportPrinter()); ModuleContainer module = new ModuleContainer(ctx); var file = new SourceFile("test", "asdfas", 0); CSharpParser parser = new CSharpParser( new SeekableStreamReader(stream, Encoding.UTF8), new CompilationSourceFile(module, file), ctx.Report, new ParserSession()); RootContext.ToplevelTypes = module; Location.Initialize(new List <SourceFile> { file }); parser.parse(); Assert.AreEqual(0, ctx.Report.Errors); module.Accept(new TestVisitor()); }
// // Processes "see" or "seealso" elements from cref attribute. // void HandleXrefCommon(MemberCore mc, XmlElement xref) { string cref = xref.GetAttribute("cref"); // when, XmlReader, "if (cref == null)" if (!xref.HasAttribute("cref")) { return; } // Nothing to be resolved the reference is marked explicitly if (cref.Length > 2 && cref [1] == ':') { return; } // Additional symbols for < and > are allowed for easier XML typing cref = cref.Replace('{', '<').Replace('}', '>'); var encoding = module.Compiler.Settings.Encoding; var s = new MemoryStream(encoding.GetBytes(cref)); var source_file = new CompilationSourceFile(doc_module, mc.Location.SourceFile); var report = new Report(doc_module.Compiler, new NullReportPrinter()); if (session == null) { session = new ParserSession { UseJayGlobalArrays = true } } ; SeekableStreamReader seekable = new SeekableStreamReader(s, encoding, session.StreamReaderBuffer); var parser = new CSharpParser(seekable, source_file, report, session); ParsedParameters = null; ParsedName = null; ParsedBuiltinType = null; ParsedOperator = null; parser.Lexer.putback_char = Tokenizer.DocumentationXref; parser.Lexer.parsing_generic_declaration_doc = true; parser.parse(); if (report.Errors > 0) { Report.Warning(1584, 1, mc.Location, "XML comment on `{0}' has syntactically incorrect cref attribute `{1}'", mc.GetSignatureForError(), cref); xref.SetAttribute("cref", "!:" + cref); return; } MemberSpec member; string prefix = null; FullNamedExpression fne = null; // // Try built-in type first because we are using ParsedName as identifier of // member names on built-in types // if (ParsedBuiltinType != null && (ParsedParameters == null || ParsedName != null)) { member = ParsedBuiltinType.Type; } else { member = null; } if (ParsedName != null || ParsedOperator.HasValue) { TypeSpec type = null; string member_name = null; if (member == null) { if (ParsedOperator.HasValue) { type = mc.CurrentType; } else if (ParsedName.Left != null) { fne = ResolveMemberName(mc, ParsedName.Left); if (fne != null) { var ns = fne as NamespaceExpression; if (ns != null) { fne = ns.LookupTypeOrNamespace(mc, ParsedName.Name, ParsedName.Arity, LookupMode.Probing, Location.Null); if (fne != null) { member = fne.Type; } } else { type = fne.Type; } } } else { fne = ResolveMemberName(mc, ParsedName); if (fne == null) { type = mc.CurrentType; } else if (ParsedParameters == null) { member = fne.Type; } else if (fne.Type.MemberDefinition == mc.CurrentType.MemberDefinition) { member_name = Constructor.ConstructorName; type = fne.Type; } } } else { type = (TypeSpec)member; member = null; } if (ParsedParameters != null) { var old_printer = mc.Module.Compiler.Report.SetPrinter(new NullReportPrinter()); try { var context = new DocumentationMemberContext(mc, ParsedName ?? MemberName.Null); foreach (var pp in ParsedParameters) { pp.Resolve(context); } } finally { mc.Module.Compiler.Report.SetPrinter(old_printer); } } if (type != null) { if (member_name == null) { member_name = ParsedOperator.HasValue ? Operator.GetMetadataName(ParsedOperator.Value) : ParsedName.Name; } int parsed_param_count; if (ParsedOperator == Operator.OpType.Explicit || ParsedOperator == Operator.OpType.Implicit) { parsed_param_count = ParsedParameters.Count - 1; } else if (ParsedParameters != null) { parsed_param_count = ParsedParameters.Count; } else { parsed_param_count = 0; } int parameters_match = -1; do { var members = MemberCache.FindMembers(type, member_name, true); if (members != null) { foreach (var m in members) { if (ParsedName != null && m.Arity != ParsedName.Arity) { continue; } if (ParsedParameters != null) { IParametersMember pm = m as IParametersMember; if (pm == null) { continue; } if (m.Kind == MemberKind.Operator && !ParsedOperator.HasValue) { continue; } var pm_params = pm.Parameters; int i; for (i = 0; i < parsed_param_count; ++i) { var pparam = ParsedParameters[i]; if (i >= pm_params.Count || pparam == null || pparam.TypeSpec == null || !TypeSpecComparer.Override.IsEqual(pparam.TypeSpec, pm_params.Types[i]) || (pparam.Modifier & Parameter.Modifier.RefOutMask) != (pm_params.FixedParameters[i].ModFlags & Parameter.Modifier.RefOutMask)) { if (i > parameters_match) { parameters_match = i; } i = -1; break; } } if (i < 0) { continue; } if (ParsedOperator == Operator.OpType.Explicit || ParsedOperator == Operator.OpType.Implicit) { if (pm.MemberType != ParsedParameters[parsed_param_count].TypeSpec) { parameters_match = parsed_param_count + 1; continue; } } else { if (parsed_param_count != pm_params.Count) { continue; } } } if (member != null) { Report.Warning(419, 3, mc.Location, "Ambiguous reference in cref attribute `{0}'. Assuming `{1}' but other overloads including `{2}' have also matched", cref, member.GetSignatureForError(), m.GetSignatureForError()); break; } member = m; } } // Continue with parent type for nested types if (member == null) { type = type.DeclaringType; } else { type = null; } } while (type != null); if (member == null && parameters_match >= 0) { for (int i = parameters_match; i < parsed_param_count; ++i) { Report.Warning(1580, 1, mc.Location, "Invalid type for parameter `{0}' in XML comment cref attribute `{1}'", (i + 1).ToString(), cref); } if (parameters_match == parsed_param_count + 1) { Report.Warning(1581, 1, mc.Location, "Invalid return type in XML comment cref attribute `{0}'", cref); } } } } if (member == null) { Report.Warning(1574, 1, mc.Location, "XML comment on `{0}' has cref attribute `{1}' that could not be resolved", mc.GetSignatureForError(), cref); cref = "!:" + cref; } else if (member == InternalType.Namespace) { cref = "N:" + fne.GetSignatureForError(); } else { prefix = GetMemberDocHead(member); cref = prefix + member.GetSignatureForDocumentation(); } xref.SetAttribute("cref", cref); }
// // Parses the string @input and returns a CSharpParser if succeeful. // // if @silent is set to true then no errors are // reported to the user. This is used to do various calls to the // parser and check if the expression is parsable. // // @partial_input: if @silent is true, then it returns whether the // parsed expression was partial, and more data is needed // CSharpParser ParseString(ParseMode mode, string input, out bool partial_input) { partial_input = false; Reset(); var enc = ctx.Settings.Encoding; var s = new MemoryStream(enc.GetBytes(input)); SeekableStreamReader seekable = new SeekableStreamReader(s, enc); InputKind kind = ToplevelOrStatement(seekable); if (kind == InputKind.Error) { if (mode == ParseMode.ReportErrors) { ctx.Report.Error(-25, "Detection Parsing Error"); } partial_input = false; return(null); } if (kind == InputKind.EOF) { if (mode == ParseMode.ReportErrors) { Console.Error.WriteLine("Internal error: EOF condition should have been detected in a previous call with silent=true"); } partial_input = true; return(null); } seekable.Position = 0; source_file.DeclarationFound = false; CSharpParser parser = new CSharpParser(seekable, source_file, new ParserSession()); if (kind == InputKind.StatementOrExpression) { parser.Lexer.putback_char = Tokenizer.EvalStatementParserCharacter; parser.Lexer.parsing_block++; ctx.Settings.StatementMode = true; } else { parser.Lexer.putback_char = Tokenizer.EvalCompilationUnitParserCharacter; ctx.Settings.StatementMode = false; } if (mode == ParseMode.GetCompletions) { parser.Lexer.CompleteOnEOF = true; } ReportPrinter old_printer = null; if ((mode == ParseMode.Silent || mode == ParseMode.GetCompletions)) { old_printer = ctx.Report.SetPrinter(new StreamReportPrinter(TextWriter.Null)); } try { parser.parse(); } finally { if (ctx.Report.Errors != 0) { if (mode != ParseMode.ReportErrors && parser.UnexpectedEOF) { partial_input = true; } if (parser.undo != null) { parser.undo.ExecuteUndo(); } parser = null; } if (old_printer != null) { ctx.Report.SetPrinter(old_printer); } } return(parser); }
// Mimicked from https://github.com/kkdevs/Patchwork/blob/master/Patchwork/MonoScript.cs#L124 public static Assembly Compile(Dictionary <string, byte[]> sources, TextWriter logger = null) { ReportPrinter reporter = logger == null ? new ConsoleReportPrinter() : new StreamReportPrinter(logger); Location.Reset(); var dllName = $"compiled_{DateTime.Now.Ticks}"; compiledAssemblies.Add(dllName); var ctx = CreateContext(reporter); ctx.Settings.SourceFiles.Clear(); var i = 0; SeekableStreamReader GetFile(SourceFile file) { return(new SeekableStreamReader(new MemoryStream(sources[file.OriginalFullPathName]), Encoding.UTF8)); } foreach (var source in sources) { ctx.Settings.SourceFiles.Add(new SourceFile(Path.GetFileName(source.Key), source.Key, i, GetFile)); i++; } var container = new ModuleContainer(ctx); RootContext.ToplevelTypes = container; Location.Initialize(ctx.Settings.SourceFiles); var session = new ParserSession { UseJayGlobalArrays = true, LocatedTokens = new LocatedToken[15000] }; container.EnableRedefinition(); foreach (var sourceFile in ctx.Settings.SourceFiles) { var stream = sourceFile.GetInputStream(sourceFile); var source = new CompilationSourceFile(container, sourceFile); source.EnableRedefinition(); container.AddTypeContainer(source); var parser = new CSharpParser(stream, source, session); parser.parse(); } var ass = new AssemblyDefinitionDynamic(container, dllName, $"{dllName}.dll"); container.SetDeclaringAssembly(ass); var importer = new ReflectionImporter(container, ctx.BuiltinTypes); ass.Importer = importer; var loader = new DynamicLoader(importer, ctx); ImportAppdomainAssemblies(a => importer.ImportAssembly(a, container.GlobalRootNamespace)); loader.LoadReferences(container); ass.Create(AppDomain.CurrentDomain, AssemblyBuilderAccess.RunAndSave); container.CreateContainer(); loader.LoadModules(ass, container.GlobalRootNamespace); container.InitializePredefinedTypes(); container.Define(); if (ctx.Report.Errors > 0) { logger?.WriteLine("Found errors! Aborting compilation..."); return(null); } try { ass.Resolve(); ass.Emit(); container.CloseContainer(); ass.EmbedResources(); } catch (Exception e) { logger?.WriteLine($"Failed to compile because {e}"); return(null); } return(ass.Builder); }
public Assembly DoStaticCompile(IEnumerable <object> sources, string prefix = "compiled_") { reporter.Reset(); Location.Reset(); var ctx = BuildContext(reporter); ctx.Settings.SourceFiles.Clear(); int i = 0; var allBytes = new MemoryStream(); List <Assembly> imports = new List <Assembly>(); foreach (var fo in sources) { Assembly impass = fo as Assembly; if (impass != null) { imports.Add(impass); continue; } var f = fo as string; byte[] fbuf = fo as byte[]; if (f != null) { if (!f.EndsWith(".cs")) { continue; } var bname = (f + "\n").ToBytes(); allBytes.Write(bname, 0, bname.Length); fbuf = File.ReadAllBytes(f); allBytes.Write(fbuf, 0, fbuf.Length); } else { allBytes.Write(fbuf, 0, fbuf.Length); f = null; } i++; ctx.Settings.SourceFiles.Add(new SourceFile(f == null ? "<eval>" : Path.GetFileName(f), f ?? "<eval>", i, (o) => { return(new SeekableStreamReader(new MemoryStream(fbuf), Encoding.UTF8)); })); } string dllname = prefix + (counter++) + ".dll"; if (tempdir != null) { if (hashkey != null) { var hb = hashkey.ToBytes(); allBytes.Write(hb, 0, hb.Length); } var hash = prefix + Ext.HashToString(allBytes.ToArray()).Substring(0, 12).ToLower() + ".dll"; if (hashkey == null) { hashkey = hash; } dllname = Path.Combine(tempdir, hash); if (File.Exists(dllname)) { var nam = AssemblyName.GetAssemblyName(dllname); unloaded.Remove(nam.Name.ToLower()); return(Assembly.Load(nam)); } } var mod = new ModuleContainer(ctx); RootContext.ToplevelTypes = mod; Location.Initialize(ctx.Settings.SourceFiles); var session = new ParserSession() { UseJayGlobalArrays = true, LocatedTokens = new LocatedToken[15000] }; mod.EnableRedefinition(); foreach (var finfo in ctx.Settings.SourceFiles) { var fs = finfo.GetInputStream(finfo); var csrc = new CompilationSourceFile(mod, finfo); csrc.EnableRedefinition(); mod.AddTypeContainer(csrc); var parser = new CSharpParser(fs, csrc, session); parser.parse(); } Debug.Log("Defining new assembly " + dllname); var ass = new AssemblyDefinitionDynamic(mod, Path.GetFileNameWithoutExtension(dllname), dllname); mod.SetDeclaringAssembly(ass); var importer = new ReflectionImporter(mod, ctx.BuiltinTypes); ass.Importer = importer; var loader = new DynamicLoader(importer, ctx); ImportAssemblies((a) => importer.ImportAssembly(a, mod.GlobalRootNamespace), prefix); foreach (var impa in imports) { importer.ImportAssembly(impa, mod.GlobalRootNamespace); } loader.LoadReferences(mod); ass.Create(AppDomain.CurrentDomain, AssemblyBuilderAccess.RunAndSave); mod.CreateContainer(); loader.LoadModules(ass, mod.GlobalRootNamespace); mod.InitializePredefinedTypes(); mod.Define(); if (ctx.Report.Errors > 0) { tw.WriteLine($"{ctx.Report.Errors} errors, aborting."); return(null); } try { ass.Resolve(); ass.Emit(); mod.CloseContainer(); ass.EmbedResources(); } catch (Exception ex) { tw.WriteLine($"Link error: " + ex.ToString()); return(null); } if (tempdir != null) { ass.Save(); } return(ass.Builder); }
public void Parse(SeekableStreamReader reader, CompilationUnit file, ModuleContainer module) { CSharpParser parser = new CSharpParser(reader, file, module); parser.parse(); }
// // Parses the string @input and returns a CSharpParser if succeeful. // // if @silent is set to true then no errors are // reported to the user. This is used to do various calls to the // parser and check if the expression is parsable. // // @partial_input: if @silent is true, then it returns whether the // parsed expression was partial, and more data is needed // CSharpParser ParseString(ParseMode mode, string input, out bool partial_input) { partial_input = false; Reset(); Tokenizer.LocatedToken.Initialize(); Stream s = new MemoryStream(Encoding.UTF8.GetBytes(input)); SeekableStreamReader seekable = new SeekableStreamReader(s, Encoding.UTF8); InputKind kind = ToplevelOrStatement(seekable); if (kind == InputKind.Error) { if (mode == ParseMode.ReportErrors) { ctx.Report.Error(-25, "Detection Parsing Error"); } partial_input = false; return(null); } if (kind == InputKind.EOF) { if (mode == ParseMode.ReportErrors) { Console.Error.WriteLine("Internal error: EOF condition should have been detected in a previous call with silent=true"); } partial_input = true; return(null); } seekable.Position = 0; if (ns == null) { ns = new NamespaceEntry(module, null, Location.SourceFiles[0], null); } ns.DeclarationFound = false; CSharpParser parser = new CSharpParser(seekable, Location.SourceFiles [0], module, ns); if (kind == InputKind.StatementOrExpression) { parser.Lexer.putback_char = Tokenizer.EvalStatementParserCharacter; ctx.Settings.StatementMode = true; } else { parser.Lexer.putback_char = Tokenizer.EvalCompilationUnitParserCharacter; ctx.Settings.StatementMode = false; } if (mode == ParseMode.GetCompletions) { parser.Lexer.CompleteOnEOF = true; } ReportPrinter old_printer = null; if ((mode == ParseMode.Silent || mode == ParseMode.GetCompletions) && CSharpParser.yacc_verbose_flag == 0) { old_printer = ctx.Report.SetPrinter(new StreamReportPrinter(TextWriter.Null)); } try { parser.parse(); } finally { if (ctx.Report.Errors != 0) { if (mode != ParseMode.ReportErrors && parser.UnexpectedEOF) { partial_input = true; } if (parser.undo != null) { parser.undo.ExecuteUndo(); } parser = null; } if (old_printer != null) { ctx.Report.SetPrinter(old_printer); } } return(parser); }
// // Parses the string @input and returns a CSharpParser if succeeful. // // if @silent is set to true then no errors are // reported to the user. This is used to do various calls to the // parser and check if the expression is parsable. // // @partial_input: if @silent is true, then it returns whether the // parsed expression was partial, and more data is needed // static CSharpParser ParseString(ParseMode mode, string input, out bool partial_input) { partial_input = false; Reset(); queued_fields.Clear(); Tokenizer.LocatedToken.Initialize(); Stream s = new MemoryStream(Encoding.Default.GetBytes(input)); SeekableStreamReader seekable = new SeekableStreamReader(s, Encoding.Default); InputKind kind = ToplevelOrStatement(seekable); if (kind == InputKind.Error) { if (mode == ParseMode.ReportErrors) { ctx.Report.Error(-25, "Detection Parsing Error"); } partial_input = false; return(null); } if (kind == InputKind.EOF) { if (mode == ParseMode.ReportErrors) { Console.Error.WriteLine("Internal error: EOF condition should have been detected in a previous call with silent=true"); } partial_input = true; return(null); } seekable.Position = 0; CSharpParser parser = new CSharpParser(seekable, Location.SourceFiles [0], RootContext.ToplevelTypes); if (kind == InputKind.StatementOrExpression) { parser.Lexer.putback_char = Tokenizer.EvalStatementParserCharacter; RootContext.StatementMode = true; } else { // // Do not activate EvalCompilationUnitParserCharacter until // I have figured out all the limitations to invoke methods // in the generated classes. See repl.txt // parser.Lexer.putback_char = Tokenizer.EvalUsingDeclarationsParserCharacter; //parser.Lexer.putback_char = Tokenizer.EvalCompilationUnitParserCharacter; RootContext.StatementMode = false; } if (mode == ParseMode.GetCompletions) { parser.Lexer.CompleteOnEOF = true; } ReportPrinter old_printer = null; if ((mode == ParseMode.Silent || mode == ParseMode.GetCompletions) && CSharpParser.yacc_verbose_flag == 0) { old_printer = SetPrinter(new StreamReportPrinter(TextWriter.Null)); } try { parser.parse(); } finally { if (ctx.Report.Errors != 0) { if (mode != ParseMode.ReportErrors && parser.UnexpectedEOF) { partial_input = true; } parser.undo.ExecuteUndo(); parser = null; } if (old_printer != null) { SetPrinter(old_printer); } } return(parser); }
// // Parses the string @input and returns a CSharpParser if succeeful. // // if @silent is set to true then no errors are // reported to the user. This is used to do various calls to the // parser and check if the expression is parsable. // // @partial_input: if @silent is true, then it returns whether the // parsed expression was partial, and more data is needed // static CSharpParser ParseString(bool silent, string input, out bool partial_input) { partial_input = false; Reset(); queued_fields.Clear(); Stream s = new MemoryStream(Encoding.Default.GetBytes(input)); SeekableStreamReader seekable = new SeekableStreamReader(s, Encoding.Default); InputKind kind = ToplevelOrStatement(seekable); if (kind == InputKind.Error) { if (!silent) { Report.Error(-25, "Detection Parsing Error"); } partial_input = false; return(null); } if (kind == InputKind.EOF) { if (silent == false) { Console.Error.WriteLine("Internal error: EOF condition should have been detected in a previous call with silent=true"); } partial_input = true; return(null); } seekable.Position = 0; CSharpParser parser = new CSharpParser(seekable, (CompilationUnit)Location.SourceFiles [0]); parser.ErrorOutput = Report.Stderr; if (kind == InputKind.StatementOrExpression) { parser.Lexer.putback_char = Tokenizer.EvalStatementParserCharacter; RootContext.StatementMode = true; } else { // // Do not activate EvalCompilationUnitParserCharacter until // I have figured out all the limitations to invoke methods // in the generated classes. See repl.txt // parser.Lexer.putback_char = Tokenizer.EvalUsingDeclarationsParserCharacter; //parser.Lexer.putback_char = Tokenizer.EvalCompilationUnitParserCharacter; RootContext.StatementMode = false; } if (silent) { Report.DisableReporting(); } try { parser.parse(); } finally { if (Report.Errors != 0) { if (silent && parser.UnexpectedEOF) { partial_input = true; } parser.undo.ExecuteUndo(); parser = null; } if (silent) { Report.EnableReporting(); } } return(parser); }