| package org.apache.flex.compiler.internal.as.codegen; |
| |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_PrivateNs; |
| import static org.apache.flex.abc.ABCConstants.OP_applytype; |
| import static org.apache.flex.abc.ABCConstants.OP_callproperty; |
| import static org.apache.flex.abc.ABCConstants.OP_callpropvoid; |
| import static org.apache.flex.abc.ABCConstants.OP_construct; |
| import static org.apache.flex.abc.ABCConstants.OP_constructprop; |
| import static org.apache.flex.abc.ABCConstants.OP_dup; |
| import static org.apache.flex.abc.ABCConstants.OP_finddef; |
| import static org.apache.flex.abc.ABCConstants.OP_findpropstrict; |
| import static org.apache.flex.abc.ABCConstants.OP_getlex; |
| import static org.apache.flex.abc.ABCConstants.OP_getlocal0; |
| import static org.apache.flex.abc.ABCConstants.OP_getlocal3; |
| import static org.apache.flex.abc.ABCConstants.OP_getproperty; |
| import static org.apache.flex.abc.ABCConstants.OP_newarray; |
| import static org.apache.flex.abc.ABCConstants.OP_newobject; |
| import static org.apache.flex.abc.ABCConstants.OP_pushdouble; |
| import static org.apache.flex.abc.ABCConstants.OP_pushfalse; |
| import static org.apache.flex.abc.ABCConstants.OP_pushnull; |
| import static org.apache.flex.abc.ABCConstants.OP_pushstring; |
| import static org.apache.flex.abc.ABCConstants.OP_pushtrue; |
| import static org.apache.flex.abc.ABCConstants.OP_pushuint; |
| import static org.apache.flex.abc.ABCConstants.OP_setproperty; |
| import static org.apache.flex.abc.ABCConstants.TRAIT_Const; |
| import static org.apache.flex.abc.ABCConstants.TRAIT_Method; |
| import static org.apache.flex.abc.ABCConstants.TRAIT_Var; |
| import static org.apache.flex.compiler.mxml.IMXMLTypeConstants.ADD_EVENT_LISTENER_CALL_OPERANDS; |
| import static org.apache.flex.compiler.mxml.IMXMLTypeConstants.CREATE_XML_DOCUMENT_CALL_OPERANDS; |
| import static org.apache.flex.compiler.mxml.IMXMLTypeConstants.GET_INSTANCE_CALL_OPERANDS; |
| import static org.apache.flex.compiler.mxml.IMXMLTypeConstants.NAME_HANDLER_FUNCTION; |
| import static org.apache.flex.compiler.mxml.IMXMLTypeConstants.NAME_ID; |
| import static org.apache.flex.compiler.mxml.IMXMLTypeConstants.NAME_NAME; |
| import static org.apache.flex.compiler.mxml.IMXMLTypeConstants.NAME_OVERRIDES; |
| import static org.apache.flex.compiler.mxml.IMXMLTypeConstants.NAME_TARGET; |
| import static org.apache.flex.compiler.mxml.IMXMLTypeConstants.NAME_VALUE; |
| import static org.apache.flex.compiler.mxml.IMXMLTypeConstants.SET_STYLE_CALL_OPERANDS; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.flex.abc.ABCConstants; |
| import org.apache.flex.abc.instructionlist.InstructionList; |
| import org.apache.flex.abc.semantics.MethodInfo; |
| import org.apache.flex.abc.semantics.Name; |
| import org.apache.flex.abc.semantics.Namespace; |
| import org.apache.flex.abc.semantics.Nsset; |
| import org.apache.flex.abc.semantics.Trait; |
| import org.apache.flex.abc.visitors.IABCVisitor; |
| import org.apache.flex.abc.visitors.ITraitVisitor; |
| import org.apache.flex.abc.visitors.ITraitsVisitor; |
| import org.apache.flex.compiler.common.ASModifier; |
| import org.apache.flex.compiler.constants.IASLanguageConstants; |
| import org.apache.flex.compiler.constants.IASLanguageConstants.BuiltinType; |
| import org.apache.flex.compiler.css.ICSSDocument; |
| import org.apache.flex.compiler.definitions.IDefinition; |
| import org.apache.flex.compiler.definitions.ITypeDefinition; |
| import org.apache.flex.compiler.exceptions.CodegenInterruptedException; |
| import org.apache.flex.compiler.internal.as.codegen.ICodeGenerator.IConstantValue; |
| import org.apache.flex.compiler.internal.as.codegen.MXMLClassDirectiveProcessor.Context; |
| import org.apache.flex.compiler.internal.as.codegen.MXMLClassDirectiveProcessor.IL; |
| import org.apache.flex.compiler.internal.caches.CSSDocumentCache; |
| import org.apache.flex.compiler.internal.css.codegen.CSSCompilationSession; |
| import org.apache.flex.compiler.internal.css.codegen.CSSEmitter; |
| import org.apache.flex.compiler.internal.css.codegen.CSSReducer; |
| import org.apache.flex.compiler.internal.definitions.ClassDefinition; |
| import org.apache.flex.compiler.internal.definitions.DefinitionBase; |
| import org.apache.flex.compiler.internal.definitions.FunctionDefinition; |
| import org.apache.flex.compiler.internal.definitions.NamespaceDefinition; |
| import org.apache.flex.compiler.internal.definitions.TypeDefinitionBase; |
| import org.apache.flex.compiler.internal.projects.FlexProject; |
| import org.apache.flex.compiler.internal.resourcebundles.ResourceBundleUtils; |
| import org.apache.flex.compiler.internal.scopes.ASProjectScope; |
| import org.apache.flex.compiler.internal.scopes.ASScope; |
| import org.apache.flex.compiler.internal.semantics.SemanticUtils; |
| import org.apache.flex.compiler.internal.tree.as.FunctionNode; |
| import org.apache.flex.compiler.internal.tree.as.NodeBase; |
| import org.apache.flex.compiler.internal.tree.as.VariableNode; |
| import org.apache.flex.compiler.mxml.IMXMLLanguageConstants; |
| import org.apache.flex.compiler.mxml.IMXMLTypeConstants; |
| import org.apache.flex.compiler.problems.CSSCodeGenProblem; |
| import org.apache.flex.compiler.problems.ICompilerProblem; |
| import org.apache.flex.compiler.problems.MXMLNotImplementedProblem; |
| import org.apache.flex.compiler.problems.MXMLOuterDocumentAlreadyDeclaredProblem; |
| import org.apache.flex.compiler.projects.ICompilerProject; |
| import org.apache.flex.compiler.projects.IFlexProject; |
| import org.apache.flex.compiler.tree.ASTNodeID; |
| import org.apache.flex.compiler.tree.as.IASNode; |
| import org.apache.flex.compiler.tree.as.IExpressionNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLArrayNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLBooleanNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLClassDefinitionNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLClassNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLClassReferenceNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLComponentNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLConcatenatedDataBindingNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLDeferredInstanceNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLDesignLayerNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLEffectSpecifierNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLEmbedNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLEventSpecifierNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLFactoryNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLFunctionNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLInstanceNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLIntNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLNumberNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLObjectNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLPropertySpecifierNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLRegExpNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLRemoteObjectMethodNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLResourceNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLSingleDataBindingNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLStateNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLStringNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLStyleNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLStyleSpecifierNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLUintNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLVectorNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLWebServiceOperationNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLXMLListNode; |
| import org.apache.flex.compiler.tree.mxml.IMXMLXMLNode; |
| import org.apache.flex.compiler.units.ICompilationUnit; |
| |
| import com.google.common.base.Strings; |
| |
| /** |
| * {@link MXMLClassDirectiveProcessor} is a subclass of |
| * {@code ClassDirectiveProcessor} that generates an ABC class |
| * from an {@link IMXMLClassDefinitionNode} and its contents. |
| * |
| * Here are some register usage conventions for Code Generation: |
| * local3: during parts of the constructor, local3 is used for a |
| * lookup array of DeferredInstanceFromFunction. |
| * local1 and 2: Used during the constructor as temporaries |
| * for some data-binding init. |
| */ |
| public class JSMXMLClassDirectiveProcessor extends MXMLClassDirectiveProcessor |
| { |
| /** |
| * Initialize the {@link MXMLClassDirectiveProcessor} and its |
| * associated AET data structures. |
| * @param d - the MXML document's AST. |
| * @param enclosingScope - the immediately enclosing lexical scope. |
| * @param emitter - the active ABC emitter. |
| */ |
| JSMXMLClassDirectiveProcessor(IMXMLClassDefinitionNode classDefinitionNode, |
| LexicalScope enclosingScope, IABCVisitor emitter) |
| { |
| super(classDefinitionNode, |
| enclosingScope, emitter); |
| |
| JSMXMLEmitter jsMXMLEmitter = (JSMXMLEmitter)emitter; |
| jsMXMLEmitter.register(this); |
| } |
| |
| /** |
| * A Map mapping an event node to the Name of the event handler |
| * method (>0, >1, etc.) associated with that node. |
| * <p> |
| * The handler method may or may not exist at the time |
| * that the handler name is assigned to the event node. |
| * For example, when a State tag appears before |
| * an instance tag with a state-dependent event, |
| * the name will get assigned and the code generated later. |
| * <p> |
| * This map is managed ONLY by getEventHandlerName(). |
| */ |
| private final Map<IMXMLEventSpecifierNode, Name> eventHandlerMap = |
| new HashMap<IMXMLEventSpecifierNode, Name>(); |
| |
| /** |
| * An incrementing counter used to create the names of the |
| * auto-generated event handler methods. |
| */ |
| private int eventHandlerCounter = 0; |
| |
| /** |
| * Autogenerated event handler methods are named $EH0, $EH1, etc. |
| * Using short names, and using the same names in each MXML document, |
| * decreases SWF size. |
| * Using a character that is not legal in ActionScript identifiers |
| * means that even if the event handler must be public |
| * (because it is referenced in a descriptor) |
| * the name will not collide with the name of a developer-written |
| * method and cannot be accessed from developer code. |
| */ |
| private static final String EVENT_HANDLER_NAME_BASE = "$EH"; |
| |
| private String NEWLINE = "\n"; |
| public ArrayList<Name> variableTraits; |
| private ArrayList<String> instanceData = new ArrayList<String>(); |
| public ArrayList<String> fragments = new ArrayList<String>(); |
| private FragmentList properties = new FragmentList(); |
| private FragmentList styles = new FragmentList(); |
| private FragmentList events = new FragmentList(); |
| private FragmentList children = new FragmentList(); |
| private FragmentList model = new FragmentList(); |
| private FragmentList beads = new FragmentList(); |
| private FragmentList currentList; |
| private boolean inContentFactory; |
| private String className; |
| |
| @Override |
| public void processMainClassDefinitionNode(IMXMLClassDefinitionNode node) |
| { |
| // Leave a reference to the class on the stack. |
| ClassDefinition classDefinition = |
| (ClassDefinition)((IMXMLClassDefinitionNode)node).getClassDefinition(); |
| className = classDefinition.getQualifiedName(); |
| currentList = properties; |
| super.processMainClassDefinitionNode(node); |
| } |
| |
| @Override |
| public void addVariableTrait(Name varName, Name varType) |
| { |
| if (variableTraits == null) |
| variableTraits = new ArrayList<Name>(); |
| variableTraits.add(varName); |
| variableTraits.add(varType); |
| } |
| |
| @Override |
| public void addBindableVariableTrait(Name varName, Name varType, IDefinition def) |
| { |
| String var = /*"_" + */varName.getBaseName(); |
| Name backingVar = new Name(new Namespace(JSSharedData.CONSTANT_PrivateNs), var); |
| variableTraits.add(backingVar); |
| variableTraits.add(varType); |
| |
| fragments.add("/**" |
| + NEWLINE + " * @this {" + className + "}" |
| + NEWLINE + " * @return {" + varType.getBaseName() + "}" |
| + NEWLINE + " */" |
| + NEWLINE + className + ".prototype.get_" + varName.getBaseName() + " = function()" |
| + NEWLINE + "{" |
| + NEWLINE + " return this." + var + ";" |
| + NEWLINE + "};"); |
| |
| fragments.add("/**" |
| + NEWLINE + " * @this {" + className + "}" |
| + NEWLINE + " * @param {" + varType.getBaseName() + "} value" |
| + NEWLINE + " */" |
| + NEWLINE + className + ".prototype.set_" + varName.getBaseName() + " = function(value)" |
| + NEWLINE + "{" |
| + NEWLINE + " if (value != this." + var + ")" |
| + NEWLINE + " this." + var + " = value;" |
| + NEWLINE + "};"); |
| } |
| |
| @Override |
| protected void processMXMLClassDefinition(IMXMLClassDefinitionNode node, Context context) |
| { |
| // Create the <Component> or <Definition> class. |
| MXMLClassDirectiveProcessor dp = new MXMLClassDirectiveProcessor(node, globalScope, emitter); |
| dp.processMainClassDefinitionNode(node); |
| dp.finishClassDefinition(); |
| } |
| |
| @Override |
| void setDocument(IMXMLClassReferenceNode node, boolean conditionally, Context context) |
| { |
| if (node.isVisualElementContainer() || node.isContainer()) |
| { |
| currentList.add("document"); |
| currentList.add(true); |
| currentList.addExplicit("this"); |
| } |
| } |
| |
| /** |
| * Adds the current set of childEvents, childStyles, and childProperties to currentList; |
| * @param context |
| * @param addCounters |
| * @param skipContentFactory |
| * @return |
| */ |
| @Override |
| int setSpecifiers(Context context, Boolean addCounters, Boolean skipContentFactory) |
| { |
| if (skipContentFactory) |
| return 0; |
| |
| int numProperties = properties.size() / 3; |
| if (context.hasBeads) |
| numProperties++; |
| if (context.hasModel) |
| numProperties++; |
| currentList.add(numProperties); |
| if (context.hasModel) |
| { |
| currentList.add("model"); |
| currentList.addObjectTypeMarker(); |
| currentList.addExplicit("[" + model.toString() + "]"); |
| } |
| currentList.addAll(properties); |
| if (context.hasBeads) |
| { |
| currentList.add("beads"); |
| currentList.addExplicit(beads.toString()); |
| } |
| currentList.add(styles.size() / 3); |
| currentList.addAll(styles); |
| currentList.add(events.size() / 2); |
| currentList.addAll(events); |
| if (children.size() == 0) |
| currentList.addNull(); |
| else |
| currentList.addExplicit("[" + children.toString() + "]"); |
| return (properties.size() + styles.size() + events.size()) / 3; |
| } |
| |
| @Override |
| void overrideMXMLDescriptorGetter(IMXMLClassDefinitionNode node, Context context) |
| { |
| // Leave a reference to the class on the stack. |
| ClassDefinition classDefinition = |
| (ClassDefinition)((IMXMLClassDefinitionNode)node).getClassDefinition(); |
| String className = classDefinition.getQualifiedName(); |
| |
| fragments.add("/**" |
| + NEWLINE + " * @override" |
| + NEWLINE + " * @this {" + className + "}" |
| + NEWLINE + " * @return {Array} the Array of UI element descriptors." |
| + NEWLINE + " */" |
| + NEWLINE + className + ".prototype.get_MXMLDescriptor = function()" |
| + NEWLINE + "{" |
| + NEWLINE + " if (this.mxmldd == undefined)" |
| + NEWLINE + " {" |
| + NEWLINE + " /** @type {Array} */" |
| + NEWLINE + " var arr = goog.base(this, 'get_MXMLDescriptor');" |
| + NEWLINE + " /** @type {Array} */" |
| + NEWLINE + " var data = " + addInstanceData() |
| + NEWLINE + " if (arr)" |
| + NEWLINE + " this.mxmldd = arr.concat(data);" |
| + NEWLINE + " else" |
| + NEWLINE + " this.mxmldd = data;" |
| + NEWLINE + " }" |
| + NEWLINE + " return this.mxmldd;" |
| + NEWLINE + "};"); |
| |
| } |
| |
| private String addInstanceData() |
| { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("[" + NEWLINE); |
| int n = children.size(); |
| for (int i = 0; i < n; i++) |
| { |
| String s = children.get(i); |
| sb.append(s); |
| if (i < n - 1) |
| sb.append("," + NEWLINE); |
| else |
| sb.append(NEWLINE); |
| } |
| sb.append("];" + NEWLINE); |
| return sb.toString(); |
| } |
| |
| void overrideMXMLPropertiesGetter(IMXMLClassDefinitionNode node, Context context, int numElements) |
| { |
| // Leave a reference to the class on the stack. |
| ClassDefinition classDefinition = |
| (ClassDefinition)((IMXMLClassDefinitionNode)node).getClassDefinition(); |
| String className = classDefinition.getQualifiedName(); |
| |
| fragments.add("/**" |
| + NEWLINE + " * @override" |
| + NEWLINE + " * @this {" + className + "}" |
| + NEWLINE + " * @return {Array} the Array of UI element descriptors." |
| + NEWLINE + " */" |
| + NEWLINE + className + ".prototype.get_MXMLProperties = function()" |
| + NEWLINE + "{" |
| + NEWLINE + " if (this.mxmldp == undefined)" |
| + NEWLINE + " {" |
| + NEWLINE + " /** @type {Array} */" |
| + NEWLINE + " var arr = goog.base(this, 'get_MXMLProperties');" |
| + NEWLINE + " /** @type {Array} */" |
| + NEWLINE + " var data = " + addPropertiesData(context) |
| + NEWLINE + " if (arr)" |
| + NEWLINE + " this.mxmldp = arr.concat(data);" |
| + NEWLINE + " else" |
| + NEWLINE + " this.mxmldp = data;" |
| + NEWLINE + " }" |
| + NEWLINE + " return this.mxmldp;" |
| + NEWLINE + "};"); |
| |
| } |
| |
| private String addPropertiesData(Context context) |
| { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("[" + NEWLINE); |
| int n = properties.size(); |
| int numProperties = n / 3; |
| if (context.hasModel) |
| numProperties++; |
| if (context.hasBeads) |
| numProperties++; |
| sb.append(new Integer(numProperties).toString() + ',' + NEWLINE); |
| if (context.hasModel) |
| { |
| sb.append("'model'"); |
| sb.append("," + NEWLINE); |
| sb.append(model.toString()); |
| sb.append("," + NEWLINE); |
| } |
| for (int i = 0; i < n; i++) |
| { |
| String s = properties.get(i); |
| sb.append(s); |
| sb.append("," + NEWLINE); |
| } |
| if (context.hasBeads) |
| { |
| sb.append("'beads'"); |
| sb.append("," + NEWLINE); |
| sb.append(beads.toString()); |
| sb.append("," + NEWLINE); |
| } |
| n = styles.size(); |
| sb.append(new Integer(n / 3).toString() + ',' + NEWLINE); |
| for (int i = 0; i < n; i++) |
| { |
| String s = styles.get(i); |
| sb.append(s); |
| sb.append("," + NEWLINE); |
| } |
| n = events.size(); |
| if (n == 0) |
| sb.append("0" + NEWLINE); |
| else |
| sb.append(new Integer(n / 2).toString() + ',' + NEWLINE); |
| for (int i = 0; i < n; i++) |
| { |
| String s = events.get(i); |
| sb.append(s); |
| if (i < n - 1) |
| sb.append("," + NEWLINE); |
| else |
| sb.append(NEWLINE); |
| } |
| sb.append("];" + NEWLINE); |
| return sb.toString(); |
| } |
| |
| @Override |
| void processMXMLBoolean(IMXMLBooleanNode booleanNode, Context context) |
| { |
| if (booleanNode.getParent().getNodeID() == ASTNodeID.MXMLPropertySpecifierID) |
| currentList.addSimpleTypeMarker(); // simple type |
| |
| boolean value = isDataBound(booleanNode) ? false : booleanNode.getValue(); |
| currentList.add(value); |
| traverse(booleanNode, context); |
| } |
| |
| @Override |
| void processMXMLInt(IMXMLIntNode intNode, Context context) |
| { |
| if (intNode.getParent().getNodeID() == ASTNodeID.MXMLPropertySpecifierID) |
| currentList.addSimpleTypeMarker(); // simple type |
| |
| int value = isDataBound(intNode) ? 0 : intNode.getValue(); |
| currentList.add(value); |
| traverse(intNode, context); |
| } |
| |
| @Override |
| void processMXMLUint(IMXMLUintNode uintNode, Context context) |
| { |
| if (uintNode.getParent().getNodeID() == ASTNodeID.MXMLPropertySpecifierID) |
| currentList.addSimpleTypeMarker(); // simple type |
| |
| long value = isDataBound(uintNode) ? 0 : uintNode.getValue(); |
| currentList.add(value); |
| traverse(uintNode, context); |
| } |
| |
| @Override |
| void processMXMLNumber(IMXMLNumberNode numberNode, Context context) |
| { |
| if (numberNode.getParent().getNodeID() == ASTNodeID.MXMLPropertySpecifierID) |
| currentList.addSimpleTypeMarker(); // simple type |
| |
| double value = isDataBound(numberNode) ? Double.NaN : numberNode.getValue(); |
| currentList.add(value); |
| traverse(numberNode, context); |
| } |
| |
| @Override |
| void processMXMLString(IMXMLStringNode stringNode, Context context) |
| { |
| if (stringNode.getParent().getNodeID() == ASTNodeID.MXMLPropertySpecifierID) |
| currentList.addSimpleTypeMarker(); // simple type |
| |
| String value = isDataBound(stringNode) ? null : stringNode.getValue(); |
| if (value != null) |
| currentList.add(value); |
| else |
| currentList.addNull(); |
| |
| traverse(stringNode, context); |
| } |
| |
| @Override |
| void processMXMLClass(IMXMLClassNode classNode, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(classNode, "MXML Class"); |
| getProblems().add(problem); |
| /* |
| // Don't call skipCodegen() because a null Class is represented |
| // by the expression node being null. |
| if (isDataBindingNode(classNode)) |
| return; |
| |
| IExpressionNode expressionNode = (IExpressionNode)classNode.getExpressionNode(); |
| if (expressionNode != null) |
| { |
| InstructionList init_expression = classScope.getGenerator().generateInstructions( |
| expressionNode, CmcEmitter.__expression_NT, this.classScope); |
| context.addAll(init_expression); |
| } |
| else |
| { |
| context.addInstruction(OP_pushnull); |
| } |
| */ |
| } |
| |
| /** |
| * Generates an instruction in the current context |
| * to push the value of an {@code IMXMLFunctionNode}. |
| * |
| * Will also generate the function, if the FunctionNode specifies a function expression. |
| * |
| * If no expression is provided in the function node, this will push null |
| */ |
| void processMXMLFunction(IMXMLFunctionNode functionNode, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(functionNode, "MXML Function"); |
| getProblems().add(problem); |
| /* |
| // Don't call skipCodegen() because a null Function is represented |
| // by the expression node being null. |
| if (isDataBindingNode(functionNode)) |
| return; |
| |
| IExpressionNode expressionNode = (IExpressionNode)functionNode.getExpressionNode(); |
| if (expressionNode != null) |
| { |
| InstructionList init_expression = classScope.getGenerator().generateInstructions( |
| expressionNode, CmcEmitter.__expression_NT, this.classScope); |
| context.addAll(init_expression); |
| } |
| else |
| { |
| context.addInstruction(OP_pushnull); |
| } |
| */ |
| } |
| |
| @Override |
| void processMXMLRegExp(IMXMLRegExpNode regexpNode, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(regexpNode, "MXML RegExp"); |
| getProblems().add(problem); |
| /* |
| // Don't call skipCodegen() because a parameterless RegExp is represented |
| // by the expression node being null. |
| if (isDataBindingNode(regexpNode)) |
| return; |
| |
| IExpressionNode expressionNode = (IExpressionNode)regexpNode.getExpressionNode(); |
| if (expressionNode != null ) |
| { |
| InstructionList init_expression = classScope.getGenerator().generateInstructions( |
| expressionNode, CmcEmitter.__expression_NT, this.classScope); |
| context.addAll(init_expression); |
| } |
| else |
| { |
| context.addInstruction(OP_findpropstrict, ABCGeneratingReducer.regexType); |
| context.addInstruction(OP_constructprop, new Object[] {ABCGeneratingReducer.regexType, 0}); |
| } |
| */ |
| } |
| |
| @Override |
| void processMXMLDesignLayer(IMXMLDesignLayerNode node, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(node, "MXML DesignLayer"); |
| getProblems().add(problem); |
| } |
| |
| @Override |
| void processMXMLWebServiceOperation(IMXMLWebServiceOperationNode node, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(node, "MXML WebServices"); |
| getProblems().add(problem); |
| } |
| |
| @Override |
| void processMXMLRemoteObjectMethod(IMXMLRemoteObjectMethodNode node, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(node, "MXML Remote Object"); |
| getProblems().add(problem); |
| } |
| |
| @Override |
| void processMXMLObject(IMXMLObjectNode objectNode, Context context) |
| { |
| FragmentList savedCurrentList = currentList; |
| currentList = new FragmentList(); |
| |
| traverse(objectNode, context); |
| |
| StringBuilder sb = new StringBuilder(); |
| sb.append("{"); |
| int n = currentList.size(); |
| for (int i = 0; i < n; i++) |
| { |
| String s = currentList.get(i++); |
| sb.append(s + ":"); |
| sb.append(currentList.get(i)); |
| if (i < n - 1) |
| sb.append(","); |
| } |
| sb.append("}"); |
| currentList = savedCurrentList; |
| currentList.addExplicit(sb.toString()); |
| } |
| |
| @Override |
| void processMXMLArray(IMXMLArrayNode arrayNode, Context context) |
| { |
| boolean savedMakingArrayValues = context.makingArrayValues; |
| |
| if (!inContentFactory) |
| { |
| if (context.parentContext.isStateDescriptor) |
| currentList.addArrayTypeMarker(); // array of descriptors |
| else |
| { |
| boolean isSimple = true; |
| |
| for (int i = 0; i < arrayNode.getChildCount(); i++) |
| { |
| final IASNode child = arrayNode.getChild(i); |
| ASTNodeID nodeID = child.getNodeID(); |
| if (nodeID == ASTNodeID.MXMLArrayID || nodeID == ASTNodeID.MXMLInstanceID) |
| { |
| isSimple = false; |
| break; |
| } |
| } |
| context.makingArrayValues = true; |
| if (isSimple) |
| currentList.addSimpleTypeMarker(); // arrays are simple values |
| else |
| currentList.addArrayTypeMarker(); |
| } |
| } |
| |
| FragmentList savedCurrentList = currentList; |
| currentList = new FragmentList(); |
| |
| traverse(arrayNode, context); |
| |
| FragmentList childList = currentList; |
| currentList = savedCurrentList; |
| |
| // TODO: can we do better? |
| // Now that stack will have the array children on it. |
| // But we may not have created one for every child of arrayNode. |
| // It would be best if we could remember how many we created, but |
| // we can't easily do that. So we use our "knowledge" that children |
| // are always created unless they are state dependent instances. |
| int nMax = arrayNode.getChildCount(); |
| int numStateDependentChildren=0; |
| for (int i=0; i<nMax; ++i) |
| { |
| IASNode ch = arrayNode.getChild(i); |
| if (isStateDependentInstance(ch)) |
| { |
| ++numStateDependentChildren; |
| } |
| } |
| |
| if (inContentFactory) |
| { |
| // pass the number of things we found up to the parent context. In spark controls |
| // the array of children is buried by a layer or two |
| currentList.addAll(childList); |
| } |
| else if (context.parentContext.isStateDescriptor) |
| { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("["); |
| sb.append(childList.toString()); |
| sb.append("]"); |
| currentList.addExplicit(sb.toString()); |
| } |
| else if (context.makingArrayValues) |
| { |
| currentList.addAll(childList); |
| } |
| context.makingArrayValues = savedMakingArrayValues; |
| } |
| |
| @Override |
| void processMXMLVector(IMXMLVectorNode vectorNode, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(vectorNode, "MXML Vector"); |
| getProblems().add(problem); |
| } |
| |
| void processMXMLInstance(IMXMLInstanceNode instanceNode, Context context) |
| { |
| FragmentList savedList = currentList; |
| FragmentList savedProperties = properties; |
| FragmentList savedStyles = styles; |
| FragmentList savedEvents = events; |
| FragmentList savedChildren = children; |
| FragmentList savedBeads = beads; |
| FragmentList savedModel = model; |
| boolean savedHasBeads = context.hasBeads; |
| boolean savedHasModel = context.hasModel; |
| |
| properties = new FragmentList(); |
| styles = new FragmentList(); |
| events = new FragmentList(); |
| children = new FragmentList(); |
| beads = new FragmentList(); |
| model = new FragmentList(); |
| context.hasBeads = false; |
| context.hasModel = false; |
| |
| if (!context.isStateDescriptor && !inContentFactory && !context.parentContext.makingArrayValues) |
| currentList.addObjectTypeMarker(); // complex type |
| |
| traverse(instanceNode, context); |
| |
| int numElements = 0; |
| |
| currentList = properties; |
| |
| setDocument(instanceNode, false, context); |
| |
| // Sets the id property if the instance |
| // implements IDeferredInstantiationUIComponent. |
| String id = instanceNode.getID(); |
| if (id != null) |
| { |
| currentList.add("id"); |
| currentList.addSimpleTypeMarker(); |
| currentList.add(id); |
| } |
| else |
| { |
| id = instanceNode.getEffectiveID(); |
| if (id != null) |
| { |
| currentList.add("_id"); |
| currentList.addSimpleTypeMarker(); |
| currentList.add(id); |
| } |
| } |
| // bail out now. Other properties will be added in processMXMLState |
| if (context.isStateDescriptor) |
| return; |
| |
| |
| if (!inContentFactory) |
| currentList = new FragmentList(); |
| else |
| currentList = savedList; |
| |
| currentList.add(context.instanceClassName); |
| numElements += setSpecifiers(context, true, false); |
| |
| if (!inContentFactory) |
| { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("["); |
| sb.append(currentList.toString()); |
| sb.append("]"); |
| currentList = savedList; |
| currentList.addExplicit(sb.toString()); |
| } |
| |
| currentList = savedList; |
| properties = savedProperties; |
| styles = savedStyles; |
| events = savedEvents; |
| children = savedChildren; |
| beads = savedBeads; |
| model = savedModel; |
| context.hasBeads = savedHasBeads; |
| context.hasModel = savedHasModel; |
| } |
| |
| @Override |
| void processMXMLFactory(IMXMLFactoryNode factoryNode, Context context) |
| { |
| // Get the Name for the mx.core.ClassFactory class. |
| ICompilerProject project = getProject(); |
| ClassDefinition classReference = (ClassDefinition)factoryNode.getClassReference(project); |
| Name factoryClassName = classReference.getMName(project); |
| |
| // Push this class. |
| currentList.add(factoryClassName); |
| |
| // Push the class to be used as the generator, |
| // by traversing the child MXMLClassNode. |
| traverse(factoryNode, context); |
| |
| // Call new ClassFactory(generator), leaving the new instance on the stack. |
| currentList.addExplicit("new " + factoryClassName.toString()); |
| } |
| |
| @Override |
| void processMXMLDeferredInstance(IMXMLDeferredInstanceNode deferredInstanceNode, Context context) |
| { |
| // Push the class or function to be used as the generator, |
| // by traversing the child MXMLClassNode or MXMLInstanceNode. |
| traverse(deferredInstanceNode, context); |
| } |
| |
| @Override |
| void processMXMLPropertySpecifier(IMXMLPropertySpecifierNode propertyNode, Context context) |
| { |
| // State-dependent nodes are handled by processMXMLState(). |
| if (isStateDependent(propertyNode)) |
| return; |
| |
| String propertyName = propertyNode.getName(); |
| |
| if (propertyName.equals("mxmlContentFactory") || propertyName.equals("mxmlContent")) |
| { |
| FragmentList savedList = currentList; |
| currentList = children; |
| inContentFactory = true; |
| |
| traverse(propertyNode, context); |
| |
| inContentFactory = false; |
| currentList = savedList; |
| } |
| else if (propertyName.equals("states")) |
| { |
| context.isStateDescriptor = true; |
| |
| FragmentList savedList = currentList; |
| currentList = properties; |
| |
| currentList.add(propertyName); |
| |
| traverse(propertyNode, context); |
| |
| currentList = savedList; |
| } |
| else if (propertyName.equals("model")) |
| { |
| context.hasModel = true; |
| |
| FragmentList savedList = currentList; |
| currentList = model; |
| |
| traverse(propertyNode, context); |
| |
| currentList = savedList; |
| } |
| else if (propertyName.equals("beads")) |
| { |
| context.hasBeads = true; |
| |
| FragmentList savedList = currentList; |
| currentList = beads; |
| boolean savedInContentFactory = inContentFactory; |
| inContentFactory = false; |
| |
| traverse(propertyNode, context); |
| |
| inContentFactory = savedInContentFactory; |
| currentList = savedList; |
| } |
| else |
| { |
| FragmentList savedList = currentList; |
| currentList = properties; |
| |
| currentList.add(propertyName); |
| |
| traverse(propertyNode, context); |
| |
| currentList = savedList; |
| } |
| } |
| |
| @Override |
| void processMXMLStyleSpecifier(IMXMLStyleSpecifierNode styleNode, Context context) |
| { |
| // State-dependent nodes are handled by processMXMLState(). |
| if (isStateDependent(styleNode)) |
| return; |
| |
| // Data bound styles don't need this processing either |
| IMXMLInstanceNode value = styleNode.getInstanceNode(); |
| if (isDataBindingNode(value)) |
| { |
| return; |
| } |
| |
| // Style specifiers on the class definition node |
| // generate code in the moduleFactory setter. |
| if (styleNode.getParent() instanceof IMXMLClassDefinitionNode) |
| { |
| FragmentList savedList = currentList; |
| currentList = styles; |
| |
| // Push the second argument: the value of the style. |
| // Do this by codegen'ing sole child, which is an IMXMLInstanceNode. |
| traverse(styleNode, context); |
| |
| currentList = savedList; |
| |
| } |
| |
| else |
| { |
| FragmentList savedList = currentList; |
| currentList = styles; |
| |
| String styleName = styleNode.getName(); |
| |
| // Push the first argument: the name of the style. |
| currentList.add(styleName); |
| |
| // Push the second argument: the value of the style. |
| // Do this by codegen'ing sole child, which is an IMXMLInstanceNode. |
| traverse(styleNode, context); |
| |
| currentList = savedList; |
| } |
| } |
| |
| @Override |
| void processMXMLEffectSpecifier(IMXMLEffectSpecifierNode effectNode, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(effectNode, "MXML Effect"); |
| getProblems().add(problem); |
| } |
| |
| @Override |
| void processMXMLEventSpecifier(IMXMLEventSpecifierNode eventNode, Context context) |
| { |
| // Event nodes (including state-dependent ones) |
| // generate a new event handler method. |
| // Create a MethodInfo and a method trait for the handler. |
| Name name = getEventHandlerName(eventNode); |
| MethodInfo methodInfo = createEventHandlerMethodInfo( |
| getProject(), eventNode, name.getBaseName()); |
| ITraitVisitor traitVisitor = |
| itraits.visitMethodTrait(TRAIT_Method, name, 0, methodInfo); |
| |
| // Use ABCGenerator to codegen the handler body from the |
| // ActionScript nodes that are the children of the event node. |
| classScope.getGenerator().generateMethodBodyForFunction( |
| methodInfo, eventNode, classScope, null); |
| |
| // Otherwise, state-dependent nodes are handled by processMXMLState(). |
| if (isStateDependent(eventNode)) |
| return; |
| |
| String eventName = eventNode.getName(); |
| Name eventHandler = getEventHandlerName(eventNode); |
| |
| FragmentList savedList = currentList; |
| currentList = events; |
| |
| currentList.add(eventName); |
| |
| currentList.addExplicit("this." + eventHandler.getBaseName()); |
| |
| currentList = savedList; |
| } |
| |
| @Override |
| void processMXMLResource(IMXMLResourceNode node, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(node, "MXML Resources"); |
| getProblems().add(problem); |
| } |
| |
| @Override |
| void processMXMLState(IMXMLStateNode stateNode, Context context) |
| { |
| int numElements = 1; |
| |
| context.isStateDescriptor = true; |
| |
| // First process the State node as an instance node, |
| // so that properties (name, stateGroups, basedOn) get set |
| // and event handlers (enterState, etc.) get set. |
| processMXMLInstance(stateNode, context); |
| |
| // Init the name property of the state (it's not a normal property specifier nodes |
| // TODO: should we make this a property node? |
| String name = stateNode.getStateName(); |
| if (name != null) |
| { |
| currentList.add("name"); |
| currentList.addSimpleTypeMarker(); |
| currentList.add(name); |
| } |
| |
| // In MXML 2009 and later, a state's 'overrides' property is implicitly |
| // determined by the nodes that are dependent on this state. |
| // We use these nodes to autogenerate runtime IOverride objects |
| // and set them as the value of the 'overrides' property. |
| IMXMLClassDefinitionNode classDefinitionNode = stateNode.getClassDefinitionNode(); |
| List<IMXMLNode> nodes = classDefinitionNode.getNodesDependentOnState(stateNode.getStateName()); |
| if (nodes != null) |
| { |
| currentList.add("overrides"); |
| currentList.addArrayTypeMarker(); // complex array |
| |
| // First step: process all instance overrides before any other overrides. |
| // why: because a) ensure instances exists before trying to apply property overrides |
| // b) because the old compiler did |
| // Do it in reverse order |
| // a) because the way old compiler generated destination and relativeTo |
| // properties relies on doing it backwards. |
| // |
| // Each one will generate code to push an IOverride instance. |
| for (int i=nodes.size()-1; i>=0; --i) |
| { |
| IMXMLNode node = nodes.get(i); |
| if (node.getNodeID() == ASTNodeID.MXMLInstanceID) |
| { |
| processInstanceOverride((IMXMLInstanceNode)node, context); |
| } |
| } |
| // Next process the non-instance overrides dependent on this state. |
| // Each one will generate code to push an IOverride instance. |
| for (IMXMLNode node : nodes) |
| { |
| switch (node.getNodeID()) |
| { |
| case MXMLPropertySpecifierID: |
| { |
| processPropertyOverride((IMXMLPropertySpecifierNode)node, context); |
| break; |
| } |
| case MXMLStyleSpecifierID: |
| { |
| processStyleOverride((IMXMLStyleSpecifierNode)node, context); |
| break; |
| } |
| case MXMLEventSpecifierID: |
| { |
| processEventOverride((IMXMLEventSpecifierNode)node, context); |
| break; |
| } |
| } |
| } |
| |
| numElements += setSpecifiers(context, true, false); |
| } |
| } |
| |
| @Override |
| void processPropertyOrStyleOverride(Name overrideName, IMXMLPropertySpecifierNode propertyOrStyleNode, Context context) |
| { |
| IASNode parentNode = propertyOrStyleNode.getParent(); |
| String id = parentNode instanceof IMXMLInstanceNode ? |
| ((IMXMLInstanceNode)parentNode).getEffectiveID() : |
| ""; |
| |
| String name = propertyOrStyleNode.getName(); |
| |
| IMXMLInstanceNode propertyOrStyleValueNode = propertyOrStyleNode.getInstanceNode(); |
| |
| // Construct the SetProperty or SetStyle object. |
| currentList.add(overrideName); |
| |
| currentList.add(3); |
| // Set its 'target' property to the id of the object |
| // whose property or style this override will set. |
| currentList.add("target"); |
| currentList.addSimpleTypeMarker(); |
| currentList.add(id); |
| |
| // Set its 'name' property to the name of the property or style. |
| currentList.add("name"); |
| currentList.addSimpleTypeMarker(); |
| currentList.add(name); |
| |
| // Set its 'value' property to the value of the property or style. |
| currentList.add("value"); |
| processNode(propertyOrStyleValueNode, context); // push value |
| |
| currentList.add(0); // styles |
| currentList.add(0); // effects |
| currentList.add(0); // events |
| currentList.addNull(); // children |
| } |
| |
| /** |
| * Generates instructions in the current context |
| * to create an instance of mx.states.SetEventHandler |
| * with its <code>target</code>, <code>name</code>, |
| * and <code>handlerFunction</code> properties set. |
| */ |
| void processEventOverride(IMXMLEventSpecifierNode eventNode, Context context) |
| { |
| FlexProject project = getProject(); |
| Name eventOverride = project.getEventOverrideClassName(); |
| |
| IASNode parentNode = eventNode.getParent(); |
| String id = parentNode instanceof IMXMLInstanceNode ? |
| ((IMXMLInstanceNode)parentNode).getEffectiveID() : |
| ""; |
| |
| String name = eventNode.getName(); |
| |
| Name eventHandler = getEventHandlerName(eventNode); |
| |
| // Construct the SetEventHandler object. |
| currentList.add(eventOverride); |
| currentList.add(3); |
| |
| // Set its 'target' property to the id of the object |
| // whose event this override will set. |
| currentList.add(NAME_TARGET); |
| currentList.addSimpleTypeMarker(); |
| currentList.add(id); |
| |
| // Set its 'name' property to the name of the event. |
| currentList.add(NAME_NAME); |
| currentList.addSimpleTypeMarker(); |
| currentList.add(name); |
| |
| // Set its 'handlerFunction' property to the autogenerated event handler. |
| currentList.add(NAME_HANDLER_FUNCTION); |
| currentList.addSimpleTypeMarker(); |
| currentList.add(eventHandler); |
| } |
| |
| /** |
| * Generates instructions in the current context |
| * to create an instance of mx.states.AddItems... |
| * |
| * Assumes lookup table is still in local3 |
| */ |
| |
| void processInstanceOverride(IMXMLInstanceNode instanceNode, Context context) |
| { |
| FlexProject project = getProject(); |
| Name instanceOverrideName = project.getInstanceOverrideClassName(); |
| |
| currentList.add(instanceOverrideName); |
| |
| // Now set properties on it! |
| |
| //---------------------------------------------------------------------- |
| // First property: set itemsFactory to the deferredInstanceFunction we created earlier |
| Integer index = nodeToIndexMap.get(instanceNode); |
| assert index != null; |
| |
| FragmentList addItemsList = new FragmentList(); |
| addItemsList.add("itemsDescriptor"); |
| addItemsList.addSimpleTypeMarker(); // the value is an array of descriptor data that will be parsed later |
| FragmentList savedList = currentList; |
| currentList = new FragmentList(); |
| InstructionList il = nodeToInstanceDescriptorMap.get(instanceNode); |
| addItemsList.addExplicit("[" + currentList.toString() + "]"); |
| currentList = savedList; |
| |
| //----------------------------------------------------------------------------- |
| // Second property set: maybe set destination and propertyName |
| |
| // get the property specifier node for the property the instanceNode represents |
| IMXMLPropertySpecifierNode propertySpecifier = (IMXMLPropertySpecifierNode) |
| instanceNode.getAncestorOfType( IMXMLPropertySpecifierNode.class); |
| |
| if (propertySpecifier == null) |
| { |
| assert false; // I think this indicates an invalid tree... |
| } |
| else |
| { |
| // Check the parent - if it's an instance then we want to use these |
| // nodes to get our property values from. If not, then it's the root |
| // and we don't need to specify destination |
| |
| IASNode parent = propertySpecifier.getParent(); |
| if (parent instanceof IMXMLInstanceNode) |
| { |
| IMXMLInstanceNode parentInstance = (IMXMLInstanceNode)parent; |
| String parentId = parentInstance.getEffectiveID(); |
| assert parentId != null; |
| String propName = propertySpecifier.getName(); |
| |
| |
| addItemsList.add("destination"); |
| addItemsList.addSimpleTypeMarker(); // simple type |
| addItemsList.add(parentId); |
| addItemsList.add("propertyName"); |
| addItemsList.addSimpleTypeMarker(); // simple type |
| addItemsList.add(propName); |
| } |
| } |
| |
| //--------------------------------------------------------------- |
| // Third property set: position and relativeTo |
| String positionPropertyValue = null; |
| String relativeToPropertyValue = null; |
| |
| // look to see if we have any sibling nodes that are not state dependent |
| // that come BEFORE us |
| IASNode instanceParent = instanceNode.getParent(); |
| IASNode prevStatelessSibling=null; |
| for (int i=0; i< instanceParent.getChildCount(); ++i) |
| { |
| IASNode sib = instanceParent.getChild(i); |
| assert sib instanceof IMXMLInstanceNode; // surely our siblings are also instances? |
| |
| // stop looking for previous nodes when we find ourself |
| if (sib == instanceNode) |
| break; |
| |
| if (!isStateDependent(sib)) |
| { |
| prevStatelessSibling = sib; |
| } |
| } |
| |
| if (prevStatelessSibling == null) { |
| positionPropertyValue = "first"; // TODO: these should be named constants |
| } |
| else { |
| positionPropertyValue = "after"; |
| relativeToPropertyValue = ((IMXMLInstanceNode)prevStatelessSibling).getEffectiveID(); |
| } |
| |
| addItemsList.add("position"); |
| addItemsList.addSimpleTypeMarker(); // simple type |
| addItemsList.add(positionPropertyValue); |
| |
| // relativeTo |
| if (relativeToPropertyValue != null) |
| { |
| addItemsList.add("relativeTo"); |
| addItemsList.addSimpleTypeMarker(); // simple type |
| addItemsList.add(relativeToPropertyValue); |
| } |
| |
| currentList.add(addItemsList.size() / 3); |
| currentList.addAll(addItemsList); |
| currentList.add(0); // styles |
| currentList.add(0); // effects |
| currentList.add(0); // events |
| currentList.addNull(); // children |
| } |
| |
| void processMXMLComponent(IMXMLComponentNode node, Context context) |
| { |
| // Resolve the outer document, and if it doesn't resolve to the contingent |
| // definition, that means there is already an existing definition declared |
| // which is an error. |
| ClassDefinition componentClass = (ClassDefinition)node.getContainedClassDefinition(); |
| ASScope classScope = componentClass.getContainedScope(); |
| IDefinition outerDocument = classScope.getPropertyFromDef( |
| getProject(), componentClass, IMXMLLanguageConstants.PROPERTY_OUTER_DOCUMENT, false); |
| assert (outerDocument != null) : "outerDocument should never be null, as always added"; |
| if (!outerDocument.isContingent()) |
| { |
| ICompilerProblem problem = new MXMLOuterDocumentAlreadyDeclaredProblem(outerDocument); |
| getProblems().add(problem); |
| } |
| |
| // Process the MXMLComponentNode as an MXMLFactoryNode, which it extends. |
| // This leaves a ClassFactory on the stack. |
| processMXMLFactory(node, context); |
| |
| // factory.properties = { outerDocument: this } |
| currentList.add(IMXMLTypeConstants.NAME_PROPERTIES); |
| currentList.addSimpleTypeMarker(); |
| currentList.addExplicit("{" + IMXMLLanguageConstants.PROPERTY_OUTER_DOCUMENT + ": this}"); |
| } |
| |
| void processMXMLEmbed(IMXMLEmbedNode node, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(node, "MXML Embedding"); |
| getProblems().add(problem); |
| } |
| |
| void processMXMLXML(IMXMLXMLNode node, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(node, "MXML XML"); |
| getProblems().add(problem); |
| } |
| |
| void processMXMLXMLList(IMXMLXMLListNode node, Context context) |
| { |
| MXMLNotImplementedProblem problem = new MXMLNotImplementedProblem(node, "MXML XMLList"); |
| getProblems().add(problem); |
| } |
| |
| /** |
| * Copied from JSClassDirectiveProcessor |
| * Declare a function. TODO: static vs. instance. |
| */ |
| @Override |
| void declareFunction(FunctionNode func) |
| { |
| func.parseFunctionBody(classScope.getProblems()); |
| |
| boolean is_constructor = func.isConstructor(); |
| |
| functionSemanticChecks(func); |
| |
| // Save the constructor function until |
| // we've seen all the instance variables |
| // that might need initialization. |
| if (is_constructor) |
| { |
| this.ctorFunction = func; |
| } |
| else |
| { |
| MethodInfo mi = classScope.getGenerator().generateFunction(func, classScope, null); |
| ITraitVisitor tv; |
| |
| if (mi != null) |
| { |
| FunctionDefinition funcDef = func.getDefinition(); |
| Name funcName = funcDef.getMName(classScope.getProject()); |
| |
| if (func.hasModifier(ASModifier.STATIC)) |
| tv = ctraits.visitMethodTrait(functionTraitKind(func, TRAIT_Method), funcName, 0, mi); |
| else |
| { |
| tv = itraits.visitMethodTrait(functionTraitKind(func, TRAIT_Method), funcName, 0, mi); |
| if (funcDef.getNamespaceReference() instanceof NamespaceDefinition.IProtectedNamespaceDefinition) |
| this.iinfo.flags |= ABCConstants.CLASS_FLAG_protected; |
| } |
| |
| this.classScope.processMetadata(tv, funcDef.getAllMetaTags()); |
| |
| if (func.hasModifier(ASModifier.FINAL)) |
| tv.visitAttribute(Trait.TRAIT_FINAL, Boolean.TRUE); |
| if (func.hasModifier(ASModifier.OVERRIDE)) |
| tv.visitAttribute(Trait.TRAIT_OVERRIDE, Boolean.TRUE); |
| } |
| } |
| } |
| |
| /** |
| * Copied from JSClassDirectiveProcessor |
| * Declare a variable. TODO: static vs. instance. |
| */ |
| @Override |
| void declareVariable(VariableNode var) |
| { |
| verifyVariableModifiers(var); |
| |
| DefinitionBase varDef = var.getDefinition(); |
| JSGenerator jsGenerator = (JSGenerator)classScope.getGenerator(); |
| jsGenerator.getReducer().startDeclareVariable(varDef); |
| |
| boolean is_static = var.hasModifier(ASModifier.STATIC); |
| boolean is_const = SemanticUtils.isConst(var, classScope.getProject()); |
| // simple initializers for public/protected vars go right on prototype. |
| // the rest (all private vars), all "complex" initializers (like array) get |
| // initialized in the constructor |
| boolean needs_constructor_init = true; |
| |
| // generateConstantValue() returns null if no constant value |
| // can be generated, and null is the correct value for "no value." |
| IConstantValue constantValue = jsGenerator.generateConstantValue(var.getAssignedValueNode(), this.classScope.getProject()); |
| |
| // initializer is null if no constant value |
| // can be generated, and null is the correct value for "no value." |
| Object initializer = constantValue != null ? constantValue.getValue() : null; |
| |
| ITraitVisitor tv = declareVariable(var, varDef, is_static, is_const, initializer); |
| |
| this.classScope.processMetadata(tv, varDef.getAllMetaTags()); |
| |
| // Generate variable initializers and append them to the |
| // proper initialization list. |
| if (var.getChildCount() > 1) |
| { |
| // We need to put the correct traits visitor on the class' |
| // LexicalScope; the BURM may encounter variable declarations |
| // chained onto this one, and it will need the traits visitor to declare them. |
| |
| // Save the scope's current traits visitor (which should be null) |
| // and restore it |
| ITraitsVisitor saved_traits_visitor = this.classScope.traitsVisitor; |
| assert (saved_traits_visitor == null); |
| try |
| { |
| // the following line causes duplicate Traits. |
| // JSEmitter::emitTraits works around duplicate Traits by checking against |
| // a visitedTraits set. |
| this.classScope.traitsVisitor = (is_static) ? ctraits : itraits; |
| this.classScope.resetDebugInfo(); |
| InstructionList init_expression = jsGenerator.generateInstructions(var, CmcJSEmitter.__statement_NT, this.classScope); |
| if (init_expression != null && !init_expression.isEmpty()) |
| { |
| // final JSEmitter emitter = (JSEmitter)this.classScope.getEmitter(); |
| final String str = JSGeneratingReducer.instructionListToString(init_expression, true); |
| |
| if (str.contains(" = ")) |
| { |
| final String varInit = jsGenerator.getReducer().getVariableInitializer(varDef); |
| if (varInit != null && !varInit.isEmpty()) |
| { |
| // set the value of the slot trait. |
| final String varName = varDef.getBaseName(); |
| for (Trait t : this.classScope.traitsVisitor.getTraits()) |
| { |
| final byte kind = t.getKind(); |
| if (kind == TRAIT_Const || kind == TRAIT_Var) |
| { |
| boolean is_private = false; |
| final Name name = t.getNameAttr(Trait.TRAIT_NAME); |
| Namespace ns = name.getSingleQualifier(); |
| if (ns.getKind() == CONSTANT_PrivateNs) |
| is_private = true; |
| if (name.getBaseName().equals(varName)) |
| { |
| t.setAttr(Trait.SLOT_VALUE, varInit); |
| if (!is_private) |
| needs_constructor_init = false; |
| break; |
| } |
| } |
| } |
| |
| } |
| |
| if (is_static) |
| { |
| // see finishClassDefinition. |
| // We clear cinitInsns only if there are no side effects |
| // by initializing the static members directly. |
| // If varInit is null, or varInit is isEmpty() |
| // then we have side effects. |
| if (!init_expression.isEmpty()) |
| registerClassInit(var); |
| |
| cinitInsns.addAll(init_expression); |
| } |
| else if (needs_constructor_init) |
| iinitInsns.addAll(init_expression); |
| } |
| } |
| } |
| finally |
| { |
| this.classScope.traitsVisitor = saved_traits_visitor; |
| } |
| } |
| |
| jsGenerator.getReducer().endDeclareVariable(varDef); |
| } |
| |
| private void registerClassInit(IASNode node) |
| { |
| final String fullName = JSGeneratingReducer.createFullNameFromDefinition(classScope.getProject(), classDefinition); |
| if (!fullName.equals(JSSharedData.JS_FRAMEWORK_NAME)) |
| { |
| JSGenerator jsGenerator = (JSGenerator)classScope.getGenerator(); |
| JSSharedData.instance.registerClassInit(fullName); |
| jsGenerator.getReducer().warnClassInitPerformance(node); |
| jsGenerator.getReducer().setNeedsSecondPass(); |
| } |
| } |
| |
| /** |
| * Determines the Name of the event handler method for an event node. |
| * This can get called to preassign the name before the method gets generated. |
| */ |
| protected Name getEventHandlerName(IMXMLEventSpecifierNode eventNode) |
| { |
| // Check the map to see if a handler name |
| // has already been assigned to this event node. |
| Name name = eventHandlerMap.get(eventNode); |
| |
| // If so, return it. |
| if (name != null) |
| return name; |
| |
| // Otherwise, generate the next one in the sequence "$EH0", "$EH1", etc. |
| String baseName = EVENT_HANDLER_NAME_BASE + eventHandlerCounter++; |
| |
| name = new Name(baseName); |
| |
| // Remember it in the map. |
| eventHandlerMap.put(eventNode, name); |
| |
| return name; |
| } |
| |
| static class FragmentList |
| { |
| ArrayList<String> list = new ArrayList<String>(); |
| |
| void add(boolean value) |
| { |
| if (value) |
| list.add("true"); |
| else |
| list.add("false"); |
| } |
| |
| void add(int value) |
| { |
| list.add(new Integer(value).toString()); |
| } |
| |
| void add(long value) |
| { |
| list.add(new Long(value).toString()); |
| } |
| |
| void add(double value) |
| { |
| list.add(new Double(value).toString()); |
| } |
| |
| void add(Name name) |
| { |
| StringBuilder sb = new StringBuilder(); |
| String s = name.getSingleQualifier().getName(); |
| if (s.length() > 0) |
| { |
| sb.append(s); |
| sb.append("."); |
| } |
| sb.append(name.getBaseName()); |
| list.add(sb.toString()); |
| } |
| |
| void add(String string) |
| { |
| list.add("'" + string + "'"); |
| } |
| |
| void addExplicit(String string) |
| { |
| list.add(string); |
| } |
| |
| void addAll(FragmentList addlist) |
| { |
| list.addAll(addlist.list); |
| } |
| |
| void addSimpleTypeMarker() |
| { |
| list.add("true"); |
| } |
| |
| void addObjectTypeMarker() |
| { |
| list.add("false"); |
| } |
| |
| void addArrayTypeMarker() |
| { |
| list.add("null"); |
| } |
| |
| void addNull() |
| { |
| list.add("null"); |
| } |
| |
| int size() |
| { |
| return list.size(); |
| } |
| |
| String get(int i) |
| { |
| return list.get(i); |
| } |
| |
| public String toString() |
| { |
| StringBuilder sb = new StringBuilder(); |
| int n = list.size(); |
| for (int i = 0; i < n; i++) |
| { |
| sb.append(list.get(i)); |
| if (i < n - 1) |
| sb.append(", "); |
| } |
| return sb.toString(); |
| } |
| |
| } |
| } |
