| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package org.apache.flex.compiler.internal.as.codegen; |
| |
| import static org.apache.flex.abc.ABCConstants.OP_add; |
| import static org.apache.flex.abc.ABCConstants.OP_getlocal0; |
| import static org.apache.flex.abc.ABCConstants.OP_pushscope; |
| import static org.apache.flex.abc.ABCConstants.OP_returnvalue; |
| import static org.apache.flex.abc.ABCConstants.OP_returnvoid; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Date; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Vector; |
| import java.util.concurrent.ExecutorService; |
| import java.util.concurrent.Future; |
| |
| import org.apache.flex.abc.ABCConstants; |
| import org.apache.flex.abc.instructionlist.InstructionList; |
| import org.apache.flex.abc.semantics.MethodBodyInfo; |
| import org.apache.flex.abc.semantics.MethodInfo; |
| import org.apache.flex.abc.semantics.Name; |
| import org.apache.flex.abc.visitors.IMethodBodyVisitor; |
| import org.apache.flex.abc.visitors.IMethodVisitor; |
| import org.apache.flex.abc.visitors.IScriptVisitor; |
| import org.apache.flex.abc.visitors.IVisitor; |
| import org.apache.flex.compiler.definitions.references.IReference; |
| import org.apache.flex.compiler.exceptions.BURMAbortException; |
| import org.apache.flex.compiler.exceptions.CodegenInterruptedException; |
| import org.apache.flex.compiler.exceptions.MissingBuiltinException; |
| import org.apache.flex.compiler.internal.as.codegen.ICodeGenerator.IConstantValue; |
| import org.apache.flex.compiler.internal.definitions.FunctionDefinition; |
| import org.apache.flex.compiler.internal.definitions.ParameterDefinition; |
| import org.apache.flex.compiler.internal.definitions.TypeDefinitionBase; |
| import org.apache.flex.compiler.internal.embedding.EmbedData; |
| import org.apache.flex.compiler.internal.scopes.ASScope; |
| import org.apache.flex.compiler.internal.testing.NodesToXMLStringFormatter; |
| import org.apache.flex.compiler.internal.tree.as.FunctionNode; |
| import org.apache.flex.compiler.internal.tree.mxml.MXMLFileNode; |
| import org.apache.flex.compiler.internal.units.requests.ABCBytesRequestResult; |
| import org.apache.flex.compiler.problems.CodegenInternalProblem; |
| import org.apache.flex.compiler.problems.ICompilerProblem; |
| import org.apache.flex.compiler.problems.MissingBuiltinProblem; |
| import org.apache.flex.compiler.projects.ICompilerProject; |
| import org.apache.flex.compiler.tree.as.IASNode; |
| import org.apache.flex.compiler.tree.as.IExpressionNode; |
| import org.apache.flex.compiler.units.ICompilationUnit; |
| import org.apache.flex.compiler.units.ICompilationUnit.Operation; |
| import org.apache.flex.compiler.units.requests.IABCBytesRequestResult; |
| |
| import com.google.common.util.concurrent.Futures; |
| |
| /** |
| * ABCGenerator is the public interface to the code generator. |
| */ |
| |
| /** |
| * JSGenerator is modeled after from ABCGenerator and called by |
| * JSCompilationUnit. JSGenerator owns the JSSharedData singleton. Ideally |
| * JSGenerator and ABCGenerator should be derived from the same base class, i.e. |
| * Generator. Some of the code in JSGenerator and ABCGenerator could be shared |
| * if Generator used a burm factory in generateInstructions(). ABCGenerator |
| * creates and uses a CmcEmitter, while JSGenerator uses a CmcJSEmitter. This |
| * implementation is part of FalconJS. For more details on FalconJS see |
| * org.apache.flex.compiler.JSDriver |
| */ |
| public class JSGenerator implements ICodeGenerator |
| { |
| public ICompilationUnit m_compilationUnit = null; |
| private Boolean m_needsSecondPass = false; |
| private CmcJSEmitter m_cmcJSEmitter = null; |
| private JSGeneratingReducer m_burm = null; |
| private ICompilationUnit.Operation m_buildPhase = Operation.GET_ABC_BYTES; |
| private JSEmitter m_emitter = null; |
| |
| public JSGenerator() |
| { |
| m_cmcJSEmitter = JSSharedData.backend.createCmcJSEmitter(); |
| m_cmcJSEmitter.reducer = JSSharedData.backend.createReducer(); |
| m_burm = m_cmcJSEmitter.reducer; |
| } |
| |
| // If JSEmitter.needsSecondPass() returns true, JSGenerator.generate() will return null during scanning, |
| // which will result in JSCompilationUnit::handleSemanticProblemsRequest not caching any abcBytes for |
| // handleABCBytesRequest. The net result is that JSGenerator.generate() will be called again in handleABCBytesRequest. |
| // This mechanic will ensure selective two-pass compilation. |
| public Boolean needsSecondPass() |
| { |
| return m_needsSecondPass; |
| } |
| |
| /* |
| * There are currently a lot of problems with the DependencyGraph: - |
| * ImportNode::resolveRefs() has not been implemented. - import and |
| * expression dependencies are not being recognized. If |
| * useOwnDependencyGraph() returns true we use our own (old) DependencyGraph |
| * implementation that used to drive the while loop in |
| * JSGenerator.generate() using nextJS. - JSDriver does a second pass - |
| * JSGlobalDirectiveProcessor::processImportDirective() registers imported |
| * classes. |
| */ |
| public static Boolean useOwnDependencyGraph() |
| { |
| // return true; |
| return false; |
| } |
| |
| /** |
| * Generate an ABC file equivalent to the input syntax tree. |
| * |
| * @param synthetic_name_prefix Prefix to prepend to all synthetic names |
| * @param root_node the root of the syntax tree. |
| * @param project {@link ICompilerProject} whose symbol table is used to |
| * resolve references to definitions. |
| * @throws InterruptedException |
| */ |
| @SuppressWarnings("nls") |
| public ABCBytesRequestResult generate(String synthetic_name_prefix, IASNode root_node, ICompilerProject project) throws InterruptedException |
| { |
| return generate(null, false, synthetic_name_prefix, root_node, project, false, Collections.<String, String>emptyMap()); |
| } |
| |
| @Override |
| public ABCBytesRequestResult generate(ExecutorService executorService, boolean useParallelCodegen, |
| String synthetic_name_prefix, IASNode root_node, |
| ICompilerProject project, boolean inInvisibleCompilationUnit, |
| Map<String, String> encodedDebugFiles) |
| throws InterruptedException |
| { |
| m_needsSecondPass = false; |
| if (root_node instanceof MXMLFileNode) |
| m_emitter = new JSMXMLEmitter(JSSharedData.instance, m_buildPhase, project, this); |
| else |
| m_emitter = JSSharedData.backend.createEmitter(m_buildPhase, project, this); |
| m_emitter.visit(ABCConstants.VERSION_ABC_MAJOR_FP10, ABCConstants.VERSION_ABC_MINOR_FP10); |
| |
| IScriptVisitor sv = m_emitter.visitScript(); |
| sv.visit(); |
| MethodInfo init_method = new MethodInfo(); |
| sv.visitInit(init_method); |
| |
| MethodBodyInfo init_body = new MethodBodyInfo(); |
| init_body.setMethodInfo(init_method); |
| |
| IMethodVisitor mv = m_emitter.visitMethod(init_method); |
| IMethodBodyVisitor mbv = mv.visitBody(init_body); |
| mbv.visit(); |
| |
| // Set up the global lexical scope. |
| final LexicalScope global_scope = new GlobalLexicalScope(project, this, synthetic_name_prefix, m_emitter); |
| global_scope.traitsVisitor = sv.visitTraits(); |
| global_scope.setMethodInfo(init_method); |
| global_scope.methodBodyVisitor = mbv; |
| |
| // Process global directives. |
| GlobalDirectiveProcessor top_level_processor = JSSharedData.backend.createGlobalDirectiveProcessor(this, global_scope, m_emitter); |
| boolean fatal_error_encountered = false; |
| try |
| { |
| top_level_processor.traverse(root_node); |
| } |
| catch (MissingBuiltinException e) |
| { |
| global_scope.addProblem(new MissingBuiltinProblem(root_node, e.getBuiltinName())); |
| fatal_error_encountered = true; |
| } |
| catch (CodegenInterruptedException e) |
| { |
| // Unwrap the InterruptedException and rethrow it. |
| throw e.getException(); |
| } |
| |
| byte[] generatedBytes = IABCBytesRequestResult.ZEROBYTES; |
| |
| if (!fatal_error_encountered) |
| { |
| // Initialize the init script. |
| InstructionList script_init_insns = new InstructionList(); |
| |
| script_init_insns.addInstruction(OP_getlocal0); |
| script_init_insns.addInstruction(OP_pushscope); |
| |
| script_init_insns.addAll(global_scope.getInitInstructions()); |
| script_init_insns.addAll(top_level_processor.directiveInsns); |
| |
| if (script_init_insns.canFallThrough() || script_init_insns.hasPendingLabels()) |
| script_init_insns.addInstruction(OP_returnvoid); |
| |
| // Allocate temps beginning with register 1, |
| // register 0 is reserved for "this" global. |
| global_scope.initializeTempRegisters(1); |
| |
| mbv.visitInstructionList(script_init_insns); |
| mbv.visitEnd(); |
| mv.visitEnd(); |
| sv.visitEnd(); |
| |
| try |
| { |
| generatedBytes = m_emitter.emit(); |
| } |
| catch (Throwable cant_generate) |
| { |
| global_scope.addProblem(new CodegenInternalProblem(root_node, cant_generate)); |
| } |
| } |
| |
| ICompilerProblem[] problemsArray = global_scope.getProblems().toArray(IABCBytesRequestResult.ZEROPROBLEMS); |
| return new ABCBytesRequestResult(generatedBytes, problemsArray, Collections.<EmbedData> emptySet()); |
| } |
| |
| /** |
| * Translate an AST into ABC instructions. |
| * |
| * @param subtree - the CM subtree. |
| * @param goal_state - the desired goal state. One of the nonterminal states |
| * in CmcJSEmitter, or 0 if you're feeling lucky and are willing to accept |
| * whatever instruction sequence the BURM decides is optimal. |
| * @param scope - the active lexical scope. |
| * @return a list of ABC instructions. |
| */ |
| public InstructionList generateInstructions(IASNode subtree, int goal_state, LexicalScope scope) |
| { |
| return generateInstructions(subtree, goal_state, scope, null); |
| } |
| |
| /** |
| * Translate an AST into ABC instructions. |
| * |
| * @param subtree - the CM subtree. |
| * @param goal_state - the desired goal state. One of the nonterminal states |
| * in CmcJSEmitter, or 0 if you're feeling lucky and are willing to accept |
| * whatever instruction sequence the BURM decides is optimal. |
| * @param scope - the active lexical scope. |
| * @param instance_init_insns - a list of instance initialization |
| * instructions collected outside a constructor body that must be included |
| * in the constructor. |
| * @post if instance_init_insns is not null then the method will have been |
| * processed as and marked as a constructor. |
| * @return a list of ABC instructions. |
| */ |
| public InstructionList generateInstructions(IASNode subtree, int goal_state, LexicalScope scope, InstructionList instance_init_insns) |
| { |
| m_burm.setCurrentscope(scope); |
| m_burm.setInstanceInitializers(instance_init_insns); |
| m_burm.setAprioriinstructions(instance_init_insns); |
| m_burm.setFunctionNode(subtree); |
| |
| InstructionList list = new InstructionList(); |
| |
| try |
| { |
| m_cmcJSEmitter.burm(subtree, goal_state); |
| |
| // TODO: cmcJSEmitter.getResult() now returns a String, which needs to be wrapped into an InstructionList |
| // return ((InstructionList)cmcJSEmitter.getResult()); |
| list.addInstruction(JSSharedData.OP_JS, m_cmcJSEmitter.getResult()); |
| |
| // If JSEmitter.needsSecondPass() returns true, JSGenerator.generate() will return null during scanning, |
| // which will result in JSCompilationUnit::handleSemanticProblemsRequest not caching any abcBytes for |
| // handleABCBytesRequest. The net result is that JSGenerator.generate() will be called again in handleABCBytesRequest. |
| // This mechanic will ensure selective two-pass compilation. |
| if (m_burm.needsSecondPass()) |
| { |
| m_needsSecondPass = true; |
| } |
| } |
| catch (Exception cant_reduce) |
| { |
| handleBurmError(m_cmcJSEmitter, subtree, cant_reduce, scope); |
| } |
| |
| return list; |
| } |
| |
| /** |
| * Generate code for a function declaration, and put its initialization code |
| * on the relevant instruction list. |
| * |
| * @param func - the function declaration node. |
| * @param enclosing_scope - the lexical scope in which the function was |
| * defined. |
| * @param a_priori_insns - instructions generated by an enclosing subsystem |
| * that should be included in the function (e.g., a constructor needs a |
| * priori instructions to initialize instance vars). |
| */ |
| public MethodInfo generateFunction(FunctionNode func, LexicalScope enclosing_scope, InstructionList a_priori_insns) |
| { |
| m_burm.setCurrentscope(enclosing_scope); |
| MethodInfo mi = createMethodInfo(m_burm, m_emitter, enclosing_scope, func); |
| if (mi.isNative()) |
| { |
| generateNativeMethod(func, mi, enclosing_scope); |
| } |
| else |
| { |
| /* |
| * Now done in JSEmitter: // support for class inits. // If this is |
| * a static function and the owner class has a class init then call |
| * __static_init() final IDefinition fdef = func.getDefinition(); |
| * if( fdef.isStatic() && fdef.getParent() != null && |
| * fdef.getParent() instanceof ClassDefinition ) { final IDefinition |
| * cdef = fdef.getParent(); final String fullName = |
| * JSGeneratingReducer |
| * .createFullNameFromDefinition(enclosing_scope.getProject(),cdef); |
| * if( JSSharedData.instance.hasClassInit(fullName) ) { final String |
| * callInit = fullName + "." + JSSharedData.STATIC_INIT + "();\n"; |
| * if( a_priori_insns == null ) a_priori_insns = new |
| * InstructionList(); a_priori_insns.addInstruction( |
| * JSSharedData.OP_JS, callInit ); } } |
| */ |
| m_burm.startFunction(func); |
| generateMethodBodyForFunction(mi, func, enclosing_scope, a_priori_insns); |
| m_burm.endFunction(func); |
| } |
| |
| return mi; |
| } |
| |
| public GenerateFunctionInParallelResult generateFunctionInParallel (ExecutorService executorService, FunctionNode func, LexicalScope enclosing_scope) |
| { |
| /** AJH commented out for now |
| MethodInfo mi = createMethodInfo(enclosing_scope, func); |
| if (mi.isNative()) |
| { |
| generateNativeMethod(func, mi, enclosing_scope); |
| return new GenerateFunctionInParallelResult(Futures.immediateFuture(null), mi, Collections.<IVisitor>emptyList()); |
| } |
| GenerateFunctionRunnable runnable = new GenerateFunctionRunnable(mi, func, enclosing_scope); |
| Future<?> future = executorService.submit(runnable); |
| return new GenerateFunctionInParallelResult(future, mi, runnable.getDeferredVisitEndsList()); |
| */ |
| System.out.println("unhandled call to generateFunctionInParallel"); |
| return null; |
| } |
| |
| /** |
| * Helper method used by <code>generateFunction()</code>. |
| * |
| * @param func - the function declaration node. |
| * @param mi - the MethodInfo describing the signature |
| * @param enclosing_scope - the lexical scope in which the handler method is |
| * autogenerated. |
| */ |
| static void generateNativeMethod(FunctionNode func, MethodInfo mi, |
| LexicalScope enclosing_scope) |
| { |
| enclosing_scope.getMethodBodySemanticChecker().checkNativeMethod(func); |
| |
| // don't need to create a new scope, so just use the enclosing scope |
| // to get a handle to the emitter |
| IMethodVisitor mv = enclosing_scope.getEmitter().visitMethod(mi); |
| |
| // Just visit the method info. Do NOT generate a body |
| // for native methods |
| mv.visit(); |
| |
| // func.getReturnType() returns a short name string. |
| // But we need a real name. ctors don't have return types. |
| if (!func.isConstructor()) |
| { |
| final ASScope scope = (ASScope)JSGeneratingReducer.getScopeFromNode(func); |
| final FunctionDefinition fdef = func.getDefinition(); |
| final IReference ref = fdef.getReturnTypeReference(); |
| final Name returnTypeName = ref.getMName(enclosing_scope.getProject(), scope); |
| mi.setReturnType(returnTypeName); |
| } |
| |
| // For non native methods, the return type is set by the burm, |
| // but for native types, as the burm isn't run, we need to set |
| // the return type here. |
| // String returnType = func.getReturnType(); |
| // mi.setReturnType(new Name(returnType)); |
| |
| mv.visitEnd(); |
| } |
| |
| /** |
| * Helper method used by <code>generateFunction()</code> (and also by |
| * <code>generateEventHandler()</code> in MXMLDocumentDirectiveProcessor). |
| * |
| * @param mi - the MethodInfo describing the signature |
| * @param node - the FunctionNode or MXMLEventSpecifierNode. may be null |
| * when generating method bodies for purely synthetic functions, such as |
| * theIEventDispatcher methods that [Bindable] introduces. |
| * @param enclosing_scope - the lexical scope in which the handler method is |
| * autogenerated. |
| * @param a_priori_insns - instructions generated by an enclosing subsystem |
| * that should be included in the function (e.g., a constructor needs a |
| * priori instructions to initialize instance vars). |
| */ |
| public void generateMethodBodyForFunction(MethodInfo mi, IASNode node, |
| LexicalScope enclosing_scope, |
| InstructionList a_priori_insns) |
| { |
| generateMethodBody(mi, node, enclosing_scope, a_priori_insns, CmcEmitter.__function_NT, null); |
| } |
| |
| /** |
| * Helper methods used by databinding codegen to emit anonymous functions |
| * based on an expression node. |
| * |
| * @param mi - the MethodInfo describing the signature |
| * @param node - the expression node whose code will start the function. may |
| * be null when generating method bodies for purely synthetic functions, |
| * such as theIEventDispatcher methods that [Bindable] introduces. |
| * @param enclosing_scope |
| * @param insns_to_append - typically some massaging of the TOS and a return |
| * function |
| */ |
| public MethodInfo generateFunctionFromExpression(MethodInfo mi, IASNode node, |
| LexicalScope enclosing_scope, |
| InstructionList insns_to_append) |
| { |
| return generateMethodBody(mi, node, enclosing_scope, null, CmcEmitter.__expression_NT, insns_to_append); |
| } |
| |
| /** |
| * Helper methods used by databinding codegen to emit anonymous functions |
| * based on an expression node. |
| * |
| * @param mi - the MethodInfo describing the signature |
| * @param nodes - a list of expression nodes whose code will start the |
| * function. May have the following values: null when generating method |
| * bodies for purely synthetic functions, such as theIEventDispatcher |
| * methods that [Bindable] introduces. an IASNode for an expression that |
| * will be code-gen'd a List of IASNodes. This is a special case where we |
| * code-gen the sum of all the expressions |
| * @param enclosing_scope |
| * @param insns_to_append - typically some massaging of the TOS and a return |
| * function |
| */ |
| |
| public MethodInfo generateFunctionFromExpressions(MethodInfo mi, List<? extends IASNode> nodes, |
| LexicalScope enclosing_scope, |
| InstructionList insns_to_append) |
| { |
| return generateMethodBody(mi, nodes, enclosing_scope, null, CmcEmitter.__expression_NT, insns_to_append); |
| } |
| |
| /** |
| * General method body maker. see the public documentation, above, for more |
| * into |
| */ |
| MethodInfo generateMethodBody(MethodInfo mi, Object node, |
| LexicalScope enclosing_scope, |
| InstructionList a_priori_insns, |
| int goal_state, |
| InstructionList insns_to_append) |
| { |
| // Set up a lexical scope for this function. |
| LexicalScope function_scope = enclosing_scope.pushFrame(); |
| |
| IMethodVisitor mv = function_scope.getEmitter().visitMethod(mi); |
| mv.visit(); |
| |
| MethodBodyInfo mbi = new MethodBodyInfo(); |
| mbi.setMethodInfo(mi); |
| |
| IMethodBodyVisitor mbv = mv.visitBody(mbi); |
| mbv.visit(); |
| |
| function_scope.methodBodyVisitor = mbv; |
| function_scope.traitsVisitor = mbv.visitTraits(); |
| function_scope.setMethodInfo(mi); |
| |
| System.out.println(mi.getMethodName()); |
| if (mi.getMethodName().contains("loginInternal")) |
| { |
| System.out.println("got it"); |
| } |
| |
| InstructionList insns = null; |
| if (node == null) |
| { |
| // node may be null when generating method bodies for purely synthetic functions, such as the |
| // IEventDispatcher methods that [Bindable] introduces. |
| insns = new InstructionList(); |
| } |
| else if (node instanceof IASNode) |
| { |
| // If we are passed a single node, generate its instructions |
| insns = generateInstructions((IASNode)node, goal_state, function_scope, a_priori_insns); |
| } |
| else if (node instanceof List<?>) |
| { |
| List<?> nodes = (List<?>)node; |
| |
| // for a list of nodes, generate all their instructions and add the results together. |
| // typically we are doing this to concatenate strings |
| for (int nodeIndex = 0; nodeIndex < nodes.size(); ++nodeIndex) |
| { |
| IASNode n = (IASNode)nodes.get(nodeIndex); |
| if (nodeIndex == 0) |
| { |
| // First one in the list makes a new IL and puts |
| // instructions into it |
| insns = generateInstructions(n, goal_state, function_scope, a_priori_insns); |
| } |
| else |
| { |
| // successive children generate into the same IS, then add the results |
| insns.addAll(generateInstructions(n, goal_state, function_scope, a_priori_insns)); |
| insns.addInstruction(OP_add); |
| } |
| } |
| } |
| else |
| { |
| assert false; // Illegal type passed as node parameter |
| } |
| assert insns != null; |
| |
| // If caller passed in instructions to get after the BURM-generated stuff, |
| // add them to the instruction stream |
| if (insns_to_append != null) |
| { |
| insns.addAll(insns_to_append); |
| } |
| |
| mbv.visitInstructionList(insns); |
| |
| if (function_scope.needsActivation()) |
| { |
| mi.setFlags((byte)(mi.getFlags() | ABCConstants.NEED_ACTIVATION)); |
| } |
| |
| mbv.visitEnd(); |
| mv.visitEnd(); |
| |
| return mi; |
| } |
| |
| /** |
| * Helper method used by mxml databinding codegen to emit an anonymous |
| * function used by an mxml data binding destination function. Example: |
| * <p> |
| * If the expression node is a.b.c, this method will generate a funtion |
| * whose source would look something like this: |
| * |
| * <pre> |
| * function (arg:*):void { a.b.c = arg; } |
| * </pre> |
| * |
| * @param mi - the MethodInfo describing the signature |
| * @param setterExpression {@link IExpressionNode} that is the destination |
| * expression of a mxml data binding. |
| * @param enclosing_scope {@link LexicalScope} for the class initializer |
| * that encloses the function being generated. |
| */ |
| public void generateMXMLDataBindingSetterFunction (MethodInfo mi, IExpressionNode setterExpression, LexicalScope enclosing_scope) |
| { |
| System.out.println("unhandled call to generateMXMLDataBindingSetterFunction"); |
| /* AJH commented out for now |
| IMethodVisitor methodVisitor = enclosing_scope.getEmitter().visitMethod(mi); |
| methodVisitor.visit(); |
| MethodBodyInfo methodBodyInfo = new MethodBodyInfo(); |
| methodBodyInfo.setMethodInfo(mi); |
| IMethodBodyVisitor methodBodyVisitor = methodVisitor.visitBody(methodBodyInfo); |
| methodBodyVisitor.visit(); |
| |
| // Set up a lexical scope for this function. |
| LexicalScope function_scope = enclosing_scope.pushFrame(); |
| |
| function_scope.methodBodyVisitor = methodBodyVisitor; |
| function_scope.traitsVisitor = methodBodyVisitor.visitTraits(); |
| function_scope.setMethodInfo(mi); |
| |
| |
| InstructionList functionBody; |
| if (setterExpression instanceof InstructionListNode) |
| functionBody = ((InstructionListNode)setterExpression).getInstructions(); |
| else |
| functionBody = generateInstructions(setterExpression, CmcEmitter.__mxml_data_binding_setter_expression_NT, function_scope, null); |
| |
| functionBody.addInstruction(OP_returnvoid); |
| |
| methodBodyVisitor.visitInstructionList(functionBody); |
| methodBodyVisitor.visitEnd(); |
| methodVisitor.visitEnd(); |
| */ |
| } |
| |
| /** |
| * Helper method used by databinding codegen to emit an anonymous function |
| * based on a list of {@link IExpressionNode}'s. This method emits a |
| * function that contains code that evaluates each expression in the list |
| * and adds the expressions together with {@link ABCConstants#OP_add}. |
| * |
| * @param mi - the MethodInfo describing the signature |
| * @param nodes - a {@link List} of {@link IExpressionNode}'s to be |
| * codegen'd. |
| * @param enclosing_scope {@link LexicalScope} for the class initializer |
| * that encloses the function being generated. |
| */ |
| public void generateMXMLDataBindingGetterFunction (MethodInfo mi, List<IExpressionNode> nodes, |
| LexicalScope enclosing_scope) |
| { |
| System.out.println("unhandled call to generateMXMLDataBindingSetterFunction"); |
| /* AJH commented out for now |
| IMethodVisitor methodVisitor = enclosing_scope.getEmitter().visitMethod(mi); |
| methodVisitor.visit(); |
| MethodBodyInfo methodBodyInfo = new MethodBodyInfo(); |
| methodBodyInfo.setMethodInfo(mi); |
| IMethodBodyVisitor methodBodyVisitor = methodVisitor.visitBody(methodBodyInfo); |
| methodBodyVisitor.visit(); |
| |
| // Set up a lexical scope for this function. |
| LexicalScope function_scope = enclosing_scope.pushFrame(); |
| |
| function_scope.methodBodyVisitor = methodBodyVisitor; |
| function_scope.traitsVisitor = methodBodyVisitor.visitTraits(); |
| function_scope.setMethodInfo(mi); |
| |
| InstructionList functionBody = null; |
| // for a list of nodes, generate all their instructions and add the results together. |
| // typically we are doing this to concatenate strings |
| for (IExpressionNode expressionNode : nodes) |
| { |
| InstructionList instructionsForExpression = generateInstructions(expressionNode, CmcEmitter.__expression_NT, function_scope, null); |
| if (functionBody == null) |
| { |
| // First one in the list makes a new IL and puts |
| // instructions into it |
| functionBody = instructionsForExpression; |
| } |
| else |
| { |
| // successive children generate into the same IL, then add the results |
| functionBody.addAll(instructionsForExpression); |
| functionBody.addInstruction(OP_add); |
| } |
| } |
| |
| functionBody.addInstruction(OP_returnvalue); |
| |
| methodBodyVisitor.visitInstructionList(functionBody); |
| function_scope.traitsVisitor.visitEnd(); |
| methodBodyVisitor.visitEnd(); |
| methodVisitor.visitEnd(); |
| */ |
| } |
| |
| /** |
| * Creates a MethodInfo specifying the signature of a method declared by a |
| * FunctionNode. |
| * |
| * @param func - A FunctionNode representing a method declaration. |
| * @return The MethodInfo specifying the signature of the method. |
| */ |
| public static MethodInfo createMethodInfo(JSGeneratingReducer burm, JSEmitter emitter, LexicalScope scope, FunctionNode func) |
| { |
| MethodInfo mi = new MethodInfo(); |
| // FIXME: FunctionNode.getQualifiedName() has |
| // preconditions that need to be understood! |
| mi.setMethodName(func.getName()); |
| |
| FunctionDefinition funcDef = func.getDefinition(); |
| // Marshal the function's arguments. |
| ParameterDefinition[] args = funcDef.getParameters(); |
| List<String> param_names = new ArrayList<String>(); |
| |
| ICompilerProject project = scope.getProject(); |
| if (args.length > 0) |
| { |
| Vector<Name> method_args = new Vector<Name>(); |
| for (ParameterDefinition arg : args) |
| { |
| TypeDefinitionBase arg_type = arg.resolveType(project); |
| Name type_name = arg_type != null ? arg_type.getMName(project) : null; |
| |
| if (arg.isRest()) |
| { |
| mi.setFlags((byte)(mi.getFlags() | ABCConstants.NEED_REST)); |
| param_names.add(arg.getBaseName()); |
| } |
| else |
| { |
| method_args.add(type_name); |
| param_names.add(arg.getBaseName()); |
| } |
| } |
| mi.setParamTypes(method_args); |
| mi.setParamNames(param_names); |
| } |
| |
| // check for native modifier |
| if (func.getDefinition().isNative()) |
| { |
| mi.setFlags((byte)(mi.getFlags() | ABCConstants.NATIVE)); |
| } |
| |
| // The return type will be set by the BURM. |
| |
| // Falcon's IMethodVisitor only records a fraction of the FunctionDefinition. |
| // For that reason we are registering every MethodInfo with its corresponding FunctionDefinition at the JSEmitter. |
| emitter.visitFunctionDefinition(mi, funcDef); |
| |
| return mi; |
| } |
| |
| // called by JSInterfaceDirectiveProcessor |
| public MethodInfo createMethodInfo(LexicalScope scope, FunctionNode func) |
| { |
| return JSGenerator.createMethodInfo(m_burm, m_emitter, scope, func); |
| } |
| |
| /** |
| ** |
| * Creates a MethodInfo specifying the signature of a method |
| * declared by a FunctionNode, and adds in the information for any |
| * default argument values. |
| * |
| * @param func - A FunctionNode representing a method declaration. |
| * @return The MethodInfo specifying the signature of the method. |
| * |
| * Will generate a compiler problem is the default value is bad |
| */ |
| @Override |
| public MethodInfo createMethodInfoWithDefaultArgumentValues (LexicalScope scope, FunctionNode func) |
| { |
| return JSGenerator.createMethodInfo(m_burm, m_emitter, scope, func); |
| } |
| |
| /** |
| * Helper method to expose the constant folding code to clients outside of |
| * the burm, such as |
| * org.apache.flex.compiler.internal.as.definitions.ConstantDefinition. |
| * |
| * @param subtree the tree to generate a constant value for |
| * @param project the project to use to evaluate the tree |
| * @return the constant value for the subtree, or null if a constant value |
| * can't be determined |
| */ |
| public IConstantValue generateConstantValue(IASNode subtree, ICompilerProject project) |
| { |
| Object result = null; |
| |
| LexicalScope scope = new GlobalLexicalScope(project, null, GlobalLexicalScope.EMPTY_NAME_PREFIX, m_emitter); |
| |
| if (subtree != null) |
| { |
| try |
| { |
| result = reduceSubtree(subtree, scope, CmcJSEmitter.__constant_value_NT); |
| } |
| catch (Exception cant_reduce) |
| { |
| // Can't generate a constant value, just return null |
| } |
| } |
| |
| return new ConstantValue(result, null); |
| } |
| |
| /** |
| * Reduce an AST to its equivalent ABC structures. |
| * |
| * @param subtree - the root of the AST subtree. May be null, in which case |
| * this routine returns null. |
| * @param scope - the active LexicalScope. |
| * @param goal - the BURM's goal state. One of the CmcEmitter.__foo_NT |
| * constants. |
| * @return the result of reducing the subtree to the desired goal state, or |
| * null if the input subtree was null. |
| * @throws Exception from the BURM if the computation didn't succeed or was |
| * interrupted. |
| */ |
| public Object reduceSubtree(IASNode subtree, LexicalScope scope, int goal) |
| throws Exception |
| { |
| CmcJSEmitter burm = m_cmcJSEmitter; |
| burm.reducer = this.m_burm; |
| burm.reducer.setCurrentscope(scope); |
| |
| burm.burm(subtree, CmcEmitter.__constant_value_NT); |
| return burm.getResult(); |
| } |
| |
| /** |
| * Handle an error from a BURM: emit diagnostics and bump the error count. |
| * |
| * @param n - the subtree that was to be reduced. |
| * @param ex - the exception. |
| */ |
| @SuppressWarnings("nls") |
| private static void handleBurmError(CmcJSEmitter burm, IASNode n, Exception ex, LexicalScope scope) |
| { |
| if (ex instanceof CodegenInterruptedException) |
| { |
| // If the exception is an InterruptedException, do nothing, as not |
| // a real error. The incremental flow kicked in and interrupted |
| // the current work, so just throw away the current work and carry |
| // on our merry way. |
| // No problem should be reported in this case. |
| scope.getProblems().clear(); |
| return; |
| } |
| else if (!(ex instanceof BURMAbortException)) |
| { |
| scope.addProblem(new CodegenInternalProblem(n, ex)); |
| } |
| |
| java.io.PrintWriter dumper; |
| |
| String dump_dir = System.getenv("JBURG_DUMP_DIR"); |
| if (dump_dir != null) |
| { |
| try |
| { |
| String dump_file = dump_dir + "/failedBurm-" + Integer.toString(dumpCount++) + ".xml"; |
| dumper = new java.io.PrintWriter(new java.io.FileWriter(dump_file)); |
| dumper.println("<?xml version=\"1.0\"?>"); |
| dumper.println("<BurmDump date=\"" + new Date().toString() + "\">"); |
| burm.dump(dumper); |
| dumper.println("<AST>"); |
| dumper.println(new NodesToXMLStringFormatter(n).toString()); |
| dumper.println("</AST>"); |
| dumper.println("</BurmDump>"); |
| dumper.flush(); |
| dumper.close(); |
| } |
| catch (Exception e) |
| { |
| JSSharedData.instance.stderr("Unable to dump due to: " + e.toString()); |
| try |
| { |
| JSSharedData.instance.stderr(new NodesToXMLStringFormatter(n).toString()); |
| } |
| catch (Exception cantformat) |
| { |
| // Probably an error in the AST itself, diagnosed above. |
| } |
| } |
| } |
| } |
| |
| /** |
| * Number of diagnostic dumps emitted by this compiler; used to generate |
| * unique dump file names. |
| */ |
| static int dumpCount = 0; |
| |
| public String toString() |
| { |
| return "JSGenerator: " + m_compilationUnit.toString(); |
| } |
| |
| public void setBuildPhase(ICompilationUnit.Operation op) |
| { |
| m_buildPhase = op; |
| m_burm.setBuildPhase(op); |
| } |
| |
| public JSGeneratingReducer getReducer() |
| { |
| return m_burm; |
| } |
| |
| |
| /** |
| * Get an ICodeGeneratorFactory that will always return the same ABCGenerator instance |
| */ |
| public static ICodeGeneratorFactory getABCGeneratorFactory() |
| { |
| return new ICodeGeneratorFactory() |
| { |
| public ICodeGenerator get () |
| { |
| return new JSGenerator(); |
| } |
| }; |
| } |
| |
| /** |
| * Represents the result of {@link #generateConstantValue}(}. |
| * <p> |
| * In addition to producing the constant value itself, |
| * the constant reduction process can also produce compiler problems. |
| */ |
| public static final class ConstantValue implements IConstantValue |
| { |
| public ConstantValue(Object value, Collection<ICompilerProblem> problems) |
| { |
| this.value = value; |
| this.problems = problems; |
| } |
| |
| private final Object value; |
| private final Collection<ICompilerProblem> problems; |
| |
| @Override |
| public Object getValue() |
| { |
| return value; |
| } |
| |
| @Override |
| public Collection<ICompilerProblem> getProblems() |
| { |
| return problems; |
| } |
| } |
| } |
