CompileToClassFile() public méthode

public CompileToClassFile ( CompilerEnvirons compilerEnv, string mainClassName, ScriptNode scriptOrFn, string encodedSource, bool returnFunction ) : byte[]
compilerEnv Rhino.CompilerEnvirons
mainClassName string
scriptOrFn Rhino.Ast.ScriptNode
encodedSource string
returnFunction bool
Résultat byte[]
Codegen Class Documentation
Exemple #1
0
			/// <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;
			}
Exemple #2
0
		/// <summary>Compile JavaScript source into one or more Java class files.</summary>
		/// <remarks>
		/// Compile JavaScript source into one or more Java class files.
		/// The first compiled class will have name mainClassName.
		/// If the results of
		/// <see cref="GetTargetExtends()">GetTargetExtends()</see>
		/// or
		/// <see cref="GetTargetImplements()">GetTargetImplements()</see>
		/// are not null, then the first compiled
		/// class will extend the specified super class and implement
		/// specified interfaces.
		/// </remarks>
		/// <returns>
		/// array where elements with even indexes specifies class name
		/// and the following odd index gives class file body as byte[]
		/// array. The initial element of the array always holds
		/// mainClassName and array[1] holds its byte code.
		/// </returns>
		public virtual object[] CompileToClassFiles(string source, string sourceLocation, int lineno, string mainClassName)
		{
			Parser p = new Parser(compilerEnv);
			AstRoot ast = p.Parse(source, sourceLocation, lineno);
			IRFactory irf = new IRFactory(compilerEnv);
			ScriptNode tree = irf.TransformTree(ast);
			// release reference to original parse tree & parser
			irf = null;
			ast = null;
			p = null;
			Type superClass = GetTargetExtends();
			Type[] interfaces = GetTargetImplements();
			string scriptClassName;
			bool isPrimary = (interfaces == null && superClass == null);
			if (isPrimary)
			{
				scriptClassName = mainClassName;
			}
			else
			{
				scriptClassName = MakeAuxiliaryClassName(mainClassName, "1");
			}
			Codegen codegen = new Codegen();
			codegen.SetMainMethodClass(mainMethodClassName);
			byte[] scriptClassBytes = codegen.CompileToClassFile(compilerEnv, scriptClassName, tree, tree.GetEncodedSource(), false);
			if (isPrimary)
			{
				return new object[] { scriptClassName, scriptClassBytes };
			}
			int functionCount = tree.GetFunctionCount();
			ObjToIntMap functionNames = new ObjToIntMap(functionCount);
			for (int i = 0; i != functionCount; ++i)
			{
				FunctionNode ofn = tree.GetFunctionNode(i);
				string name = ofn.GetName();
				if (name != null && name.Length != 0)
				{
					functionNames.Put(name, ofn.GetParamCount());
				}
			}
			if (superClass == null)
			{
				superClass = ScriptRuntime.ObjectClass;
			}
			byte[] mainClassBytes = JavaAdapter.CreateAdapterCode(functionNames, mainClassName, superClass, interfaces, scriptClassName);
			return new object[] { mainClassName, mainClassBytes, scriptClassName, scriptClassBytes };
		}