public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
        {
            //embedded-type "." identifier
            CsPredefinedTypeMemberAccess ex = pStatement as CsPredefinedTypeMemberAccess;
            string name;
            bool   renamed = Helpers.GetRealName(ex, ex.identifier.identifier, out name);

            if (renamed)
            {
                return(new Expression(name, pStatement.entity_typeref));
            }

            CsEntityProperty p = ex.entity as CsEntityProperty;

            if (p != null)
            {
                //getter, rename
                name = "get_" + name + "()";
            }
            else if (ex.ec == expression_classification.ec_event_access)                //remove eventhandler name
            {
                name = string.Empty;
            }
            //FactoryExpressionCreator.Parse(ex.expression).Value
            return(new Expression(
                       "nose" + "." + name,
                       pStatement.entity_typeref
                       ));
        }
Exemplo n.º 2
0
        public static Expression ParseSimpleName(CsExpression pStatement, bool pForce, bool pGetSetter)
        {
            CsSimpleName ex = (CsSimpleName)pStatement;

            bool   isInternal = false;
            string val;

            if (ex.ec == expression_classification.ec_property_access)
            {
                CsAssignmentExpression parent = pStatement.parent as CsAssignmentExpression;

                if (!pForce)
                {
                    pGetSetter = parent != null && parent.lhs.Equals(pStatement);
                }

                isInternal = true;
                CsEntityProperty property = (CsEntityProperty)ex.entity;
                val = pGetSetter ? string.Format("{0}({{0}})", property.setter.name) : string.Format("{0}()", property.getter.name);
            }
            else
            {
                //val = ex.identifier.identifier;
                Helpers.GetRealName(ex, ex.identifier.identifier, out val);
            }

            return(new Expression(
                       val,
                       ex.entity_typeref,
                       isInternal));
        }
Exemplo n.º 3
0
        public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator)
        {
            //expression "." identifier (type-argument-list?)
            CsPrimaryExpressionMemberAccess ex = (CsPrimaryExpressionMemberAccess)pStatement;
            string name;
            bool   renamed = Helpers.GetRealName(ex, ex.identifier.identifier, out name);

            if (renamed)
            {
                return(new Expression(name, pStatement.entity_typeref));
            }

            CsEntityProperty p          = ex.entity as CsEntityProperty;
            bool             isInternal = false;

            if (p != null && p.decl != null)
            {
                TheClass theClass = TheClassFactory.Get(p, pCreator);
                TheClass parent   = theClass;

                //Am I extending a standard flash class? Do not rename then...
                bool isStandardGetSet = false;
                while (parent.Base != null)
                {
                    isStandardGetSet |= parent.FullName.StartsWith("flash.");
                    parent            = parent.Base;
                }

                if (!isStandardGetSet)
                {
                    TheProperty theProperty = theClass.GetProperty((CsProperty)p.decl);
                    if (theProperty != null)
                    {
                        if (ex.parent is CsAssignmentExpression)
                        {
                            //setter
                            isInternal = true;
                            name       = "set_" + name + "({0})";
                        }
                        else
                        {
                            //getter, rename
                            name = "get_" + name + "()";
                        }
                    }
                }
            }
            else if (ex.ec == expression_classification.ec_event_access)                //remove eventhandler name
            {
                name = string.Empty;
            }

            return(new Expression(
                       pCreator.Parse(ex.expression).Value + "." + name,
                       pStatement.entity_typeref,
                       isInternal
                       ));
        }