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);
}
}
