public void BadValue1() { NativeValueExpression expr = new NativeValueExpression("&&&"); Assert.True(expr.IsImmediateResolved); Assert.False(expr.IsParsable); }
public void Value3() { NativeValueExpression expr = new NativeValueExpression("FOO+BAR"); Assert.Equal(2, expr.Values.Count); Assert.Equal("FOO", expr.Values[0].DisplayValue); Assert.Equal("BAR", expr.Values[1].DisplayValue); }
public void Value4() { NativeValueExpression expr = new NativeValueExpression("\"bar\"+1"); Assert.Equal(2, expr.Values.Count); Assert.Equal(NativeValueKind.String, expr.Values[0].ValueKind); Assert.Equal("bar", expr.Values[0].DisplayValue); }
public void Value2() { NativeValueExpression expr = new NativeValueExpression("FOO+1"); Assert.Equal(2, expr.Values.Count); Assert.Equal("FOO", expr.Values[0].DisplayValue); Assert.Equal("FOO", expr.Values[0].Name); Assert.Null(expr.Values[0].SymbolValue); }
public void Value1() { NativeValueExpression expr = new NativeValueExpression("1+1"); Assert.Equal(2, expr.Values.Count); Assert.Equal(NativeValueKind.Number, expr.Values[0].ValueKind); Assert.Equal("1", expr.Values[0].DisplayValue); Assert.Equal(1, Convert.ToInt32(expr.Values[0].Value)); }
public void BadValue2() { NativeValueExpression expr = new NativeValueExpression("&&&"); Assert.True(expr.IsImmediateResolved); Assert.False(expr.IsParsable); Assert.Equal(0, expr.Values.Count); expr.Expression = "1+1"; Assert.True(expr.IsImmediateResolved); Assert.True(expr.IsParsable); Assert.Equal(2, expr.Values.Count); }
public void Value5() { NativeValueExpression expr = new NativeValueExpression("(DWORD)5"); Assert.Equal(2, expr.Values.Count); NativeValue val = expr.Values[0]; Assert.Equal(NativeValueKind.SymbolType, val.ValueKind); Assert.Equal("DWORD", val.DisplayValue); val = expr.Values[1]; Assert.Equal(NativeValueKind.Number, val.ValueKind); Assert.Equal(5, Convert.ToInt32(val.Value)); }
public static void VerifyExpression(LanguageType lang, string nativeExpr, string managedExpr, string managedType, NativeSymbolBag bag) { bag = bag ?? new NativeSymbolBag(); CodeTransform trans = new CodeTransform(lang, bag); NativeValueExpression nExpr = new NativeValueExpression(nativeExpr); CodeExpression cExpr = null; CodeTypeReference codeType = null; Exception ex = null; Assert.True(trans.TryGenerateValueExpression(nExpr, out cExpr, out codeType, out ex)); var provider = default(System.CodeDom.Compiler.CodeDomProvider); switch (lang) { case LanguageType.CSharp: provider = new Microsoft.CSharp.CSharpCodeProvider(); break; case LanguageType.VisualBasic: provider = new Microsoft.VisualBasic.VBCodeProvider(); break; default: provider = null; break; } Assert.NotNull(provider); using (var writer = new StringWriter()) { provider.GenerateCodeFromExpression(cExpr, writer, new System.CodeDom.Compiler.CodeGeneratorOptions()); Assert.Equal(managedExpr, writer.ToString()); } if (managedType != null) { Assert.Equal(managedType, CodeDomPrinter.Convert(codeType)); } }
public bool TryGenerateValueExpression(NativeValueExpression ntExpr, out CodeExpression expr, out CodeTypeReference exprType, out Exception ex) { try { if (!ntExpr.IsParsable) { string msg = "Expression is not parsable. Treating value as a raw string"; throw new InvalidOperationException(msg); } exprType = null; expr = GenerateValueExpressionImpl(ntExpr.Node, ref exprType); ex = null; return(true); } catch (Exception ex2) { ex = ex2; expr = null; exprType = null; return(false); } }
internal ExpressionSyntax GenerateExpression(NativeValueExpression expr) { return(_exprGenerator.GenerateValue(expr.Node)); }
/// <summary> /// Convert a NativeValueExpression into managed code and make it the initialization expression of /// the passed in member. /// /// If the code is unable to generate a valid expression for the member it will make the expression /// a stringized version of the original native expression. It will add information in the comments /// about why it could not properly generate the expression. Lastly it will generate incompatible types /// to force a compile error /// </summary> /// <param name="member"></param> /// <param name="ntExpr"></param> /// <returns></returns> /// <remarks></remarks> public bool GenerateInitExpression(CodeMemberField member, NativeSymbol target, NativeValueExpression ntExpr) { if (ntExpr == null) { member.Comments.Add(new CodeCommentStatement("Error: No value expression", true)); member.InitExpression = new CodePrimitiveExpression(string.Empty); member.Type = new CodeTypeReference(typeof(int)); return(false); } member.Comments.Add(new CodeCommentStatement(string.Format("{0} -> {1}", member.Name, ntExpr.Expression), true)); // It's not legal for a symbol to be used as part of it's initialization expression in most languages. // There for we need to mark it as the initialization member so the generated will output NULL in it's place _symbolValueMap.Add(target.Name, target); try { Exception ex = null; CodeExpression expr; CodeTypeReference typeRef; if (TryGenerateValueExpression(ntExpr, out expr, out typeRef, out ex)) { member.InitExpression = expr; member.Type = typeRef; return(true); } else { member.Comments.Add(new CodeCommentStatement(string.Format("Error generating expression: {0}", ex.Message), true)); member.InitExpression = new CodePrimitiveExpression(ntExpr.Expression); member.Type = new CodeTypeReference(typeof(string)); return(false); } } finally { _symbolValueMap.Remove(target.Name); } }