Package macromedia.asc.parser

Examples of macromedia.asc.parser.MemberExpressionNode

1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
                if (fd.fexpr.signature.result != null)
                {
                    TypeExpressionNode result = (TypeExpressionNode)fd.fexpr.signature.result;
                    if(result.expr != null)
                    {
                        MemberExpressionNode expr = (MemberExpressionNode)result.expr;
                        resultType = getRefName(cx, expr.ref);
                    }
                }
                else if( fd.fexpr.signature.void_anno )
                    resultType = "void";
View Full Code Here
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
                    {
                        defaultValue = (((LiteralBooleanNode)(vb.initializer)).value) ? "true" : "false";
                    }
                    else if (vb.initializer instanceof MemberExpressionNode)
                    {
                        MemberExpressionNode mb = (MemberExpressionNode)(vb.initializer);
                        Slot vs = null;
            if (mb.ref != null && mb.selector.isGetExpression())
            {
              vs = (mb.ref != null ? mb.ref.getSlot(cx, Tokens.GET_TOKEN) : null);
            }
View Full Code Here
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
       
        //And finally our completed _skinPart AST
        VariableDefinitionNode skinParts = (VariableDefinitionNode)AbstractSyntaxTreeUtil.generatePrivateStaticVariable(currentContext, typeExpression, _SKINPARTS, literalObject);
       
        //Signature for getter that takes no parameters (of course) and returns an Object
        MemberExpressionNode returnTypeExpression = AbstractSyntaxTreeUtil.generateGetterSelector(nodeFactory, OBJECT, true);
        TypeExpressionNode returnType = nodeFactory.typeExpression(returnTypeExpression, true, false, -1);
        FunctionSignatureNode functionSignature = nodeFactory.functionSignature(null, returnType);
       
        //generate <ClassName>._skinParts
        IdentifierNode identifier = AbstractSyntaxTreeUtil.generateIdentifier(nodeFactory, _SKINPARTS, false);
        GetExpressionNode selector = nodeFactory.getExpression(identifier);
      
        MemberExpressionNode memberExpression = nodeFactory.memberExpression(null, selector);
        ListNode list = nodeFactory.list(null, memberExpression);

        //return <ClassName>._skinParts
        ReturnStatementNode returnStatement = nodeFactory.returnStatement(list);
        StatementListNode rStatementList = nodeFactory.statementList(null, returnStatement);
View Full Code Here
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
        // process extends
        if (classDefinition.baseclass != null)
        {
            if (classDefinition.baseclass instanceof MemberExpressionNode)
            {
                MemberExpressionNode memberExpression = (MemberExpressionNode) classDefinition.baseclass;

                if (memberExpression.selector != null)
                {
                    IdentifierNode identifier = memberExpression.selector.getIdentifier();
                    String baseClassName = toString(identifier);
                    inheritanceNames.add(baseClassName);
                }
            }
            else if (classDefinition.baseclass instanceof LiteralStringNode)
            {
                String baseClassName = ((LiteralStringNode) classDefinition.baseclass).value;
                inheritanceNames.add(baseClassName);
            }
            else
            {
                assert false;
            }
        }
        else
        {
          inheritanceNames.add(":Object");
        }

        // process interfaces
        if (classDefinition.interfaces != null)
        {
            Iterator iterator = classDefinition.interfaces.items.iterator();

            while ( iterator.hasNext() )
            {
                MemberExpressionNode memberExpression = (MemberExpressionNode) iterator.next();

                if (memberExpression.selector != null)
                {
                    IdentifierNode identifier = memberExpression.selector.getIdentifier();
                    String interfaceName = toString(identifier);
View Full Code Here
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
        // process extends
        if (interfaceDefinition.baseclass != null)
        {
            if (interfaceDefinition.baseclass instanceof MemberExpressionNode)
            {
                MemberExpressionNode memberExpression = (MemberExpressionNode) interfaceDefinition.baseclass;

                if (memberExpression.selector != null)
                {
                    IdentifierNode identifier = memberExpression.selector.getIdentifier();
                    String baseInterfaceName = toString(identifier);
                    inheritanceNames.add(baseInterfaceName);
                }
            }
            else
            {
                assert false;
            }
        }
        else
        {
          inheritanceNames.add(":Object");
        }

        // process interfaces: It would seem that ASC sometimes puts an interface's base
        // interface in the InterfaceDefinitionNode's interfaces list.  I'm not sure if
        // this is always the case, though.
        if (interfaceDefinition.interfaces != null)
        {
            Iterator iterator = interfaceDefinition.interfaces.items.iterator();

            while ( iterator.hasNext() )
            {
                MemberExpressionNode memberExpression = (MemberExpressionNode) iterator.next();

                if (memberExpression.selector != null)
                {
                    IdentifierNode identifier = memberExpression.selector.getIdentifier();
                    String baseInterfaceName = toString(identifier);
View Full Code Here
83
84
85
86
87
88
89
90
91
92
        Node valueExpr = generateValueExpr(nodeFactory, configNamespaces, generateDocComments);
        argumentList = nodeFactory.argumentList(argumentList, valueExpr);
        CallExpressionNode callExpression =
            (CallExpressionNode) nodeFactory.callExpression(identifier, argumentList);
        callExpression.setRValue(false);
        MemberExpressionNode memberExpression = nodeFactory.memberExpression(lvalueBase, callExpression);
        ListNode list = nodeFactory.list(null, memberExpression);
        ExpressionStatementNode expressionStatement = nodeFactory.expressionStatement(list);
        return nodeFactory.statementList(statementList, expressionStatement);
    }
View Full Code Here
68
69
70
71
72
73
74
75
76
77
        ArgumentListNode expr = nodeFactory.argumentList(null, literalNumber);
        Node value = generateValueExpr(nodeFactory, configNamespaces, generateDocComments);
        ArgumentListNode argumentList = nodeFactory.argumentList(null, value);
        SetExpressionNode setExpression = nodeFactory.setExpression(expr, argumentList, false);
    setExpression.setMode(Tokens.LEFTBRACKET_TOKEN);
        MemberExpressionNode memberExpression = nodeFactory.memberExpression(lvalueBase, setExpression);
        ListNode list = nodeFactory.list(null, memberExpression);
        ExpressionStatementNode expressionStatement = nodeFactory.expressionStatement(list);
        return nodeFactory.statementList(statementList, expressionStatement);
    }
View Full Code Here
85
86
87
88
89
90
91
92
93
94
        Node valueExpr = generateValueExpr(nodeFactory, configNamespaces, generateDocComments);
        argumentList = nodeFactory.argumentList(argumentList, valueExpr);
        CallExpressionNode callExpression =
            (CallExpressionNode) nodeFactory.callExpression(identifier, argumentList);
        callExpression.setRValue(false);
        MemberExpressionNode memberExpression = nodeFactory.memberExpression(lvalueBase, callExpression);
        ListNode list = nodeFactory.list(null, memberExpression);
        ExpressionStatementNode expressionStatement = nodeFactory.expressionStatement(list);
        return nodeFactory.statementList(statementList, expressionStatement);
    }
View Full Code Here
55
56
57
58
59
60
61
62
63
64
    super(movieClip, movieClip.getXmlLineNumber(), movieClip.getStandardDefs());
  }

  private String extractName(Node lvalueBase)
  {
    MemberExpressionNode memberExpression = (MemberExpressionNode) lvalueBase;
    GetExpressionNode getExpression = (GetExpressionNode) memberExpression.selector;
    IdentifierNode identifier = (IdentifierNode) getExpression.expr;
    return identifier.name;
  }
View Full Code Here
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
                AbstractSyntaxTreeUtil.generateVariable(nodeFactory, REPEATER,
                                                        standardDefs.CLASS_REPEATER_DOT, true,
                                                        value);
            nodeFactory.statementList(statementList, variableDefinition);

            MemberExpressionNode repeaterBase =
                AbstractSyntaxTreeUtil.generateGetterSelector(nodeFactory, REPEATER, false);

            IdentifierNode initializeRepeaterIdentifier = nodeFactory.identifier(INITIALIZE_REPEATER, false);
            MemberExpressionNode lvalueBaseMemberExpression =
                AbstractSyntaxTreeUtil.generateGetterSelector(nodeFactory, name, true);
      ArgumentListNode initializeRepeaterArgumentList =
                nodeFactory.argumentList(null, lvalueBaseMemberExpression);
            LiteralBooleanNode literalBoolean = nodeFactory.literalBoolean(true);
            initializeRepeaterArgumentList = nodeFactory.argumentList(initializeRepeaterArgumentList,
                                                                      literalBoolean);
      CallExpressionNode initializeRepeaterCallExpression =
        (CallExpressionNode) nodeFactory.callExpression(initializeRepeaterIdentifier,
                                                                initializeRepeaterArgumentList);
      initializeRepeaterCallExpression.setRValue(false);
            MemberExpressionNode initializeRepeaterMemberExpression =
                nodeFactory.memberExpression(repeaterBase, initializeRepeaterCallExpression);
            ListNode initializeRepeaterList = nodeFactory.list(null, initializeRepeaterMemberExpression);
            ExpressionStatementNode initializeRepeaterExpressionStatement =
                nodeFactory.expressionStatement(initializeRepeaterList);
            nodeFactory.statementList(statementList, initializeRepeaterExpressionStatement);           

      MemberExpressionNode condition = generateChildRepeaters(nodeFactory, lvalueBase);
      MemberExpressionNode thenExpr = generateThen(nodeFactory, name);
      ListNode elseExpr = generateElse(nodeFactory, name);
      ConditionalExpressionNode conditionalExpression =
                nodeFactory.conditionalExpression(condition, thenExpr, elseExpr);
      ListNode base = nodeFactory.list(null, conditionalExpression);

      IdentifierNode pushIdentifier = nodeFactory.identifier(PUSH, false);
            MemberExpressionNode repeaterMemberExpression =
                AbstractSyntaxTreeUtil.generateGetterSelector(nodeFactory, REPEATER, false);
      ArgumentListNode pushArgumentList = nodeFactory.argumentList(null, repeaterMemberExpression);
      CallExpressionNode pushCallExpression =
        (CallExpressionNode) nodeFactory.callExpression(pushIdentifier, pushArgumentList);
      pushCallExpression.setRValue(false);

      MemberExpressionNode pushMemberExpression = nodeFactory.memberExpression(base, pushCallExpression);
      ListNode pushList = nodeFactory.list(null, pushMemberExpression);
            ExpressionStatementNode pushExpressionStatement = nodeFactory.expressionStatement(pushList);
            return nodeFactory.statementList(statementList, pushExpressionStatement);
    }
    else
    {
      IdentifierNode identifier = nodeFactory.identifier(ADD_CHILD, false);
      Node valueExpr = generateValueExpr(nodeFactory, configNamespaces, generateDocComments);
      ArgumentListNode argumentList = nodeFactory.argumentList(null, valueExpr);
      CallExpressionNode callExpression =
        (CallExpressionNode) nodeFactory.callExpression(identifier, argumentList);
      callExpression.setRValue(false);
      MemberExpressionNode memberExpression = nodeFactory.memberExpression(lvalueBase, callExpression);
      ListNode list = nodeFactory.list(null, memberExpression);
      ExpressionStatementNode expressionStatement = nodeFactory.expressionStatement(list);
            return nodeFactory.statementList(statementList, expressionStatement);
    }
  }
View Full Code Here
TOP

Related Classes of macromedia.asc.parser.MemberExpressionNode

  • flex2.compiler.as3.binding.BindableSecondPassEvaluator
  • flex2.compiler.as3.InheritanceEvaluator
  • flex2.compiler.as3.SkinPartEvaluator
  • flex2.compiler.asdoc.ClassTable$CommentsTable$CommentEntry
  • flex2.compiler.mxml.rep.AtResource
  • flex2.compiler.mxml.rep.init.ArrayElementInitializer
  • flex2.compiler.mxml.rep.init.EffectInitializer
  • flex2.compiler.mxml.rep.init.StyleInitializer
  • flex2.compiler.mxml.rep.init.VisualChildInitializer
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.