ClassDefinition GetClassDefinition(string code) { RubyParser parser = new RubyParser(); SourceUnitTree unit = parser.CreateAst(@"test.rb", new StringTextBuffer(code)); return(unit.Statements.First as ClassDefinition); }
static Statements Parse(string code) { RubyParser parser = new RubyParser(); SourceUnitTree unit = parser.CreateAst(@"snippet.rb", new StringTextBuffer(code)); return(unit.Statements); }
public void GetTreeAndCookie(out SourceUnitTree tree, out IAnalysisCookie cookie) { lock (this) { tree = _node; cookie = _curCookie; } }
public SourceUnitTree Parse(SourceUnit /*!*/ sourceUnit, RubyCompilerOptions /*!*/ options, ErrorSink /*!*/ errorSink) { Assert.NotNull(sourceUnit, options, errorSink); ErrorCounter counter = new ErrorCounter(errorSink); _tokenizer.ErrorSink = counter; _tokenizer.Compatibility = options.Compatibility; _lexicalScopes.Clear(); EnterScope(CreateTopScope(options.LocalNames)); using (SourceCodeReader reader = sourceUnit.GetReader()) { _sourceUnit = sourceUnit; _tokenizer.Initialize(null, reader, sourceUnit, options.InitialLocation); // Default encoding when hosted (ignore KCODE, we are reading from Unicode buffer): _tokenizer.Encoding = (reader.Encoding != null) ? RubyEncoding.GetRubyEncoding(reader.Encoding) : RubyEncoding.UTF8; _tokenizer.AllowNonAsciiIdentifiers = _tokenizer.Encoding != RubyEncoding.Binary; try { Parse(); LeaveScope(); } catch (InternalSyntaxError) { _ast = null; _lexicalScopes.Clear(); } finally { ScriptCodeParseResult props; if (counter.AnyError) { _ast = null; if (_tokenizer.UnterminatedToken) { props = ScriptCodeParseResult.IncompleteToken; } else if (_tokenizer.EndOfFileReached) { props = ScriptCodeParseResult.IncompleteStatement; } else { props = ScriptCodeParseResult.Invalid; } } else { props = ScriptCodeParseResult.Complete; } sourceUnit.CodeProperties = props; } return(_ast); } }
public SourceUnitTree Parse(SourceUnit /*!*/ sourceUnit, RubyCompilerOptions /*!*/ options, ErrorSink /*!*/ errorSink) { Assert.NotNull(sourceUnit, options, errorSink); ErrorCounter counter = new ErrorCounter(errorSink); _tokenizer.ErrorSink = counter; _tokenizer.Compatibility = options.Compatibility; _lexicalScopes.Clear(); EnterScope(CreateTopScope(options.LocalNames)); using (SourceCodeReader reader = sourceUnit.GetReader()) { _sourceUnit = sourceUnit; _tokenizer.Initialize(null, reader, sourceUnit, options.InitialLocation); // default encoding when hosted: _encoding = reader.Encoding ?? RubyEncoding.GetDefaultHostEncoding(options.Compatibility); try { Parse(); LeaveScope(); } catch (InternalSyntaxError) { _ast = null; _lexicalScopes.Clear(); } finally { ScriptCodeParseResult props; if (counter.AnyError) { _ast = null; if (_tokenizer.UnterminatedToken) { props = ScriptCodeParseResult.IncompleteToken; } else if (_tokenizer.IsEndOfFile) { props = ScriptCodeParseResult.IncompleteStatement; } else { props = ScriptCodeParseResult.Invalid; } } else { props = ScriptCodeParseResult.Complete; } sourceUnit.CodeProperties = props; } return(_ast); } }
public static MSA.Expression <T> /*!*/ Transform <T>(SourceUnitTree /*!*/ ast, SourceUnit /*!*/ sourceUnit, RubyCompilerOptions /*!*/ options, int sourceId) { var context = (RubyContext)sourceUnit.LanguageContext; var siteNodes = new Dictionary <MSA.DynamicExpression, SourceSpan>(); var generator = new TraceAstGenerator(siteNodes, context, options, sourceUnit, ast.Encoding); var lambda = ast.Transform <T>(generator); return((MSA.Expression <T>) new CallSiteTraceInjector(siteNodes, sourceId).Visit(lambda)); }
public virtual object Walk(SourceUnitTree node) { if (Enter(node)) { if (node.SourceElements != null) node.SourceElements.Accept(this); } Exit(node); return null; }
public void Parse() { var srcunit = HostingHelpers.GetSourceUnit(source); var parser = new IronRuby.Compiler.Parser(errorSink); ast = parser.Parse(srcunit, new RubyCompilerOptions(), errorSink); var transformer = new Transformer.Transformer(ast); transformations = transformer.Transform(); }
public virtual object Walk(SourceUnitTree node) { if (Enter(node)) { if (node.SourceElements != null) { node.SourceElements.Accept(this); } } Exit(node); return(null); }
public static MSA.Expression <T> /*!*/ Transform <T>(SourceUnitTree /*!*/ ast, SourceUnit /*!*/ sourceUnit, RubyCompilerOptions /*!*/ options, int sourceId) { var siteNodes = new Dictionary <MSA.DynamicExpression, SourceSpan>(); var context = (RubyContext)sourceUnit.LanguageContext; context.CallSiteCreated = (expression, callSite) => siteNodes.Add(callSite, expression.Location); var generator = new AstGenerator(context, options, sourceUnit.Document, ast.Encoding, false); var lambda = ast.Transform <T>(generator); return((MSA.Expression <T>) new CallSiteTraceInjector(siteNodes, sourceId).Visit(lambda)); }
public void UpdateTree(SourceUnitTree newAst, IAnalysisCookie newCookie) { lock (this) { _node = newAst; _curCookie = newCookie; } var newParse = OnNewParseTree; if (newParse != null) { newParse(this, EventArgs.Empty); } }
public void Parse(TextContentProvider /*!*/ content) { var errorSink = new CollectingErrorSink(); SourceUnitTree ast = MakeParseTree(content, errorSink); ISnapshotTextContentProvider snapshotContent = content as ISnapshotTextContentProvider; if (snapshotContent != null) { // queue analysis of the parsed tree at High Pri so the active buffer is quickly re-analyzed var snapshot = snapshotContent.Snapshot; var analysis = AnalysisItem.GetAnalysis(snapshot.TextBuffer); // only update the AST when we're error free, this way we don't remove // a useful analysis with an incomplete and useless analysis. if (errorSink.Errors.Count == 0) { analysis.UpdateTree(ast, new SnapshotCookie(snapshot)); _analysisQueue.Enqueue(analysis, AnalysisPriority.High); } SimpleTagger <ErrorTag> squiggles = _squiggleProvider.GetErrorTagger(snapshot.TextBuffer); squiggles.RemoveTagSpans(x => true); // update squiggles for the live buffer foreach (ErrorResult warning in errorSink.Warnings) { var span = warning.Span; var tspan = CreateSpan(snapshot, span); squiggles.CreateTagSpan(tspan, new ErrorTag("Warning", warning.Message)); } foreach (ErrorResult error in errorSink.Errors) { var span = error.Span; var tspan = CreateSpan(snapshot, span); squiggles.CreateTagSpan(tspan, new ErrorTag("Error", error.Message)); } } else { FileTextContentProvider fileContent = content as FileTextContentProvider; AnalysisItem analysis; if (fileContent != null && _projectFiles.TryGetValue(fileContent.Path, out analysis)) { analysis.UpdateTree(ast, new FileCookie(fileContent.Path)); _analysisQueue.Enqueue(analysis, AnalysisPriority.Normal); } } }
/// <summary> /// Creates a control either a UserControl or Form from the Ruby code. /// </summary> public IComponent CreateComponent(string rubyCode) { RubyParser parser = new RubyParser(); SourceUnitTree ast = parser.CreateAst(@"Control.rb", new StringTextBuffer(rubyCode)); Walk(ast); // Did we find the InitializeComponent method? if (!FoundInitializeComponentMethod) { throw new RubyComponentWalkerException("Unable to find InitializeComponents method."); } return(component); }
public SourceUnitTree ParseProgram() { if (Next().Is(TokenType.Eof)) { return new SourceUnitTree { Token = Next() } } ; var tree = new SourceUnitTree { Token = Next(), SourceElements = ParseSourceElements() }; Match(TokenType.Eof); return(tree); }
public Compiler(SourceUnitTree tree, string source = null) { if (source == null) { signature = new string[0]; } else { signature = new string[] { "// " + source.MD5(), "// Generated by Fructose on " + DateTime.Now.ToShortDateString() + " by " + Environment.UserName, "//" }; } this.tree = tree; }
public ModelBuilder(SourceUnitTree /*!*/ tree) { _tree = tree; var top = new ModuleEntry("<main>", "<main>", tree, false, false); _outerName = new List <string>(); _outerName.Add(null); _outerModules = new Stack <ModuleEntry>(); _outerModules.Push(top); _outerMethods = new Stack <MethodEntry>(); _definitions = new Dictionary <string, int>(); _entries = new List <ModuleEntry>(); _entries.Add(top); }
public ICompilationUnit Parse(IProjectContent projectContent, string fileName, ITextBuffer fileContent) { if (fileContent != null) { try { SourceUnitTree ast = CreateAst(fileName, fileContent); RubyAstWalker walker = new RubyAstWalker(projectContent, fileName, sourceUnit); walker.Walk(ast); return walker.CompilationUnit; } catch (SyntaxErrorException) { // Ignore. } } DefaultCompilationUnit compilationUnit = new DefaultCompilationUnit(projectContent); compilationUnit.FileName = fileName; return compilationUnit; }
public override bool Enter(SourceUnitTree node) { Print("********************* Code Tree *********************"); return true; }
public virtual void Exit(SourceUnitTree node) { }
public virtual bool Enter(SourceUnitTree node) { return true; }
FunctionDefinition ParseFunctionDefinition() { var name = Expect(TokenType.Identifier).Value.ToString(); List <ParameterDefinition> parameters = new List <ParameterDefinition>(); if (Accept(TokenType.SymbolOpenParenthesis)) { while (true) { if (Accept(TokenType.SymbolCloseParenthesis)) { break; } else { Accept(TokenType.SymbolComma); } if (Accept(TokenType.SymbolAsterisk)) { parameters.Add(new ParameterDefinition(null, true)); } else { var paramName = Expect(TokenType.Identifier).Value.ToString(); if (Accept(TokenType.SymbolEquals)) { var start = _tokenizer.NextToken.Span.Start; var exp = new SourceUnitTree( Enumerable.Empty <ClassDefinition>(), Enumerable.Empty <FunctionDefinition>(), Enumerable.Empty <PropertyDefinition>(), new[] { new ExpressionStatement(ParseAssignmentExpression()) }, _context ); var end = _tokenizer.NextToken.Span.End; try { parameters.Add(new ParameterDefinition(paramName, exp.Transform <Func <object, object> >().Compile()(null))); } catch (MissingMemberException) { _tokenizer.ErrorSink.Add(_context.SourceUnit, "関数の既定値には定数のみが使用できます。", new SourceSpan(start, end), -2, Severity.Error); throw new InternalInvalidSyntaxException(); } } else if (Accept(TokenType.SymbolAsterisk)) { parameters.Add(new ParameterDefinition(paramName, true)); } else { parameters.Add(new ParameterDefinition(paramName, false)); } } } } List <Statement> statements = new List <Statement>(); Expect(TokenType.SymbolOpenBrace); while (!Accept(TokenType.SymbolCloseBrace)) { statements.Add(ParseStatement()); } return(new FunctionDefinition(name, parameters, statements)); }
public AstScopeNode(SourceUnitTree ast, ProjectEntry projectEntry) { _ast = ast; _projectEntry = projectEntry; }
public override bool Enter(SourceUnitTree node) { Print("********************* Code Tree *********************"); return(true); }
public SourceUnitTree ParseProgram() { if (Next().Is(TokenType.Eof)) return new SourceUnitTree { Token = Next() }; var tree = new SourceUnitTree { Token = Next(), SourceElements = ParseSourceElements() }; Match(TokenType.Eof); return tree; }
private void DumpRegularExpressions(SourceUnitTree /*!*/ ast) { new RegexDumper(_regexLog).Walk(ast); }
private void DumpFile(string /*!*/ path) { _log.WriteLine(path); try { string fullPath = Path.GetFullPath(path); string root = Path.GetPathRoot(fullPath); string outputPath = Path.ChangeExtension(Path.Combine(_targetDir, fullPath.Substring(root.Length).TrimEnd('\'', '/')), ".txt"); Directory.CreateDirectory(Path.GetDirectoryName(outputPath)); using (TextWriter output = File.CreateText(outputPath)) { output.WriteLine(fullPath); output.WriteLine(); output.WriteLine("Tokens:"); output.WriteLine(); ErrorLog errors = new ErrorLog(); Parser parser = new Parser(); parser.TokenSink = delegate(Tokens token, SourceSpan span) { DumpTokenDetail(output, parser.Tokenizer, token); }; if (_logProductions) { #if DEBUG parser.EnableLogging(new CoverageParserLogger(parser, _parserLog)); #endif } _currentSourceFile = path; SourceUnitTree ast = null; try { ast = parser.Parse(_context.CreateFileUnit(path), new RubyCompilerOptions(), errors); } catch (Exception e) { WriteException(e.ToString()); } output.WriteLine(); if (errors.ErrorCount + errors.FatalErrorCount + errors.WarningCount > 0) { output.WriteLine(); output.WriteLine("Errors:"); foreach (string error in errors.Errors) { output.WriteLine(error); } } else { Debug.Assert(ast != null); DumpRegularExpressions(ast); } output.WriteLine("."); } } catch (Exception e) { _log.WriteLine("!{0}", e.Message); } finally { _currentSourceFile = null; _regexLog.Flush(); _parserLog.Flush(); } }
public Transformer(SourceUnitTree AST) { this.AST = AST; }
public override object Walk(SourceUnitTree node) { return node.SourceElements == null ? null : node.SourceElements.Accept(this); }
public override void Exit(SourceUnitTree node) { }
public virtual bool Enter(SourceUnitTree node) { return(true); }
public override object Walk(SourceUnitTree node) { return(node.SourceElements == null ? null : node.SourceElements.Accept(this)); }