public static string Convert(CodeExpression expr) { CodePrimitiveExpression primitiveExpr = expr as CodePrimitiveExpression; if (primitiveExpr != null) { return(primitiveExpr.Value.ToString()); } CodeFieldReferenceExpression fieldExpr = expr as CodeFieldReferenceExpression; if (fieldExpr != null) { return(string.Format("{0}.{1}", Convert(fieldExpr.TargetObject), fieldExpr.FieldName)); } CodeTypeReferenceExpression typeExpr = expr as CodeTypeReferenceExpression; if (typeExpr != null) { return(ConvertNoNamespace(typeExpr.Type)); } CodeBinaryOperatorExpression opExpr = expr as CodeBinaryOperatorExpression; if (opExpr != null) { return(string.Format("{0}({1})({2})", opExpr.Operator, Convert(opExpr.Left), Convert(opExpr.Right))); } return(expr.ToString()); }
private static string GetExpression(CodeExpression expr) { if (expr is CodeFieldReferenceExpression expression) { return(expression.FieldName); } if (expr is CodePropertyReferenceExpression expression1) { return(expression1.PropertyName); } if (expr is CodeMethodReferenceExpression cmre) { return(cmre.MethodName); } if (expr is CodePrimitiveExpression cpe) { return(cpe.Value.ToString()); } return(expr.ToString()); }
private static string getExpression(CodeExpression expr) { if (expr is CodeFieldReferenceExpression) { return(((CodeFieldReferenceExpression)expr).FieldName); } if (expr is CodePropertyReferenceExpression) { return(((CodePropertyReferenceExpression)expr).PropertyName); } if (expr is CodeMethodReferenceExpression) { return(((CodeMethodReferenceExpression)expr).MethodName); } if (expr is CodePrimitiveExpression) { return(((CodePrimitiveExpression)expr).Value.ToString()); } return(expr.ToString()); }
internal static void GenerateCodeFromExpression(CodeExpression e, TextWriter w, CodeGeneratorOptions o) { if (e == null) { return; } var argumentReferenceExpression = e as CodeArgumentReferenceExpression; if (argumentReferenceExpression != null) { w.Write(argumentReferenceExpression.ParameterName); return; } if (WriteCodeArrayCreateExpression(e as CodeArrayCreateExpression, w, o)) { return; } if (WriteCodeArrayIndexerExpression(e as CodeArrayIndexerExpression, w, o)) { return; } var baseReferenceExpression = e as CodeBaseReferenceExpression; if (baseReferenceExpression != null) { w.Write("super"); return; } if (WriteCodeBinaryOperatorExpression(e as CodeBinaryOperatorExpression, w, o)) { return; } if (WriteCodeFieldReferenceExpression(e as CodeFieldReferenceExpression, w, o)) { return; } if (WriteCodeIndexerExpression(e as CodeIndexerExpression, w, o)) { return; } if (WriteCodeMethodInvokeExpression(e as CodeMethodInvokeExpression, w, o)) { return; } var methodReferenceExpression = e as CodeMethodReferenceExpression; if (methodReferenceExpression != null) { WriteCodeMethodReferenceExpression(methodReferenceExpression, w, o); return; } if (WriteCodeObjectCreateExpression(e as CodeObjectCreateExpression, w, o)) { return; } var parameterDeclarationExpression = e as CodeParameterDeclarationExpression; if (parameterDeclarationExpression != null) { w.Write($"{parameterDeclarationExpression.Name}: {TypeMapper.MapCodeTypeReferenceToTsText(parameterDeclarationExpression.Type)}"); return; } if (WriteCodePrimitiveExpression(e as CodePrimitiveExpression, w)) { return; } if (WriteCodePropertyReferenceExpression(e as CodePropertyReferenceExpression, w, o)) { return; } var snippetExpression = e as CodeSnippetExpression; if (snippetExpression != null) { w.Write(snippetExpression.Value); return; } var thisReferenceExpression = e as CodeThisReferenceExpression; if (thisReferenceExpression != null) { w.Write("this"); return; } var typeOfExpression = e as CodeTypeOfExpression; if (typeOfExpression != null) { w.Write("typeof " + TypeMapper.MapCodeTypeReferenceToTsText(typeOfExpression.Type)); return; } var typeReferenceExpression = e as CodeTypeReferenceExpression; if (typeReferenceExpression != null) { w.Write(TypeMapper.MapCodeTypeReferenceToTsText(typeReferenceExpression.Type)); return; } var variableReferenceExpression = e as CodeVariableReferenceExpression; if (variableReferenceExpression != null) { w.Write(variableReferenceExpression.VariableName); return; } Trace.TraceWarning($"CodeExpression not supported: {e.ToString()}"); }
/// <summary> /// knowing the code is of different type, make conversion code /// </summary> /// <param name="sourceValue"></param> /// <param name="targetType"></param> /// <param name="csc"></param> /// <returns></returns> static CodeExpression CodeExpConvertTo(CodeExpression sourceCode, Type sourceType, Type targetType, CodeStatementCollection supprtStatements) { if (targetType.Equals(typeof(void))) { if (sourceCode == null) { MathNode.Trace("code 00: target type is void. Input code is null. Return null for code."); } else { MathNode.Trace("code 00: target type is void. Input code becomes a statement (0). Return null for code.", sourceCode.ToString()); supprtStatements.Add(new CodeExpressionStatement(sourceCode)); } return(null); } CodeExpression codeRet; TypeConverter converter = TypeDescriptor.GetConverter(targetType); if (converter.CanConvertFrom(sourceType)) { MathNode.AddImportLocation(typeof(TypeConverter).Assembly.Location); string converterName = "conv" + targetType.Name; if (!MathNodeVariable.VariableDeclared(supprtStatements, converterName)) { CodeVariableDeclarationStatement cs1 = new CodeVariableDeclarationStatement( typeof(TypeConverter), converterName, new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(typeof(TypeDescriptor)), "GetConverter", new CodeExpression[] { new CodeSnippetExpression("typeof(" + targetType.FullName + ")") })); supprtStatements.Add(cs1); } //================================================= codeRet = new CodeCastExpression(targetType, new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(converterName), "ConvertFrom", new CodeExpression[] { sourceCode })); MathNode.Trace("code 2: source type:{0}, target type:{1} result=converter.ConvertFrom(code);", sourceType, targetType); } else { if (sourceCode is CodePrimitiveExpression) { CodePrimitiveExpression codep = sourceCode as CodePrimitiveExpression; if (targetType.Equals(typeof(string))) { if (codep.Value == null) { codeRet = new CodeCastExpression(targetType, sourceCode); MathNode.Trace("code 3: source type:{0}, target type:{1} result=null;", sourceType, targetType); } else { if (codep.Value is string) { codeRet = sourceCode; // MathNode.Trace("code 4: source type:{0}, target type:{1} result=code;", sourceType, targetType); } else { codeRet = new CodeMethodInvokeExpression(sourceCode, "ToString", new CodeExpression[] { }); MathNode.Trace("code 5: source type:{0}, target type:{1} result=code.ToString();", sourceType, targetType); } } } else //none-string primative { codeRet = new CodeCastExpression(targetType, sourceCode); MathNode.Trace("code 6: source type:{0}, target type:{1}, result=({1})code;", sourceType, targetType); } } else { if (sourceType.Equals(typeof(void))) { codeRet = null; if (sourceCode == null) { MathNode.Trace("code 7a: source type:{0}, target type:{1} code is null;", sourceType, targetType); } else { supprtStatements.Add(new CodeExpressionStatement(sourceCode)); MathNode.Trace("code 7: source type:{0}, target type: {1}. code used as a statement; return null as CodeExpression.", sourceType, targetType); } } else if (targetType.Equals(typeof(string))) { codeRet = new CodeMethodInvokeExpression(sourceCode, "ToString", new CodeExpression[] { }); MathNode.Trace("code 8: source type:{0}, target type:{1} result=code.ToString();", sourceType, targetType); } else { //check to see if casting can be done codeRet = new CodeCastExpression(targetType, sourceCode); MathNode.Trace("code 9: source type:{0}, target type:{1}. cast it: result=({1})code;", sourceType, targetType); } } } return(codeRet); }