private AstRoot Parse(CharSequence cs) { CompilerEnvirons compilerEnv = new CompilerEnvirons(); compilerEnv.InitFromContext(cx); ErrorReporter compilationErrorReporter = compilerEnv.GetErrorReporter(); Parser p = new Parser(compilerEnv, compilationErrorReporter); return p.Parse(cs.ToString(), "<eval>", 1); }
/// <summary> /// Compiles /// <code>source</code> /// and returns the transformed and optimized /// <see cref="Rhino.Ast.ScriptNode">Rhino.Ast.ScriptNode</see> /// </summary> protected internal virtual ScriptNode Compile(CharSequence source) { string mainMethodClassName = "Main"; string scriptClassName = "Main"; CompilerEnvirons compilerEnv = new CompilerEnvirons(); compilerEnv.InitFromContext(cx); ErrorReporter compilationErrorReporter = compilerEnv.GetErrorReporter(); Parser p = new Parser(compilerEnv, compilationErrorReporter); AstRoot ast = p.Parse(source.ToString(), "<eval>", 1); IRFactory irf = new IRFactory(compilerEnv); ScriptNode tree = irf.TransformTree(ast); Codegen codegen = new Codegen(); codegen.SetMainMethodClass(mainMethodClassName); codegen.CompileToClassFile(compilerEnv, scriptClassName, tree, tree.GetEncodedSource(), false); return tree; }
/// <exception cref="System.IO.IOException"></exception> private object CompileImpl(Scriptable scope, TextReader sourceReader, string sourceString, string sourceName, int lineno, object securityDomain, bool returnFunction, Evaluator compiler, ErrorReporter compilationErrorReporter) { if (sourceName == null) { sourceName = "unnamed script"; } if (securityDomain != null && GetSecurityController() == null) { throw new ArgumentException("securityDomain should be null if setSecurityController() was never called"); } // One of sourceReader or sourceString has to be null if (!(sourceReader == null ^ sourceString == null)) { Kit.CodeBug(); } // scope should be given if and only if compiling function if (!(scope == null ^ returnFunction)) { Kit.CodeBug(); } CompilerEnvirons compilerEnv = new CompilerEnvirons(); compilerEnv.InitFromContext(this); if (compilationErrorReporter == null) { compilationErrorReporter = compilerEnv.GetErrorReporter(); } if (debugger != null) { if (sourceReader != null) { sourceString = Kit.ReadReader(sourceReader); sourceReader = null; } } Parser p = new Parser(compilerEnv, compilationErrorReporter); if (returnFunction) { p.calledByCompileFunction = true; } AstRoot ast; if (sourceString != null) { ast = p.Parse(sourceString, sourceName, lineno); } else { ast = p.Parse(sourceReader, sourceName, lineno); } if (returnFunction) { // parser no longer adds function to script node if (!(ast.GetFirstChild() != null && ast.GetFirstChild().GetType() == Token.FUNCTION)) { // XXX: the check just looks for the first child // and allows for more nodes after it for compatibility // with sources like function() {};;; throw new ArgumentException("compileFunction only accepts source with single JS function: " + sourceString); } } IRFactory irf = new IRFactory(compilerEnv, compilationErrorReporter); ScriptNode tree = irf.TransformTree(ast); // discard everything but the IR tree p = null; ast = null; irf = null; if (compiler == null) { compiler = CreateCompiler(); } object bytecode = compiler.Compile(compilerEnv, tree, tree.GetEncodedSource(), returnFunction); if (debugger != null) { if (sourceString == null) { Kit.CodeBug(); } if (bytecode is DebuggableScript) { DebuggableScript dscript = (DebuggableScript)bytecode; NotifyDebugger_r(this, dscript, sourceString); } else { throw new Exception("NOT SUPPORTED"); } } object result; if (returnFunction) { result = compiler.CreateFunctionObject(this, scope, bytecode, securityDomain); } else { result = compiler.CreateScriptObject(bytecode, securityDomain); } return result; }
/// <summary>Check whether a string is ready to be compiled.</summary> /// <remarks> /// Check whether a string is ready to be compiled. /// <p> /// stringIsCompilableUnit is intended to support interactive compilation of /// JavaScript. If compiling the string would result in an error /// that might be fixed by appending more source, this method /// returns false. In every other case, it returns true. /// <p> /// Interactive shells may accumulate source lines, using this /// method after each new line is appended to check whether the /// statement being entered is complete. /// </remarks> /// <param name="source">the source buffer to check</param> /// <returns>whether the source is ready for compilation</returns> /// <since>1.4 Release 2</since> public bool StringIsCompilableUnit(string source) { bool errorseen = false; CompilerEnvirons compilerEnv = new CompilerEnvirons(); compilerEnv.InitFromContext(this); // no source name or source text manager, because we're just // going to throw away the result. compilerEnv.SetGeneratingSource(false); Parser p = new Parser(compilerEnv, DefaultErrorReporter.instance); try { p.Parse(source, null, 1); } catch (EvaluatorException) { errorseen = true; } // Return false only if an error occurred as a result of reading past // the end of the file, i.e. if the source could be fixed by // appending more source. if (errorseen && p.Eof()) { return false; } else { return true; } }