public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsLambdaExpression ex = (CsLambdaExpression)pStatement; LambdaMethodExpression lambda = new LambdaMethodExpression((CsLambdaExpression)pStatement, pCreator); CodeBuilder b = new CodeBuilder(); b.AppendFormat("function ({0}):{1} {{", As3Helpers.GetParameters(lambda.Arguments), (lambda.ReturnType == null) ? "void" : As3Helpers.Convert(lambda.ReturnType) ); b.Indent(); b.Indent(); b.Indent(); b.AppendLine(); if (!(lambda.CodeBlock is CsBlock)) { b.Append("return "); } BlockParser.ParseNode(lambda.CodeBlock, b, pCreator); b.AppendLine("}"); b.AppendLine(); b.Unindent(); b.Unindent(); b.Unindent(); return new Expression(b.ToString(), ex.entity_typeref); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { // "default" ( type ) return new Expression( null, pStatement.entity_typeref ); }
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); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsPostIncrementDecrementExpression ex = (CsPostIncrementDecrementExpression)pStatement; Expression exp = pCreator.Parse(ex.expression); if (exp.InternalType) { if (ex.expression is CsElementAccess) { string setter = ElementAccessHelper.parseElementAccess(ex.expression, true, true, pCreator).Value; switch (ex.oper) { case CsTokenType.tkINC: return new Expression(string.Format(setter, exp.Value + "++"), exp.Type); case CsTokenType.tkDEC: return new Expression(string.Format(setter, exp.Value + "--"), exp.Type); default: throw new Exception(); } } } switch (ex.oper) { case CsTokenType.tkINC: return new Expression(exp.Value + "++", exp.Type); case CsTokenType.tkDEC: return new Expression(exp.Value + "--", exp.Type); default: throw new NotImplementedException(); } }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsBinaryExpression li = (CsBinaryExpression)pStatement; Expression left = pCreator.Parse(li.lhs); Expression right = pCreator.Parse(li.rhs); return new Expression(left.Value + " " + JsHelpers.ConvertTokens(Helpers.GetTokenType(li.oper)) + " " + right.Value, pStatement.entity_typeref); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsOperatorUnaryExpression ex = (CsOperatorUnaryExpression)pStatement; return new Expression( JsHelpers.ConvertTokens(Helpers.GetTokenType(ex.oper)) + pCreator.Parse(ex.unary_expression).Value, pStatement.entity_typeref ); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //object-creation-expression: //"new" type "(" ( argument_list )? ")" object-or-collection-initializer? //"new" type object-or-collection-initializer //delegate-creation-expression: //"new" delegate-type "(" expression ")" CsNewObjectExpression node = (CsNewObjectExpression)pStatement; StringBuilder sb = new StringBuilder(); string name = As3Helpers.Convert(Helpers.GetType(node.type)); bool isVector = name.StartsWith("Vector.<", StringComparison.Ordinal) && node.initializer != null; bool isArray = name.Equals("Array", StringComparison.Ordinal) && node.initializer != null; if (!isArray) sb.Append("(new "); if (isVector || isArray) { if (isVector) { int lb = name.IndexOf("<") + 1; sb.AppendFormat("<{0}>", name.Substring(lb, name.IndexOf(">") - lb)); } sb.Append("["); CsCollectionInitializer initializer = (CsCollectionInitializer)node.initializer; if (initializer.element_initializer_list != null) { List<string> args = new List<string>(); foreach (var csNode in initializer.element_initializer_list) { args.Add(pCreator.Parse(csNode).Value); } sb.Append(String.Join(", ", args.ToArray())); } } else { sb.AppendFormat("{0}(", name); if (node.argument_list != null) { List<string> args = new List<string>(); foreach (CsArgument argument in node.argument_list.list) { args.Add(pCreator.Parse(argument.expression).Value); } sb.Append(String.Join(", ", args.ToArray())); } } sb.Append(isVector || isArray ? "]" : ")"); if (!isArray) sb.Append(")"); return new Expression( sb.ToString(), pStatement.entity_typeref ); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsPreIncrementDecrementExpression ex = (CsPreIncrementDecrementExpression)pStatement; Expression exp = pCreator.Parse(ex.unary_expression); return new Expression( As3Helpers.ConvertTokens(Helpers.GetTokenType(ex.oper)) + exp.Value, pStatement.entity_typeref ); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsAsIsExpression ex = (CsAsIsExpression)pStatement; return new Expression( pCreator.Parse(ex.expression).Value + " " + As3Helpers.ConvertTokens(Helpers.GetTokenType(ex.oper)) + " " + As3Helpers.Convert(Helpers.GetType(ex.type)), ex.entity_typeref ); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsConditionalExpression ex = (CsConditionalExpression)pStatement; return new Expression( pCreator.Parse(ex.condition).Value + " ? " + pCreator.Parse(ex.true_expression).Value + " : " + pCreator.Parse(ex.false_expression).Value, pStatement.entity_typeref ); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsCastUnaryExpression ex = (CsCastUnaryExpression)pStatement; //Do not cast anything. This is here just to support the automatic casting done by the flash player. return new Expression( //As3Helpers.Convert(Helpers.GetType(ex.type)) + "(" + pCreator.Parse(ex.unary_expression).Value //+ ")" , ex.type.entity_typeref ); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsTypeofExpression ex = (CsTypeofExpression)pStatement; //"typeof" "(" type ")" CsNamespaceOrTypeName isClass = ex.type.type_name as CsNamespaceOrTypeName; if (isClass != null) { return new Expression(isClass.identifier.identifier, ex.type.entity_typeref); } throw new NotImplementedException(); }
internal static Expression parseElementAccess(CsExpression pStatement, bool pForce, bool pGetSetter, FactoryExpressionCreator pCreator) { //expression "[" expression-list "]" CsElementAccess stat = (CsElementAccess)pStatement; List<CsExpression> l = new List<CsExpression>(); foreach (CsArgument csArgument in stat.argument_list.list) { l.Add(csArgument.expression); } return getIndexerExpression(stat, l, pCreator.Parse(stat.expression), pForce, pGetSetter, pCreator); }
protected virtual void Add_GetBaseUnitValue() { var cs = Ext.Create <BasicUnitValuesGenerator>(); cs.SingleLineIf("Unit.Equals(BaseUnit)", ReturnValue("Value")); cs.WriteLine("var factor = GlobalUnitRegistry.Factors.Get(Unit);"); cs.SingleLineIf("!(factor is null)", ReturnValue("Value * factor.Value")); var exceptionMessage = new CsExpression("Unable to find multiplication for unit ".CsEncode()) + new CsExpression("Unit"); cs.Throw <Exception>(exceptionMessage.ToString()); Target.AddMethod("GetBaseUnitValue", ValuePropertyType) .WithBody(cs); }
protected override void Add_GetBaseUnitValue() { var cs = Ext.Create <BasicUnitValuesGenerator>(); cs.WriteLine("var factor1 = GlobalUnitRegistry.Factors.Get(Unit.LeftUnit);"); cs.WriteLine("var factor2 = GlobalUnitRegistry.Factors.Get(Unit.RightUnit);"); cs.SingleLineIf("(factor1.HasValue && factor2.HasValue)", ReturnValue("Value * factor1.Value * factor2.Value")); var exceptionMessage = new CsExpression("Unable to find multiplication for unit ".CsEncode()) + new CsExpression("Unit"); cs.Throw <Exception>(exceptionMessage.ToString()); Target.AddMethod("GetBaseUnitValue", ValuePropertyType) .WithBody(cs); }
internal static Expression parseElementAccess(CsExpression pStatement, bool pForce, bool pGetSetter, FactoryExpressionCreator pCreator) { //expression "[" expression-list "]" CsElementAccess stat = (CsElementAccess)pStatement; List <CsExpression> l = new List <CsExpression>(); foreach (CsArgument csArgument in stat.argument_list.list) { l.Add(csArgument.expression); } return(getIndexerExpression(stat, l, pCreator.Parse(stat.expression), pForce, pGetSetter, pCreator)); }
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 ); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsAnonymousObjectCreationExpression ex = (CsAnonymousObjectCreationExpression)pStatement; StringBuilder builder = new StringBuilder("{"); if (ex.member_declarator_list != null) { foreach (var declarator in ex.member_declarator_list) { builder.AppendFormat(@"""{0}"": {1}, ", declarator.identifier.identifier, pCreator.Parse(declarator.expression).Value ); } builder.Remove(builder.Length - 2, 2); } builder.Append("}"); return new Expression(builder.ToString(), ex.entity_typeref); }
internal static Expression getIndexerExpression(CsExpression pStatement, IEnumerable<CsExpression> pList, Expression pIndexer, bool pForce, bool pGetSetter, FactoryExpressionCreator pCreator) { TheClass k = TheClassFactory.Get(pStatement, pCreator); List<string> indexes = new List<string>(); List<CsEntityTypeRef> param = new List<CsEntityTypeRef>(); foreach (CsExpression ex in pList) { Expression te = pCreator.Parse(ex); indexes.Add(te.Value); param.Add(te.Type); } string exp = pIndexer == null ? "super" : pIndexer.Value; bool isInternal = false; TheIndexer i = null; if (k != null) i = k.GetIndexer(pStatement); //TODO: Check array access... if (i == null || pIndexer == null || (pIndexer.Type != null && pIndexer.Type.type == cs_entity_type.et_array)) { //Array access or unknown accessor exp += "[" + indexes[0] + "]"; } else { //TheIndexers i = k.GetIndexerBySignature(param); isInternal = true; CsAssignmentExpression parent = pStatement.parent as CsAssignmentExpression; if (!pForce) { pGetSetter = parent != null && parent.lhs.Equals(pStatement); } if (pGetSetter) { exp += "." + i.Setter.Name + "(" + string.Join(", ", indexes.ToArray()) + ", {0})"; } else { exp += "." + i.Getter.Name + "(" + string.Join(", ", indexes.ToArray()) + ")"; } } return new Expression(exp, pStatement.entity_typeref, isInternal); }
public TheIndexer GetIndexer(CsExpression pIndexer) { CsBaseIndexerAccess csbia = pIndexer as CsBaseIndexerAccess; CsIndexer i; CsEntityProperty p; if (csbia != null) { p = (CsEntityProperty)csbia.entity; if (p == null) { return(null); } i = (CsIndexer)p.decl; if (i == null) { return(null); } return(_indexers.ContainsKey(i) ? _indexers[i] : null); } CsElementAccess csea = pIndexer as CsElementAccess; if (csea != null) { p = (CsEntityProperty)csea.entity; if (p == null) { return(null); } i = (CsIndexer)p.decl; if (i == null) { return(null); } return(_indexers.ContainsKey(i) ? _indexers[i] : null); } throw new NotImplementedException(); }
private void ProcessExpression(CsExpression expression) { switch (expression.e) { case cs_node.n_simple_name: ProcessResultExpression(expression); break; case cs_node.n_lambda_expression: ProcessLambdaExpression((CsLambdaExpression)expression); break; default: Debugger.Break(); break; } }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //"new" non-array-type "[" expression-list "]" ( rank-specifiers )? ( array-initializer )? //"new" non-array-type? rank-specifiers array-initializer CsNewArrayExpression ex = (CsNewArrayExpression)pStatement; StringBuilder builder = new StringBuilder(); if (ex.initializer != null) { builder.Append("["); //builder.AppendFormat("new <{0}>[", As3Helpers.Convert(Helpers.GetType(((CsEntityArraySpecifier)ex.entity_typeref.u).type))); if (ex.initializer.initializers != null) { List <string> initializers = new List <string>(); foreach (CsNode node in ex.initializer.initializers) { Expression expression = pCreator.Parse(node as CsExpression); initializers.Add(expression.Value); } if (initializers.Count != 0) { builder.Append(string.Join(", ", initializers.ToArray())); } } builder.Append("]"); //builder.Append("]"); } else if (ex.expressions != null && ex.expressions.list != null && ex.expressions.list.Count == 1) { builder.Append("new Array("); Expression expression = pCreator.Parse(ex.expressions.list.First.Value); builder.Append(expression.Value); builder.Append(")"); } return(new Expression(builder.ToString(), pStatement.entity_typeref)); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsAnonymousObjectCreationExpression ex = (CsAnonymousObjectCreationExpression)pStatement; StringBuilder builder = new StringBuilder("{"); if (ex.member_declarator_list != null) { foreach (var declarator in ex.member_declarator_list) { builder.AppendFormat(@"""{0}"": {1}, ", declarator.identifier.identifier, pCreator.Parse(declarator.expression).Value ); } builder.Remove(builder.Length - 2, 2); } builder.Append("}"); return(new Expression(builder.ToString(), ex.entity_typeref)); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsPostIncrementDecrementExpression ex = (CsPostIncrementDecrementExpression)pStatement; Expression exp = pCreator.Parse(ex.expression); if (exp.InternalType) { if (ex.expression is CsElementAccess) { string setter = ElementAccessHelper.parseElementAccess(ex.expression, true, true, pCreator).Value; switch (ex.oper) { case CsTokenType.tkINC: return(new Expression(string.Format(setter, exp.Value + "++"), exp.Type)); case CsTokenType.tkDEC: return(new Expression(string.Format(setter, exp.Value + "--"), exp.Type)); default: throw new Exception(); } } } switch (ex.oper) { case CsTokenType.tkINC: return(new Expression(exp.Value + "++", exp.Type)); case CsTokenType.tkDEC: return(new Expression(exp.Value + "--", exp.Type)); default: throw new NotImplementedException(); } }
private Col1 GetPropertiesInfo(int nr) { IReadOnlyList <ConstructorParameterInfo> items = new[] { new ConstructorParameterInfo(PropName, "string", null, "name of unit", Flags1.NormalizedString | Flags1.AddNotNullAttributeToPropertyIfPossible) }; if (nr == 0) { return(new Col1(items)); } items = new[] { new ConstructorParameterInfo("BaseUnit", Cfg.Source.Unit.GetTypename(), null, "base unit", Flags1.NotNull | Flags1.PropertyCanBeNull), new ConstructorParameterInfo(PropName, "string", null, "name of unit", Flags1.TrimValue | Flags1.Optional | Flags1.DoNotAssignProperty | Flags1.DoNotCreateProperty) }; var a = new Col1(items); var forceValue = new CsExpression("unitName"); var takeFromBaseUnit = new CsExpression("1/".CsEncode()) + new CsExpression("baseUnit.UnitName"); var c3 = new CsExpression("string.IsNullOrEmpty(unitName)").Conditional(takeFromBaseUnit, forceValue); a.Writer2.WriteAssign("UnitName", c3.Code); return(a); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //"new" non-array-type "[" expression-list "]" ( rank-specifiers )? ( array-initializer )? //"new" non-array-type? rank-specifiers array-initializer CsNewArrayExpression ex = (CsNewArrayExpression) pStatement; StringBuilder builder = new StringBuilder(); if (ex.initializer != null) { builder.Append("["); //builder.AppendFormat("new <{0}>[", JsHelpers.Convert(Helpers.GetType(((CsEntityArraySpecifier)ex.entity_typeref.u).type))); if (ex.initializer.initializers != null) { List<string> initializers = new List<string>(); foreach (CsNode node in ex.initializer.initializers) { Expression expression = pCreator.Parse(node as CsExpression); initializers.Add(expression.Value); } if (initializers.Count != 0) { builder.Append(string.Join(", ", initializers.ToArray())); } } builder.Append("]"); //builder.Append("]"); } else if (ex.expressions != null && ex.expressions.list != null && ex.expressions.list.Count == 1) { builder.Append("new Array("); Expression expression = pCreator.Parse(ex.expressions.list.First.Value); builder.Append(expression.Value); builder.Append(")"); } return new Expression(builder.ToString(), pStatement.entity_typeref); }
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 ); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsBaseMemberAccess baseMemberAccess = (CsBaseMemberAccess)pStatement; // "base" "." identifier (type-argument-list)? return new Expression("super." + baseMemberAccess.identifier.identifier, pStatement.entity_typeref); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //"sizeof" "(" type ")" throw new NotImplementedException(); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //"checked" "(" expression ")" throw new NotImplementedException(); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { throw new NotImplementedException(); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsAssignmentExpression ex = (CsAssignmentExpression)pStatement; Expression left = pCreator.Parse(ex.lhs); Expression right = pCreator.Parse(ex.rhs); if (((ex.lhs is CsElementAccess) || (ex.lhs is CsPrimaryExpressionMemberAccess)) && left.InternalType) { switch (ex.oper) { case CsTokenType.tkASSIGN: return(new Expression(string.Format(left.Value, right.Value), pStatement.entity_typeref)); case CsTokenType.tkPLUS_EQ: case CsTokenType.tkMINUS_EQ: case CsTokenType.tkDIV_EQ: case CsTokenType.tkMUL_EQ: string getter = ElementAccessHelper.parseElementAccess(ex.lhs, true, false, pCreator).Value; return(new Expression(string.Format(left.Value, getter + As3Helpers.ConvertTokens(Helpers.GetTokenType(convertToken(ex.oper))) + right.Value), pStatement.entity_typeref)); } } if ((ex.lhs is CsSimpleName) && left.InternalType) { switch (ex.oper) { case CsTokenType.tkASSIGN: return(new Expression(string.Format(left.Value, right.Value), pStatement.entity_typeref)); case CsTokenType.tkPLUS_EQ: case CsTokenType.tkMINUS_EQ: case CsTokenType.tkDIV_EQ: case CsTokenType.tkMUL_EQ: string getter = SimpleNameHelper.ParseSimpleName(ex.lhs, true, false).Value; return(new Expression(string.Format(left.Value, getter + As3Helpers.ConvertTokens(Helpers.GetTokenType(convertToken(ex.oper))) + right.Value), pStatement.entity_typeref)); } } if (ex.lhs is CsPrimaryExpressionMemberAccess) { if (ex.lhs.ec == expression_classification.ec_event_access) { CsEntityEvent ev = (CsEntityEvent)ex.lhs.entity; TheClass theClass = TheClassFactory.Get(ev.parent, pCreator); string eventName; //flash event on flash.xxxx if (theClass == null) { eventName = Helpers.GetEventFromAttr(ev.attributes); return(new Expression( left.Value + (ex.oper == CsTokenType.tkPLUS_EQ ? ("addEventListener(" + eventName + ", " + right.Value + ", false, 0, true)") : ("removeEventListener(" + eventName + ", " + right.Value + ")")) , pStatement.entity_typeref )); } TheEvent theEvent = theClass.GetEvent(ev.name); if (theEvent != null && string.IsNullOrEmpty(theEvent.EventName)) //custom event on the same class { return(new Expression( //event name == left => left IS the event name. Do not add twice left.Value + (ev.name.Equals(left.Value, StringComparison.Ordinal) ? string.Empty : ev.name) + (ex.oper == CsTokenType.tkPLUS_EQ ? ".add" : ".remove") + "(" + right.Value + ")" , pStatement.entity_typeref )); } eventName = theEvent == null?Helpers.GetEventFromAttr(ev.attributes) : theEvent.EventName; //flash event on the same class. return(new Expression( //event name == left => left IS the event name. Do not add twice (ev.name.Equals(left.Value, StringComparison.Ordinal) ? string.Empty : left.Value) + (ex.oper == CsTokenType.tkPLUS_EQ ? ("addEventListener(" + eventName + ", " + right.Value + ", false, 0, true)") : ("removeEventListener(" + eventName + ", " + right.Value + ")")) , pStatement.entity_typeref)); } //else { // left = FactoryExpressionCreator.Parse(ex.lhs); // CsPrimaryExpressionMemberAccess primaryExpressionMemberAccess = (CsPrimaryExpressionMemberAccess)ex.lhs; // TheClass theClass = TheClassFactory.Get((CsEntity)primaryExpressionMemberAccess.entity); // //TheProperty theProp = theClass.GetProperty(); //} } return(new Expression(string.Format("{0} {2} {1}", left.Value, right.Value, As3Helpers.ConvertTokens(Helpers.GetTokenType(ex.oper))), pStatement.entity_typeref)); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsLiteral li = (CsLiteral)pStatement; switch (li.type) { case CsTokenType.tkTRUE: return(new Expression("true", pStatement.entity_typeref)); case CsTokenType.tkFALSE: return(new Expression("false", pStatement.entity_typeref)); case CsTokenType.tkNULL: return(new Expression("null", pStatement.entity_typeref)); default: switch (li.literal_type) { case CsLiteralType.literal_int: return(new Expression(li.literal, pStatement.entity_typeref)); case CsLiteralType.literal_uint_U: return(new Expression(li.literal.Substring(0, li.literal.Length - 1), pStatement.entity_typeref)); case CsLiteralType.literal_uint: return(new Expression(li.literal, pStatement.entity_typeref)); case CsLiteralType.literal_long: return(new Expression(li.literal, pStatement.entity_typeref)); case CsLiteralType.literal_long_L: return(new Expression(li.literal.Substring(0, li.literal.Length - 1), pStatement.entity_typeref)); case CsLiteralType.literal_decimal_M: return(new Expression(li.literal, pStatement.entity_typeref)); case CsLiteralType.literal_ulong: case CsLiteralType.literal_ulong_L: case CsLiteralType.literal_ulong_UL: return(new Expression(li.literal, pStatement.entity_typeref)); case CsLiteralType.literal_double_D: case CsLiteralType.literal_double: return(new Expression(li.literal, pStatement.entity_typeref)); case CsLiteralType.literal_number: return(new Expression(li.literal, pStatement.entity_typeref)); case CsLiteralType.literal_float_F: return(new Expression(li.literal, pStatement.entity_typeref)); case CsLiteralType.literal_char: return(new Expression("'" + li.literal + "'", pStatement.entity_typeref)); case CsLiteralType.literal_verbatim_string: string l = li.literal.Substring(2, li.literal.Length - 3); return(l.StartsWith(@"rx:", StringComparison.Ordinal) ? new Expression(l.Substring(3, l.Length - 3), pStatement.entity_typeref) : new Expression(Helpers.EscapeString(l), pStatement.entity_typeref)); default: return(new Expression(Helpers.EscapeString(li.literal), pStatement.entity_typeref)); } } }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //__arglist ( "(" expresion-list ")" )? throw new NotImplementedException(); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //"(" expression ")" CsParenthesizedExpression ex = (CsParenthesizedExpression)pStatement; return new Expression("(" + pCreator.Parse(ex.expression).Value + ")", pStatement.entity_typeref); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsInvocationExpression ex = (CsInvocationExpression)pStatement; List<string> indexes = new List<string>(); if (ex.argument_list != null) { foreach (CsArgument argument in ex.argument_list.list) { indexes.Add(pCreator.Parse(argument.expression).Value); } } TheClass c = TheClassFactory.Get(pStatement, pCreator); TheMethod m; CsEntityMethod method = ex.entity as CsEntityMethod; CsEntityDelegate entityDelegate = ex.entity as CsEntityDelegate; string name = pCreator.Parse(ex.expression).Value; //call es de tipo super. Necesito saber cuál es la clase heredada) if (name.EndsWith("super.", StringComparison.Ordinal)) { c = c.Base; m = c.GetMethod(method, pCreator); name = name + m.Name; } else if (method != null) { //si es una expresión de tipo xx.yy.method(), tengo que revisar la expresión //porque la invocación se da como expresión completa... c = TheClassFactory.Get(method.parent, pCreator); m = c.GetMethod(method, pCreator); if (m.IsExtensionMethod) { int fnIndex = name.IndexOf(m.Name); if (fnIndex > 0) fnIndex--; indexes.Insert(0, name.Substring(0, fnIndex)); if (Helpers.HasAttribute(((CsEntityClass)method.parent).attributes, "JsExtensionAttribute")) { name = m.MyClass.FullName; name = name.Substring(0, name.LastIndexOf('.')); name = name + "."+m.Name; ImportStatementList.AddImport(name); name = m.Name; } else { name = m.FullName; } } else { name = name.Replace(m.Name, m.Name); } } else if (entityDelegate != null) { //es un evento? if (ex.expression.ec == expression_classification.ec_event_access) { TheEvent theEvent = c.GetEvent(name); name = theEvent.IsFlashEvent ? "dispatchEvent" : string.Format(@"if (_e{0}) _e{0}.fire", name); } } //patch if (name.Contains("{0}")) { string p = indexes[0]; indexes.RemoveAt(0); name = string.Format(name, p, string.Join(", ", indexes.ToArray())); } else { name = name + "(" + string.Join(", ", indexes.ToArray()) + ")"; } return new Expression( name, ex.entity_typeref ); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //from-clause query-body throw new NotImplementedException(); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //__refvalue "(" expresion "," type ")" throw new NotImplementedException(); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //object-creation-expression: //"new" type "(" ( argument_list )? ")" object-or-collection-initializer? //"new" type object-or-collection-initializer //delegate-creation-expression: //"new" delegate-type "(" expression ")" CsNewObjectExpression node = (CsNewObjectExpression)pStatement; StringBuilder sb = new StringBuilder(); string name = As3Helpers.Convert(Helpers.GetType(node.type)); bool isVector = name.StartsWith("Vector.<", StringComparison.Ordinal) && node.initializer != null; bool isArray = name.Equals("Array", StringComparison.Ordinal) && node.initializer != null; if (!isArray) { sb.Append("(new "); } if (isVector || isArray) { if (isVector) { int lb = name.IndexOf("<") + 1; sb.AppendFormat("<{0}>", name.Substring(lb, name.IndexOf(">") - lb)); } sb.Append("["); CsCollectionInitializer initializer = (CsCollectionInitializer)node.initializer; if (initializer.element_initializer_list != null) { List <string> args = new List <string>(); foreach (var csNode in initializer.element_initializer_list) { args.Add(pCreator.Parse(csNode).Value); } sb.Append(String.Join(", ", args.ToArray())); } } else { sb.AppendFormat("{0}(", name); if (node.argument_list != null) { List <string> args = new List <string>(); foreach (CsArgument argument in node.argument_list.list) { args.Add(pCreator.Parse(argument.expression).Value); } sb.Append(String.Join(", ", args.ToArray())); } } sb.Append(isVector || isArray ? "]" : ")"); if (!isArray) { sb.Append(")"); } return(new Expression( sb.ToString(), pStatement.entity_typeref )); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { // expression "->" identifier (type-argument-list?) throw new NotImplementedException(); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { return(SimpleNameHelper.ParseSimpleName(pStatement, false, false)); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //"delegate" (explicit-anonymous-function-signature)? block throw new NotImplementedException(); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { return(ElementAccessHelper.parseElementAccess(pStatement, false, false, pCreator)); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //CsThisAccess ex = (CsThisAccess)pExpression; return(new Expression("this", pStatement.entity_typeref)); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //CsThisAccess ex = (CsThisAccess)pExpression; return new Expression("this", pStatement.entity_typeref); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { // "base" "[" expression-list "]" CsBaseIndexerAccess indexerAccess = (CsBaseIndexerAccess) pStatement; return ElementAccessHelper.getIndexerExpression(indexerAccess, indexerAccess.expression_list.list, null, false, false, pCreator); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { return SimpleNameHelper.ParseSimpleName(pStatement, false, false); }
public TheConstructor GetConstructor(CsExpression pMethod) { return(GetConstructor((CsConstructor)((CsEntityMethod)pMethod.entity).decl)); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { CsInvocationExpression ex = (CsInvocationExpression)pStatement; List <string> indexes = new List <string>(); if (ex.argument_list != null) { foreach (CsArgument argument in ex.argument_list.list) { indexes.Add(pCreator.Parse(argument.expression).Value); } } TheClass c = TheClassFactory.Get(pStatement, pCreator); TheMethod m; CsEntityMethod method = ex.entity as CsEntityMethod; CsEntityDelegate entityDelegate = ex.entity as CsEntityDelegate; string name = pCreator.Parse(ex.expression).Value; //call es de tipo super. Necesito saber cuál es la clase heredada) if (name.EndsWith("super.", StringComparison.Ordinal)) { c = c.Base; m = c.GetMethod(method, pCreator); name = name + m.Name; } else if (method != null) { //si es una expresión de tipo xx.yy.method(), tengo que revisar la expresión //porque la invocación se da como expresión completa... c = TheClassFactory.Get(method.parent, pCreator); m = c.GetMethod(method, pCreator); if (m.IsExtensionMethod) { int fnIndex = name.IndexOf(m.Name); if (fnIndex > 0) { fnIndex--; } indexes.Insert(0, name.Substring(0, fnIndex)); if (Helpers.HasAttribute(((CsEntityClass)method.parent).attributes, "As3ExtensionAttribute")) { name = m.MyClass.FullName; name = name.Substring(0, name.LastIndexOf('.')); name = name + "." + m.Name; ImportStatementList.AddImport(name); name = m.Name; } else { name = m.FullName; } } else { name = name.Replace(m.Name, m.Name); } } else if (entityDelegate != null) { //es un evento? if (ex.expression.ec == expression_classification.ec_event_access) { TheEvent theEvent = c.GetEvent(name); name = theEvent.IsFlashEvent ? "dispatchEvent" : string.Format(@"if (_e{0}) _e{0}.fire", name); } } //patch if (name.Contains("{0}")) { string p = indexes[0]; indexes.RemoveAt(0); name = string.Format(name, p, string.Join(", ", indexes.ToArray())); } else { name = name + "(" + string.Join(", ", indexes.ToArray()) + ")"; } return(new Expression( name, ex.entity_typeref )); }
public Expression Parse(CsExpression pStatement, FactoryExpressionCreator pCreator) { //identifier "::" identifier (type-argument-list)? "." identifier (type-argument-list)? throw new NotImplementedException(); }