private ScriptCode /*!*/ CompileRubySource(SourceUnit /*!*/ sourceUnit, LoadFlags flags) { Assert.NotNull(sourceUnit); // TODO: check file timestamp string fullPath = Platform.GetFullPath(sourceUnit.Path); #if FEATURE_FILESYSTEM CompiledFile compiledFile; if (TryGetCompiledFile(fullPath, out compiledFile)) { Utils.Log(String.Format("{0}: {1}", ++_cacheHitCount, sourceUnit.Path), "LOAD_CACHED"); return(compiledFile.CompiledCode); } Utils.Log(String.Format("{0}: {1}", ++_compiledFileCount, sourceUnit.Path), "LOAD_COMPILED"); #endif RubyCompilerOptions options = new RubyCompilerOptions(_context.RubyOptions) { FactoryKind = (flags & LoadFlags.LoadIsolated) != 0 ? TopScopeFactoryKind.WrappedFile : TopScopeFactoryKind.File }; ScriptCode compiledCode = sourceUnit.Compile(options, _context.RuntimeErrorSink); #if FEATURE_FILESYSTEM AddCompiledFile(fullPath, compiledCode); #endif return(compiledCode); }
private void ExecuteRubySourceUnit(SourceUnit /*!*/ sourceUnit, Scope /*!*/ globalScope, LoadFlags flags) { Assert.NotNull(sourceUnit, globalScope); // TODO: check file timestamp string fullPath = Platform.GetFullPath(sourceUnit.Path); CompiledFile compiledFile; if (TryGetCompiledFile(fullPath, out compiledFile)) { Utils.Log(String.Format("{0}: {1}", ++_cacheHitCount, sourceUnit.Path), "LOAD_CACHED"); compiledFile.CompiledCode.Run(globalScope); } else { Utils.Log(String.Format("{0}: {1}", ++_compiledFileCount, sourceUnit.Path), "LOAD_COMPILED"); RubyCompilerOptions options = new RubyCompilerOptions(_context.RubyOptions) { IsIncluded = true, IsWrapped = (flags & LoadFlags.LoadIsolated) != 0, }; long ts1 = Stopwatch.GetTimestamp(); ScriptCode compiledCode = sourceUnit.Compile(options, _context.RuntimeErrorSink); long ts2 = Stopwatch.GetTimestamp(); Interlocked.Add(ref _ScriptCodeGenerationTimeTicks, ts2 - ts1); AddCompiledFile(fullPath, compiledCode); CompileAndRun(globalScope, compiledCode, _context.Options.InterpretedMode); } }
public TraceAstGenerator(Dictionary <MSA.DynamicExpression, SourceSpan> /*!*/ sites, RubyContext /*!*/ context, RubyCompilerOptions /*!*/ options, SourceUnit /*!*/ sourceUnit, Encoding /*!*/ encoding) : base((RubyBinder)context.Binder, options, sourceUnit, encoding, false, context.DomainManager.Configuration.DebugMode, false, false, false) { _sites = sites; }
private ScriptCode /*!*/ CompileRubySource(SourceUnit /*!*/ sourceUnit, LoadFlags flags) { Assert.NotNull(sourceUnit); // TODO: check file timestamp string fullPath = Platform.GetFullPath(sourceUnit.Path); CompiledFile compiledFile; if (TryGetCompiledFile(fullPath, out compiledFile)) { Utils.Log(String.Format("{0}: {1}", ++_cacheHitCount, sourceUnit.Path), "LOAD_CACHED"); return(compiledFile.CompiledCode); } else { Utils.Log(String.Format("{0}: {1}", ++_compiledFileCount, sourceUnit.Path), "LOAD_COMPILED"); RubyCompilerOptions options = new RubyCompilerOptions(_context.RubyOptions) { FactoryKind = (flags & LoadFlags.LoadIsolated) != 0 ? TopScopeFactoryKind.WrappedFile : TopScopeFactoryKind.File }; long ts1 = Stopwatch.GetTimestamp(); ScriptCode compiledCode = sourceUnit.Compile(options, _context.RuntimeErrorSink); long ts2 = Stopwatch.GetTimestamp(); Interlocked.Add(ref _ScriptCodeGenerationTimeTicks, ts2 - ts1); AddCompiledFile(fullPath, compiledCode); return(compiledCode); } }
private SourceUnitTree MakeParseTree(TextContentProvider /*!*/ content, ErrorSink /*!*/ errorSink) { var source = new SourceUnit(HostingHelpers.GetLanguageContext(_engine), content, null, SourceCodeKind.File); var options = new RubyCompilerOptions(); var parser = new Parser(); try { int attempts = 10; while (true) { try { return(parser.Parse(source, options, errorSink)); } catch (IOException) { // file being copied, try again... if (attempts > 0) { Thread.Sleep(100); attempts--; } else { throw; } } } } catch (Exception e) { Debug.Assert(false, String.Format("Failure in IronRuby parser: {0}", e.ToString())); return(null); } }
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 SourceUnitTree CreateAst(string fileName, ITextBuffer fileContent) { if (scriptEngine == null) { scriptEngine = Ruby.CreateEngine(); } RubyContext rubyContext = HostingHelpers.GetLanguageContext(scriptEngine) as RubyContext; sourceUnit = rubyContext.CreateFileUnit(fileName, fileContent.Text); RubyCompilerSink sink = new RubyCompilerSink(); RubyCompilerOptions compilerOptions = new RubyCompilerOptions((RubyOptions)rubyContext.Options); Parser parser = new Parser(); return parser.Parse(sourceUnit, compilerOptions, sink); }
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)); }
internal AstGenerator(RubyBinder /*!*/ binder, RubyCompilerOptions /*!*/ options, SourceUnit /*!*/ sourceUnit, Encoding /*!*/ encoding, bool debugCompiler, bool debugMode, bool traceEnabled, bool profilerEnabled, bool savingToDisk) { Assert.NotNull(binder, options, encoding); _binder = binder; _compilerOptions = options; _debugCompiler = debugCompiler; _debugMode = debugMode; _traceEnabled = traceEnabled; _sourceUnit = sourceUnit; _document = sourceUnit.Document; _encoding = encoding; _profiler = profilerEnabled ? Profiler.Instance : null; _savingToDisk = savingToDisk; }
internal AstGenerator(RubyCompilerOptions/*!*/ options, SourceUnit/*!*/ sourceUnit, RubyEncoding/*!*/ encoding, bool debugCompiler, bool debugMode, bool traceEnabled, bool profilerEnabled, bool savingToDisk) { Assert.NotNull(options, encoding, sourceUnit); _context = (RubyContext)sourceUnit.LanguageContext; _compilerOptions = options; _debugCompiler = debugCompiler; _debugMode = debugMode; _traceEnabled = traceEnabled; _sourceUnit = sourceUnit; _document = sourceUnit.Document; _encoding = encoding; _profiler = profilerEnabled ? Profiler.Instance : null; _savingToDisk = savingToDisk; }
private MSA.Expression _sourcePathConstant; // lazy internal AstGenerator(RubyContext/*!*/ context, RubyCompilerOptions/*!*/ options, MSA.SymbolDocumentInfo document, RubyEncoding/*!*/ encoding, bool printInteractiveResult) { Assert.NotNull(context, options, encoding); _context = context; _compilerOptions = options; _debugCompiler = Snippets.Shared.SaveSnippets; _debugMode = context.DomainManager.Configuration.DebugMode; _traceEnabled = context.RubyOptions.EnableTracing; _document = document; _encoding = encoding; _profiler = context.RubyOptions.Profile ? Profiler.Instance : null; _savingToDisk = context.RubyOptions.SavePath != null; _printInteractiveResult = printInteractiveResult; }
private void AstLocations1() { // DumpExpression uses private reflection: if (_driver.PartialTrust) { return; } var sourceUnit = Context.CreateSnippet(@" def add a,b a + b end add 1, 1 add 'foo', 'bar' ", SourceCodeKind.Expression); var options = new RubyCompilerOptions(); var parser = new Parser(); var tokens = new List <KeyValuePair <SourceSpan, Tokens> >(); parser.TokenSink = (token, span) => { tokens.Add(new KeyValuePair <SourceSpan, Tokens>(span, token)); }; var ast = parser.Parse(sourceUnit, options, Context.RuntimeErrorSink); const int Id = 0x12345678; var lambda = CallSiteTracer.Transform <DlrMainCallTarget>(ast, sourceUnit, options, Id); var code = new ScriptCode(lambda, sourceUnit); var locations = new List <int>(); CallSiteTracer.Register((context, args, result, id, location) => { locations.Add(location); Debug.Assert(id == Id); Debug.Assert(location > 0); //Console.WriteLine("-- {0} ---------", location); //Console.WriteLine(this); //Console.WriteLine(AstUtils.DumpExpression(result.Restrictions.ToExpression())); //Console.WriteLine(); //Console.WriteLine(AstUtils.DumpExpression(result.Expression)); //Console.WriteLine("----------------"); }); code.Run(); Debug.Assert(locations.Count == 4 && locations[0] == 31 && locations[1] == 19 && locations[2] == 41 && locations[3] == 19); }
internal AstGenerator(RubyContext /*!*/ context, RubyCompilerOptions /*!*/ options, MSA.SymbolDocumentInfo document, RubyEncoding /*!*/ encoding, bool printInteractiveResult) { Assert.NotNull(context, options, encoding); _context = context; _compilerOptions = options; _debugMode = context.DomainManager.Configuration.DebugMode; _traceEnabled = context.RubyOptions.EnableTracing; _document = document; _sequencePointClearance = (document != null) ? Ast.ClearDebugInfo(document) : null; _encoding = encoding; _encodingConstant = Ast.Constant(encoding); _profiler = context.RubyOptions.Profile ? Profiler.Instance : null; _savingToDisk = context.RubyOptions.SavePath != null; _printInteractiveResult = printInteractiveResult; #if !SILVERLIGHT _debugCompiler = Snippets.Shared.SaveSnippets; #endif }
private void ParserLoggingTest() { #if DEBUG string source = "def foo(a); end"; var sourceUnit = Context.CreateSnippet(source, SourceCodeKind.Statements); var options = new RubyCompilerOptions(); string temp = Path.Combine(Path.GetTempPath(), "RubyParser"); Console.WriteLine("> see {0}", temp); Directory.CreateDirectory(temp); Parser parser = new Parser(); using (TextWriter writer = File.CreateText(Path.Combine(temp, "default.log"))) { DefaultParserLogger.Attach(parser, writer); parser.Parse(sourceUnit, options, ErrorSink.Null); } using (TextWriter writer = File.CreateText(Path.Combine(temp, "tables.csv"))) { parser.DumpTables(writer); } using (TextWriter writer = File.CreateText(Path.Combine(temp, "productions.txt"))) { for (int i = 0; i < parser.RuleLhsNonTerminals.Length; i++) { writer.WriteLine("{0}\t{1}", i, parser.RuleToString(i)); } } parser = new Parser(); using (TextWriter writer = File.CreateText(Path.Combine(temp, "productions.txt"))) { for (int i = 0; i < parser.RuleLhsNonTerminals.Length; i++) { writer.WriteLine("{0}\t{1}", i, parser.RuleToString(i)); } } using (TextWriter writer = File.CreateText(Path.Combine(temp, "second_order.log"))) { parser.EnableLogging(new CoverageParserLogger(parser, writer)); parser.Parse(sourceUnit, options, ErrorSink.Null); } #endif }
internal AstGenerator(RubyContext/*!*/ context, RubyCompilerOptions/*!*/ options, MSA.SymbolDocumentInfo document, RubyEncoding/*!*/ encoding, bool printInteractiveResult) { Assert.NotNull(context, options, encoding); _context = context; _compilerOptions = options; _debugMode = context.DomainManager.Configuration.DebugMode; _traceEnabled = context.RubyOptions.EnableTracing; _document = document; _sequencePointClearance = (document != null) ? Ast.ClearDebugInfo(document) : null; _encoding = encoding; _encodingConstant = Ast.Constant(encoding); _profiler = context.RubyOptions.Profile ? Profiler.Instance : null; _savingToDisk = context.RubyOptions.SavePath != null; _printInteractiveResult = printInteractiveResult; #if SILVERLIGHT _debugCompiler = false; #else _debugCompiler = Snippets.Shared.SaveSnippets; #endif }
private void Benchmark(List <string> /*!*/ files) { var sources = new List <SourceUnit>(); Stopwatch readTime = new Stopwatch(); long totalSize = 0; readTime.Start(); foreach (string path in files) { try { byte[] data = File.ReadAllBytes(path); sources.Add(_context.CreateSourceUnit(new BinaryContentProvider(data), path, Encoding.Default, SourceCodeKind.File)); totalSize += data.Length; } catch (Exception) { Console.WriteLine("Error: {0}", path); } } readTime.Stop(); Console.WriteLine("Read: {0} kB in {1}", totalSize / 1024, readTime.Elapsed); #if F Stopwatch tokenizeTime = new Stopwatch(); tokenizeTime.Start(); foreach (var source in sources) { try { var tokenizer = new Tokenizer(); tokenizer.Initialize(source); Tokens token; do { token = tokenizer.GetNextToken(); } while (token != Tokens.EndOfFile); } catch (Exception) { Console.WriteLine("Tokenization error: {0}", source.Path); break; } } tokenizeTime.Stop(); #endif //var stackSizes = new Dictionary<int, int>(); var options = new RubyCompilerOptions(); Stopwatch parseTime = new Stopwatch(); Stopwatch transformTime = new Stopwatch(); foreach (var source in sources) { try { parseTime.Start(); var parser = new Parser(); parser.Parse(source, options, ErrorSink.Null); //int mt; //stackSizes[parser.StackMaxTop] = stackSizes.TryGetValue(parser.StackMaxTop, out mt) ? mt + 1 : 1; parseTime.Stop(); #if F if (rubyTree != null) { transformTime.Start(); var lambda = _context.TransformTree <DlrMainCallTarget>(rubyTree, source, options); transformTime.Stop(); } else { Console.WriteLine("SyntaxError: {0}", source.Path); } #endif } catch (Exception e) { Console.WriteLine("{0}: {1}: {2}", e.GetType().Name, source.Path, e.Message); break; } } // Console.WriteLine("Tokenize: {0}", tokenizeTime.Elapsed); Console.WriteLine("Parse: {0}", parseTime.Elapsed); //Console.WriteLine("Idf/Kwd/Loc: {0}/{1}/{2}", Tokenizer.IdfLength, Tokenizer.KwdLength, Tokenizer.LocLength); // Console.WriteLine("Transform: {0}", transformTime.Elapsed); //PerfTrack.DumpHistogram(Parser.Reductions); //PerfTrack.DumpHistogram(stackSizes); }