public void Parse(SourceFile file, ModuleContainer module, ParserSession session, Report report) { Stream input; try { // input = File.OpenRead (file.Name); input = file.GetDataStream(); // aeroson's edit } catch { report.Error(2001, "Source file `{0}' could not be found", file.Name); return; } // Check 'MZ' header if (input.ReadByte() == 77 && input.ReadByte() == 90) { report.Error(2015, "Source file `{0}' is a binary file and not a text file", file.Name); input.Close(); return; } input.Position = 0; SeekableStreamReader reader = new SeekableStreamReader(input, ctx.Settings.Encoding, session.StreamReaderBuffer); Parse(reader, file, module, session, report); if (ctx.Settings.GenerateDebugInfo && report.Errors == 0 && !file.HasChecksum) { input.Position = 0; var checksum = session.GetChecksumAlgorithm(); file.SetChecksum(checksum.ComputeHash(input)); } reader.Dispose(); input.Close(); }
void tokenize_file (CompilationUnit file, CompilerContext ctx) { Stream input; try { input = File.OpenRead (file.Name); } catch { Report.Error (2001, "Source file `" + file.Name + "' could not be found"); return; } using (input){ SeekableStreamReader reader = new SeekableStreamReader (input, RootContext.Encoding); Tokenizer lexer = new Tokenizer (reader, file, ctx); int token, tokens = 0, errors = 0; while ((token = lexer.token ()) != Token.EOF){ tokens++; if (token == Token.ERROR) errors++; } Console.WriteLine ("Tokenized: " + tokens + " found " + errors + " errors"); } return; }
void tokenize_file (SourceFile sourceFile, ModuleContainer module) { Stream input; try { input = File.OpenRead (sourceFile.Name); } catch { Report.Error (2001, "Source file `" + sourceFile.Name + "' could not be found"); return; } using (input){ SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding); var file = new CompilationSourceFile (module, sourceFile); Tokenizer lexer = new Tokenizer (reader, file); int token, tokens = 0, errors = 0; while ((token = lexer.token ()) != Token.EOF){ tokens++; if (token == Token.ERROR) errors++; } Console.WriteLine ("Tokenized: " + tokens + " found " + errors + " errors"); } return; }
void tokenize_file(SourceFile sourceFile, ModuleContainer module, ParserSession session) { Stream input; try { // input = File.OpenRead (file.Name); input = sourceFile.GetDataStream(); // aeroson's edit } catch { Report.Error(2001, "Source file `" + sourceFile.Name + "' could not be found"); return; } using (input) { SeekableStreamReader reader = new SeekableStreamReader(input, ctx.Settings.Encoding); var file = new CompilationSourceFile(module, sourceFile); Tokenizer lexer = new Tokenizer(reader, file, session, ctx.Report); int token, tokens = 0, errors = 0; while ((token = lexer.token()) != Token.EOF) { tokens++; if (token == Token.ERROR) { errors++; } } Console.WriteLine("Tokenized: " + tokens + " found " + errors + " errors"); } return; }
void tokenize_file(CompilationSourceFile file) { Stream input; try { input = File.OpenRead(file.Name); } catch { Report.Error(2001, "Source file `" + file.Name + "' could not be found"); return; } using (input){ SeekableStreamReader reader = new SeekableStreamReader(input, ctx.Settings.Encoding); Tokenizer lexer = new Tokenizer(reader, file, ctx); int token, tokens = 0, errors = 0; while ((token = lexer.token()) != Token.EOF) { tokens++; if (token == Token.ERROR) { errors++; } } Console.WriteLine("Tokenized: " + tokens + " found " + errors + " errors"); } return; }
void Parse(CompilationSourceFile file, ModuleContainer module) { Stream input; try { input = File.OpenRead(file.Name); } catch { Report.Error(2001, "Source file `{0}' could not be found", file.Name); return; } // Check 'MZ' header if (input.ReadByte() == 77 && input.ReadByte() == 90) { Report.Error(2015, "Source file `{0}' is a binary file and not a text file", file.Name); input.Close(); return; } input.Position = 0; SeekableStreamReader reader = new SeekableStreamReader(input, ctx.Settings.Encoding); Parse(reader, file, module); reader.Dispose(); input.Close(); }
void tokenize_file(SourceFile sourceFile, ModuleContainer module, ParserSession session) { Stream input = null; SeekableStreamReader reader = null; try { if (sourceFile.GetInputStream != null) { reader = sourceFile.GetInputStream(sourceFile); if (reader == null) { throw new FileNotFoundException("Delegate returned null", sourceFile.Name); } } else { input = File.OpenRead(sourceFile.Name); } } catch { Report.Error(2001, "Source file `" + sourceFile.Name + "' could not be found"); return; } if (reader == null) { using (input) { reader = new SeekableStreamReader(input, ctx.Settings.Encoding); DoTokenize(sourceFile, module, session, reader); } } else { DoTokenize(sourceFile, module, session, reader); } }
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 void Parse(SeekableStreamReader reader, CompilationSourceFile file, ModuleContainer module) { file.NamespaceContainer = new NamespaceContainer(null, module, null, file); CSharpParser parser = new CSharpParser(reader, file); parser.parse(); }
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 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); }
void tokenize_file(SourceFile sourceFile, ModuleContainer module, ParserSession session) { Stream input; try { input = File.OpenRead(sourceFile.Name); } catch { Report.Error(2001, "Source file `" + sourceFile.Name + "' could not be found"); return; } using (input) { SeekableStreamReader reader = new SeekableStreamReader(input, ctx.Settings.Encoding); var file = new CompilationSourceFile(module, sourceFile); if (sourceFile.FileType == SourceFileType.CSharp) { Tokenizer lexer = new Tokenizer(reader, file, session); int token, tokens = 0, errors = 0; while ((token = lexer.token()) != Token.EOF) { tokens++; if (token == Token.ERROR) { errors++; } } } else { Mono.PlayScript.Tokenizer lexer = new Mono.PlayScript.Tokenizer(reader, file, session); lexer.ParsingPlayScript = sourceFile.PsExtended; int token, tokens = 0, errors = 0; while ((token = lexer.token()) != Mono.PlayScript.Token.EOF) { tokens++; if (token == Mono.PlayScript.Token.ERROR) { errors++; } } } } return; }
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 Parse(SourceFile file, ModuleContainer module, ParserSession session, Report report) { Stream input = null; SeekableStreamReader reader = null; try { if (file.GetInputStream != null) { reader = file.GetInputStream(file); if (reader == null) { throw new FileNotFoundException("Delegate returned null", file.Name); } } else { input = File.OpenRead(file.Name); } } catch { report.Error(2001, "Source file `{0}' could not be found", file.Name); return; } if (reader == null) { using (input) { // Check 'MZ' header if (input.ReadByte() == 77 && input.ReadByte() == 90) { report.Error(2015, "Source file `{0}' is a binary file and not a text file", file.Name); return; } input.Position = 0; reader = new SeekableStreamReader(input, ctx.Settings.Encoding, session.StreamReaderBuffer); DoParse(file, module, session, report, reader); } } else { DoParse(file, module, session, report, reader); } }
void tokenize_file (SourceFile sourceFile, ModuleContainer module, ParserSession session) { Stream input; try { input = File.OpenRead (sourceFile.Name); } catch { Report.Error (2001, "Source file `" + sourceFile.Name + "' could not be found"); return; } using (input) { SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding); var file = new CompilationSourceFile (module, sourceFile); if (sourceFile.FileType == SourceFileType.CSharp) { Tokenizer lexer = new Tokenizer (reader, file, session); int token, tokens = 0, errors = 0; while ((token = lexer.token ()) != Token.EOF){ tokens++; if (token == Token.ERROR) errors++; } } else { Mono.PlayScript.Tokenizer lexer = new Mono.PlayScript.Tokenizer (reader, file, session); lexer.ParsingPlayScript = sourceFile.PsExtended; int token, tokens = 0, errors = 0; while ((token = lexer.token ()) != Mono.PlayScript.Token.EOF){ tokens++; if (token == Mono.PlayScript.Token.ERROR) errors++; } } } return; }
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; Location.AddFile (null, inputFile); Location.Initialize (); // TODO: encoding from driver SeekableStreamReader reader = new SeekableStreamReader (input, Encoding.Default); CompilerContext ctx = new CompilerContext (new Report (reportPrinter)); RootContext.ToplevelTypes = new ModuleContainer (ctx); CompilationUnit unit = null; try { unit = (CompilationUnit) Location.SourceFiles [0]; } catch (Exception) { string path = Path.GetFullPath (inputFile); unit = new CompilationUnit (inputFile, path, 0); } CSharpParser parser = new CSharpParser (reader, unit, RootContext.ToplevelTypes); 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 }; } 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 CSharpParser (SeekableStreamReader reader, CompilationSourceFile file) { this.file = file; current_namespace = file.NamespaceContainer; this.module = current_namespace.Module; this.compiler = module.Compiler; this.settings = compiler.Settings; lang_version = settings.Version; doc_support = settings.Documentation != null; current_class = current_namespace.SlaveDeclSpace; current_container = current_class.PartialContainer; // == RootContest.ToplevelTypes oob_stack.Clear (); lexer = new Tokenizer (reader, file, compiler); use_global_stacks = true; }
// // 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, (CompilationUnit) Location.SourceFiles [0], ctx); 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; }
public CSharpParser (SeekableStreamReader reader, CompilationSourceFile file, ParserSession session) : this (reader, file, file.Compiler.Report, session) { }
public CompilationUnit Parse(Stream stream, string fileName, int lineModifier = 0) { lock (parseLock) { errorReportPrinter = new ErrorReportPrinter (""); var ctx = new CompilerContext (CompilerSettings, errorReportPrinter); ctx.Settings.TabSize = 1; var reader = new SeekableStreamReader (stream, Encoding.UTF8); var file = new SourceFile (fileName, fileName, 0); Location.Initialize (new List<SourceFile> (new [] { file })); var module = new ModuleContainer (ctx); var parser = Driver.Parse (reader, file, module, lineModifier); var top = new CompilerCompilationUnit () { ModuleCompiled = module, LocationsBag = parser.LocationsBag, SpecialsBag = parser.Lexer.sbag }; var unit = Parse (top, fileName, lineModifier); unit.Errors.AddRange (errorReportPrinter.Errors); CompilerCallableEntryPoint.Reset (); return unit; } }
public void Parse (SourceFile file, ModuleContainer module) { Stream input; try { input = File.OpenRead (file.Name); } catch { Report.Error (2001, "Source file `{0}' could not be found", file.Name); return; } // Check 'MZ' header if (input.ReadByte () == 77 && input.ReadByte () == 90) { Report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name); input.Close (); return; } input.Position = 0; SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding); Parse (reader, file, module); if (ctx.Settings.GenerateDebugInfo && ctx.Report.Errors == 0 && !file.HasChecksum) { input.Position = 0; if (md5 == null) md5 = MD5.Create (); file.SetChecksum (md5.ComputeHash (input)); } reader.Dispose (); input.Close (); }
void Parse(CompilationUnit file, ModuleContainer module) { Stream input; try { input = File.OpenRead (file.Name); } catch { Report.Error (2001, "Source file `{0}' could not be found", file.Name); return; } // Check 'MZ' header if (input.ReadByte () == 77 && input.ReadByte () == 90) { Report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name); input.Close (); return; } input.Position = 0; SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding); Parse (reader, file, module); reader.Dispose (); input.Close (); }
// // Deambiguates the input string to determine if we // want to process a statement or if we want to // process a compilation unit. // // This is done using a top-down predictive parser, // since the yacc/jay parser can not deambiguage this // without more than one lookahead token. There are very // few ambiguities. // InputKind ToplevelOrStatement (SeekableStreamReader seekable) { Tokenizer tokenizer = new Tokenizer (seekable, source_file); int t = tokenizer.token (); switch (t){ case Token.EOF: return InputKind.EOF; // These are toplevels case Token.EXTERN: case Token.OPEN_BRACKET: case Token.ABSTRACT: case Token.CLASS: case Token.ENUM: case Token.INTERFACE: case Token.INTERNAL: case Token.NAMESPACE: case Token.PRIVATE: case Token.PROTECTED: case Token.PUBLIC: case Token.SEALED: case Token.STATIC: case Token.STRUCT: return InputKind.CompilationUnit; // Definitely expression case Token.FIXED: case Token.BOOL: case Token.BYTE: case Token.CHAR: case Token.DECIMAL: case Token.DOUBLE: case Token.FLOAT: case Token.INT: case Token.LONG: case Token.NEW: case Token.OBJECT: case Token.SBYTE: case Token.SHORT: case Token.STRING: case Token.UINT: case Token.ULONG: return InputKind.StatementOrExpression; // These need deambiguation help case Token.USING: t = tokenizer.token (); if (t == Token.EOF) return InputKind.EOF; if (t == Token.IDENTIFIER) return InputKind.CompilationUnit; return InputKind.StatementOrExpression; // Distinguish between: // delegate opt_anonymous_method_signature block // delegate type case Token.DELEGATE: t = tokenizer.token (); if (t == Token.EOF) return InputKind.EOF; if (t == Token.OPEN_PARENS || t == Token.OPEN_BRACE) return InputKind.StatementOrExpression; return InputKind.CompilationUnit; // Distinguih between: // unsafe block // unsafe as modifier of a type declaration case Token.UNSAFE: t = tokenizer.token (); if (t == Token.EOF) return InputKind.EOF; if (t == Token.OPEN_PARENS) return InputKind.StatementOrExpression; return InputKind.CompilationUnit; // These are errors: we list explicitly what we had // from the grammar, ERROR and then everything else case Token.READONLY: case Token.OVERRIDE: case Token.ERROR: return InputKind.Error; // This catches everything else allowed by // expressions. We could add one-by-one use cases // if needed. default: return InputKind.StatementOrExpression; } }
void Parse (SeekableStreamReader reader, CompilationUnit file) { CSharpParser parser = new CSharpParser (reader, file); parser.ErrorOutput = Report.Stderr; try { parser.parse (); } catch (Exception ex) { Report.Error(589, parser.Lexer.Location, "Compilation aborted in file `{0}', {1}", file.Name, ex); } }
public CSharpParser (SeekableStreamReader reader, CompilationUnit file, CompilerContext ctx) { if (RootContext.EvalMode) undo = new Undo (); this.file = file; this.compiler = ctx; current_namespace = new NamespaceEntry (ctx, null, file, null); current_class = current_namespace.SlaveDeclSpace; current_container = current_class.PartialContainer; // == RootContest.ToplevelTypes oob_stack.Clear (); lexer = new Tokenizer (reader, file, ctx); use_global_stacks = true; }
void DoTokenize(SourceFile sourceFile, ModuleContainer module, ParserSession session, SeekableStreamReader reader) { var file = new CompilationSourceFile(module, sourceFile); Tokenizer lexer = new Tokenizer(reader, file, session, ctx.Report); int token, tokens = 0, errors = 0; while ((token = lexer.token()) != Token.EOF) { tokens++; if (token == Token.ERROR) { errors++; } } Console.WriteLine("Tokenized: " + tokens + " found " + errors + " errors"); }
// // 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); }
public Tokenizer (SeekableStreamReader input, CompilationUnit file, CompilerContext ctx) { this.ref_name = file; this.file_name = file; this.context = ctx; reader = input; putback_char = -1; xml_comment_buffer = new StringBuilder (); // // FIXME: This could be `Location.Push' but we have to // find out why the MS compiler allows this // Mono.CSharp.Location.Push (file, file); }
// // 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); }
public void Parse(SeekableStreamReader reader, CompilationUnit file, ModuleContainer module) { CSharpParser parser = new CSharpParser (reader, file, module); parser.parse (); }
// // Deambiguates the input string to determine if we // want to process a statement or if we want to // process a compilation unit. // // This is done using a top-down predictive parser, // since the yacc/jay parser can not deambiguage this // without more than one lookahead token. There are very // few ambiguities. // static InputKind ToplevelOrStatement(SeekableStreamReader seekable) { Tokenizer tokenizer = new Tokenizer(seekable, (CompilationUnit)Location.SourceFiles [0], ctx); int t = tokenizer.token(); switch (t) { case Token.EOF: return(InputKind.EOF); // These are toplevels case Token.EXTERN: case Token.OPEN_BRACKET: case Token.ABSTRACT: case Token.CLASS: case Token.ENUM: case Token.INTERFACE: case Token.INTERNAL: case Token.NAMESPACE: case Token.PRIVATE: case Token.PROTECTED: case Token.PUBLIC: case Token.SEALED: case Token.STATIC: case Token.STRUCT: return(InputKind.CompilationUnit); // Definitely expression case Token.FIXED: case Token.BOOL: case Token.BYTE: case Token.CHAR: case Token.DECIMAL: case Token.DOUBLE: case Token.FLOAT: case Token.INT: case Token.LONG: case Token.NEW: case Token.OBJECT: case Token.SBYTE: case Token.SHORT: case Token.STRING: case Token.UINT: case Token.ULONG: return(InputKind.StatementOrExpression); // These need deambiguation help case Token.USING: t = tokenizer.token(); if (t == Token.EOF) { return(InputKind.EOF); } if (t == Token.IDENTIFIER) { return(InputKind.CompilationUnit); } return(InputKind.StatementOrExpression); // Distinguish between: // delegate opt_anonymous_method_signature block // delegate type case Token.DELEGATE: t = tokenizer.token(); if (t == Token.EOF) { return(InputKind.EOF); } if (t == Token.OPEN_PARENS || t == Token.OPEN_BRACE) { return(InputKind.StatementOrExpression); } return(InputKind.CompilationUnit); // Distinguih between: // unsafe block // unsafe as modifier of a type declaration case Token.UNSAFE: t = tokenizer.token(); if (t == Token.EOF) { return(InputKind.EOF); } if (t == Token.OPEN_PARENS) { return(InputKind.StatementOrExpression); } return(InputKind.CompilationUnit); // These are errors: we list explicitly what we had // from the grammar, ERROR and then everything else case Token.READONLY: case Token.OVERRIDE: case Token.ERROR: return(InputKind.Error); // This catches everything else allowed by // expressions. We could add one-by-one use cases // if needed. default: return(InputKind.StatementOrExpression); } }
// // 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); }
public void Parse(SeekableStreamReader reader, CompilationUnit file, ModuleContainer module) { CSharpParser parser = new CSharpParser(reader, file, module); parser.parse(); }
// // Processes "see" or "seealso" elements from cref attribute. // void HandleXrefCommon (MemberCore mc, TypeContainer ds, 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)); SeekableStreamReader seekable = new SeekableStreamReader (s, encoding); var source_file = new CompilationSourceFile (doc_module); var report = new Report (doc_module.Compiler, new NullReportPrinter ()); var parser = new CSharpParser (seekable, source_file, report); 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 Namespace; 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 ()); foreach (var pp in ParsedParameters) { pp.Resolve (mc); } 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; int i; for (i = 0; i < parsed_param_count; ++i) { var pparam = ParsedParameters[i]; if (i >= pm.Parameters.Count || pparam == null || pparam.TypeSpec != pm.Parameters.Types[i] || (pparam.Modifier & Parameter.Modifier.SignatureMask) != (pm.Parameters.FixedParameters[i].ModFlags & Parameter.Modifier.SignatureMask)) { 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.Parameters.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); }
public void Parse (SourceFile file, ModuleContainer module, ParserSession session, Report report) { Stream input; try { input = File.OpenRead (file.Name); } catch { report.Error (2001, "Source file `{0}' could not be found", file.Name); return; } // Check 'MZ' header if (input.ReadByte () == 77 && input.ReadByte () == 90) { report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name); input.Close (); return; } input.Position = 0; SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding, session.StreamReaderBuffer); Parse (reader, file, module, session, report); if (ctx.Settings.GenerateDebugInfo && report.Errors == 0 && !file.HasChecksum) { input.Position = 0; var checksum = session.GetChecksumAlgorithm (); file.SetChecksum (checksum.ComputeHash (input)); } reader.Dispose (); input.Close (); }
// // 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); }
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 (); }
public CSharpParser (SeekableStreamReader reader, CompilationSourceFile file, Report report, ParserSession session) { this.file = file; current_container = current_namespace = file; this.module = file.Module; this.compiler = file.Compiler; this.settings = compiler.Settings; this.report = report; lang_version = settings.Version; yacc_verbose_flag = settings.VerboseParserFlag; doc_support = settings.DocumentationFile != null; lexer = new Tokenizer (reader, file, session); oob_stack = new Stack<object> (); lbag = session.LocationsBag; use_global_stacks = session.UseJayGlobalArrays; parameters_bucket = session.ParametersStack; }
SyntaxTree Parse(ITextSource program, string fileName, int initialLine, int initialColumn) { lock (parseLock) { errorReportPrinter = new ErrorReportPrinter(""); var ctx = new CompilerContext(compilerSettings.ToMono(), errorReportPrinter); ctx.Settings.TabSize = 1; var reader = new SeekableStreamReader(program); var file = new SourceFile(fileName, fileName, 0); Location.Initialize(new List<SourceFile>(new [] { file })); var module = new ModuleContainer(ctx); var session = new ParserSession(); session.LocationsBag = new LocationsBag(); var report = new Report(ctx, errorReportPrinter); var parser = Driver.Parse(reader, file, module, session, report, initialLine - 1, initialColumn - 1); var top = new CompilerCompilationUnit { ModuleCompiled = module, LocationsBag = session.LocationsBag, SpecialsBag = parser.Lexer.sbag, Conditionals = parser.Lexer.SourceFile.Conditionals }; var unit = Parse(top, fileName); unit.Errors.AddRange(errorReportPrinter.Errors); CompilerCallableEntryPoint.Reset(); return unit; } }
void DoParse(SourceFile file, ModuleContainer module, ParserSession session, Report report, SeekableStreamReader reader) { Parse(reader, file, module, session, report); if (ctx.Settings.GenerateDebugInfo && report.Errors == 0 && !file.HasChecksum) { reader.Stream.Position = 0; var checksum = session.GetChecksumAlgorithm(); file.SetChecksum(checksum.ComputeHash(reader.Stream)); } }
void Parse (SeekableStreamReader reader, CompilationUnit file) { CSharpParser parser = new CSharpParser (reader, file, ctx); 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; 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.Default); 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 CSharpParser (SeekableStreamReader reader, CompilationSourceFile file, Report report) { this.file = file; current_container = current_namespace = file; this.module = file.Module; this.compiler = file.Compiler; this.settings = compiler.Settings; this.report = report; lang_version = settings.Version; yacc_verbose_flag = settings.VerboseParserFlag; doc_support = settings.DocumentationFile != null; oob_stack.Clear (); lexer = new Tokenizer (reader, file); #if FULL_AST lbag = new LocationsBag (); #else lbag = null; #endif use_global_stacks = true; }
/* /// <summary> /// Parses a file snippet; guessing what the code snippet represents (whole file, type members, block, type reference, expression). /// </summary> public AstNode ParseSnippet (string code) { // TODO: add support for parsing a part of a file throw new NotImplementedException (); } */ public DocumentationReference ParseDocumentationReference(string cref) { // see Mono.CSharp.DocumentationBuilder.HandleXrefCommon if (cref == null) throw new ArgumentNullException("cref"); // Additional symbols for < and > are allowed for easier XML typing cref = cref.Replace('{', '<').Replace('}', '>'); lock (parseLock) { errorReportPrinter = new ErrorReportPrinter(""); var ctx = new CompilerContext(compilerSettings.ToMono(), errorReportPrinter); ctx.Settings.TabSize = 1; var reader = new SeekableStreamReader(new StringTextSource(cref)); var file = new SourceFile("", "", 0); Location.Initialize(new List<SourceFile>(new [] { file })); var module = new ModuleContainer(ctx); module.DocumentationBuilder = new DocumentationBuilder(module); var source_file = new CompilationSourceFile(module); var report = new Report(ctx, errorReportPrinter); var session = new ParserSession(); session.LocationsBag = new LocationsBag(); var parser = new Mono.CSharp.CSharpParser(reader, source_file, report, session); parser.Lexer.Line += initialLocation.Line - 1; parser.Lexer.Column += initialLocation.Column - 1; 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); } var conversionVisitor = new ConversionVisitor(false, session.LocationsBag); var docRef = conversionVisitor.ConvertXmlDoc(module.DocumentationBuilder); CompilerCallableEntryPoint.Reset(); return docRef; } }
void Parse (CompilationUnit file) { Stream input; try { input = File.OpenRead (file.Name); } catch { Report.Error (2001, "Source file `{0}' could not be found", file.Name); return; } SeekableStreamReader reader = new SeekableStreamReader (input, encoding); // Check 'MZ' header if (reader.Read () == 77 && reader.Read () == 90) { Report.Error (2015, "Source file `{0}' is a binary file and not a text file", file.Name); input.Close (); return; } reader.Position = 0; Parse (reader, file); reader.Dispose (); input.Close (); }
// // 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); 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)) 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; }
public static void GenerateEmbedClasses(ModuleContainer module, ParserSession session, Report report) { List<EmbedData> embeds = new List<EmbedData>(); FindEmbedClasses(module, module, embeds); if (embeds.Count == 0) return; var os = new StringWriter(); os.Write (@" // Generated embed loader classes "); foreach (var e in embeds) { var loc = e._field.Location; e._field.Initializer = new TypeOf(new MemberAccess(new SimpleName("_embed_loaders", loc), e._className), loc); os.Write (@" namespace _embed_loaders {{ internal class {1} : PlayScript.EmbedLoader {{ public {1}() : base({2}, {3}, {4}, {5}, {6}) {{ }} }} }} ", PsConsts.PsRootNamespace, e._className, e.source, e.mimeType, e.embedAsCFF, e.fontFamily, e.symbol); } string fileStr = os.ToString(); var path = System.IO.Path.Combine (System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(module.Compiler.Settings.OutputFile)), "embed.g.cs"); System.IO.File.WriteAllText(path, fileStr); byte[] byteArray = Encoding.ASCII.GetBytes( fileStr ); var input = new MemoryStream( byteArray, false ); var reader = new SeekableStreamReader (input, System.Text.Encoding.UTF8); SourceFile file = new SourceFile(path, path, 0); file.FileType = SourceFileType.CSharp; Driver.Parse (reader, file, module, session, report); }
// // 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); }
public static void GenerateDynamicPartialClasses(ModuleContainer module, ParserSession session, Report report) { List<Class> classes = new List<Class>(); FindDynamicClasses(module, classes); if (classes.Count == 0) return; var os = new StringWriter(); os.Write (@" // Generated dynamic class partial classes "); foreach (var cl in classes) { os.Write (@" namespace {1} {{ partial class {2} : PlayScript.IDynamicClass {{ private PlayScript.IDynamicClass __dynamicProps; dynamic PlayScript.IDynamicClass.__GetDynamicValue(string name) {{ object value = null; if (__dynamicProps != null) {{ value = __dynamicProps.__GetDynamicValue(name); }} return value; }} bool PlayScript.IDynamicClass.__TryGetDynamicValue(string name, out object value) {{ if (__dynamicProps != null) {{ return __dynamicProps.__TryGetDynamicValue(name, out value); }} else {{ value = null; return false; }} }} void PlayScript.IDynamicClass.__SetDynamicValue(string name, object value) {{ if (__dynamicProps == null) {{ __dynamicProps = new PlayScript.DynamicProperties(this); }} __dynamicProps.__SetDynamicValue(name, value); }} bool PlayScript.IDynamicClass.__DeleteDynamicValue(object name) {{ if (__dynamicProps != null) {{ return __dynamicProps.__DeleteDynamicValue(name); }} return false; }} bool PlayScript.IDynamicClass.__HasDynamicValue(string name) {{ if (__dynamicProps != null) {{ return __dynamicProps.__HasDynamicValue(name); }} return false; }} System.Collections.IEnumerable PlayScript.IDynamicClass.__GetDynamicNames() {{ if (__dynamicProps != null) {{ return __dynamicProps.__GetDynamicNames(); }} return null; }} }} }} ", PsConsts.PsRootNamespace, ((ITypeDefinition)cl).Namespace, cl.MemberName.Basename); } string fileStr = os.ToString(); var path = System.IO.Path.Combine (System.IO.Path.GetDirectoryName(System.IO.Path.GetFullPath(module.Compiler.Settings.OutputFile)), "dynamic.g.cs"); System.IO.File.WriteAllText(path, fileStr); byte[] byteArray = Encoding.ASCII.GetBytes( fileStr ); var input = new MemoryStream( byteArray, false ); var reader = new SeekableStreamReader (input, System.Text.Encoding.UTF8); SourceFile file = new SourceFile(path, path, 0); file.FileType = SourceFileType.CSharp; Driver.Parse (reader, file, module, session, report); }