public static Type GetBuiltInType(string name, ExpressionLanguage language)
{
Require.NotNull(name, "name");
Type result;
switch (language)
{
case ExpressionLanguage.Flee:
FleeBuiltInTypes.TryGetValue(name, out result);
break;
case ExpressionLanguage.Csharp:
CsharpBuiltInTypes.TryGetValue(name, out result);
break;
case ExpressionLanguage.VisualBasic:
VisualBasicBuiltInTypes.TryGetValue(name, out result);
break;
default:
throw new ArgumentOutOfRangeException("language");
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicExpression"/>
/// class with the specified expression and language.
/// </summary>
/// <param name="expression">The expression to parse.</param>
/// <param name="language">The language of the expression to parse.</param>
public DynamicExpression(string expression, ExpressionLanguage language)
{
Require.NotNull(expression, "expression");
Expression = expression;
Language = language;
Cached = DynamicExpressionCache.GetOrCreateCachedDynamicExpression(expression, language);
}
public CachedDynamicExpression(ParseResult parseResult, ExpressionLanguage language)
{
Require.NotNull(parseResult, "parseResult");
_boundExpressionCache = new BoundExpressionCache(this);
ParseResult = parseResult;
Language = language;
}
public CachedDynamicExpression(ParseResult parseResult, ExpressionLanguage language)
{
Require.NotNull(parseResult, "parseResult");
_boundExpressionCache = new BoundExpressionCache(this);
ParseResult = parseResult;
Language = language;
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicExpression"/>
/// class with the specified expression and language.
/// </summary>
/// <param name="expression">The expression to parse.</param>
/// <param name="language">The language of the expression to parse.</param>
public DynamicExpression(string expression, ExpressionLanguage language)
{
Require.NotNull(expression, "expression");
Expression = expression;
Language = language;
Cached = DynamicExpressionCache.GetOrCreateCachedDynamicExpression(expression, language);
}
/// <summary>
/// Determines whether the specified language is a case sensitive language.
/// </summary>
/// <param name="language">The language to determine case sensitivity for.</param>
/// <returns>True when the specified language is case sensitive; false otherwise.</returns>
public static bool IsLanguageCaseSensitive(ExpressionLanguage language)
{
switch (language)
{
case ExpressionLanguage.Flee: return false;
case ExpressionLanguage.VisualBasic: return false;
case ExpressionLanguage.Csharp: return true;
default: throw new ArgumentOutOfRangeException("language");
}
}
/// <summary>
/// Determines whether the specified language is a case sensitive language.
/// </summary>
/// <param name="language">The language to determine case sensitivity for.</param>
/// <returns>True when the specified language is case sensitive; false otherwise.</returns>
public static bool IsLanguageCaseSensitive(ExpressionLanguage language)
{
switch (language)
{
case ExpressionLanguage.Flee: return(false);
case ExpressionLanguage.Csharp: return(true);
default: throw new ArgumentOutOfRangeException("language");
}
}
public static ParseResult ParseExpression(string expression, ExpressionLanguage language)
{
switch (language)
{
case ExpressionLanguage.Flee:
return(Flee.FleeParser.Parse(expression));
case ExpressionLanguage.Csharp:
return(Csharp.CsharpParser.Parse(expression));
default:
throw new ArgumentOutOfRangeException("language");
}
}
public static ParseResult ParseExpression(string expression, ExpressionLanguage language)
{
switch (language)
{
case ExpressionLanguage.Flee:
return Flee.FleeParser.Parse(expression);
case ExpressionLanguage.Csharp:
return Csharp.CsharpParser.Parse(expression);
case ExpressionLanguage.VisualBasic:
return VisualBasic.VisualBasicParser.Parse(expression);
default:
throw new ArgumentOutOfRangeException("language");
}
}
public static CachedDynamicExpression GetOrCreateCachedDynamicExpression(string expression, ExpressionLanguage language)
{
var key = new CacheKey(expression, language);
lock (_syncRoot)
{
CachedDynamicExpression cached;
if (!_cache.TryGetValue(key, out cached))
{
var parseResult = ParseExpression(expression, language);
cached = new CachedDynamicExpression(parseResult, language);
_cache.Add(key, cached);
}
return cached;
}
}
public ExpressionTests(ExpressionLanguage language)
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
Language = language;
MyValidExpressionsOwner = new ExpressionOwner();
MyGenericContext = this.CreateGenericContext(MyValidExpressionsOwner);
var imports = new[]
{
new Import(typeof(Monitor)),
new Import("Convert", typeof(Convert)),
new Import(typeof(Guid)),
new Import(typeof(Version)),
new Import(typeof(DayOfWeek)),
new Import("DayOfWeek", typeof(DayOfWeek)),
new Import(typeof(ValueType)),
new Import(typeof(IComparable)),
new Import(typeof(ICloneable)),
new Import(typeof(Array)),
new Import(typeof(Delegate)),
new Import(typeof(System.Text.Encoding)),
new Import(typeof(System.Text.ASCIIEncoding)),
new Import(typeof(ArgumentException))
};
ExpressionContext context = new ExpressionContext(imports, MyValidExpressionsOwner);
//context.Options.OwnerMemberAccess = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic;
MyValidCastsContext = context;
// For testing virtual properties
//TypeDescriptor.AddProvider(new UselessTypeDescriptionProvider(TypeDescriptor.GetProvider(typeof(int))), typeof(int));
//TypeDescriptor.AddProvider(new UselessTypeDescriptionProvider(TypeDescriptor.GetProvider(typeof(string))), typeof(string));
Initialize();
}
public static bool EvaluateArgs(string args, Player player,
ExpressionLanguage language = ExpressionLanguage.Csharp)
{
var expression = new DynamicExpression(args, language);
// Only create context once
if (player.Context == null)
{
player.Context = new ExpressionContext(null, player, true);
player.Context.Variables.Add("Player", player);
foreach (var spell in player.Spells.DistinctBy(s => s.Name))
{
player.Context.Variables.Add(spell.Name, spell);
}
}
var res = expression.Invoke(player.Context);
return((bool)res);
}
public ExpressionTests(ExpressionLanguage language)
{
Language = language;
MyValidExpressionsOwner = new ExpressionOwner();
MyGenericContext = this.CreateGenericContext(MyValidExpressionsOwner);
var imports = new[]
{
new Import(typeof(Monitor)),
new Import("Convert", typeof(Convert)),
new Import(typeof(Guid)),
new Import(typeof(Version)),
new Import(typeof(DayOfWeek)),
new Import("DayOfWeek", typeof(DayOfWeek)),
new Import(typeof(ValueType)),
new Import(typeof(IComparable)),
new Import(typeof(ICloneable)),
new Import(typeof(Array)),
new Import(typeof(System.Delegate)),
new Import(typeof(AppDomainInitializer)),
new Import(typeof(System.Text.Encoding)),
new Import(typeof(System.Text.ASCIIEncoding)),
new Import(typeof(ArgumentException))
};
ExpressionContext context = new ExpressionContext(imports, MyValidExpressionsOwner);
//context.Options.OwnerMemberAccess = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic;
MyValidCastsContext = context;
// For testing virtual properties
//TypeDescriptor.AddProvider(new UselessTypeDescriptionProvider(TypeDescriptor.GetProvider(typeof(int))), typeof(int));
//TypeDescriptor.AddProvider(new UselessTypeDescriptionProvider(TypeDescriptor.GetProvider(typeof(string))), typeof(string));
Initialize();
}
protected BulkTests(ExpressionLanguage language)
: base(language)
{
}
/// <summary>
/// Constructor for an expression language
/// </summary>
/// <param name="language"></param>
public ExpressionEvaluator(ExpressionLanguage language)
{
m_language = language;
}
/// <summary>
/// Delegate Factory for a Language
/// </summary>
/// <param name="language"></param>
public ExpressionDelegateFactory(ExpressionLanguage language)
{
m_language = language;
}
/// <summary>
/// Constructor for an expression language
/// </summary>
/// <param name="language"></param>
public CodeCompiler(ExpressionLanguage language)
{
m_language = language;
}
public static Type GetBuiltInType(string name, ExpressionLanguage language)
{
Require.NotNull(name, "name");
Type result;
switch (language)
{
case ExpressionLanguage.Flee:
FleeBuiltInTypes.TryGetValue(name, out result);
break;
case ExpressionLanguage.Csharp:
CsharpBuiltInTypes.TryGetValue(name, out result);
break;
case ExpressionLanguage.VisualBasic:
VisualBasicBuiltInTypes.TryGetValue(name, out result);
break;
default:
throw new ArgumentOutOfRangeException("language");
}
return result;
}
public CacheKey(string expression, ExpressionLanguage language)
{
_expression = expression;
_language = language;
}
public CacheKey(string expression, ExpressionLanguage language)
{
_expression = expression;
_language = language;
}
/// <summary>
/// Checks the syntax of the specified expression.
/// </summary>
/// <param name="expression">The expression of which to check the syntax.</param>
/// <param name="language">The language used when checking the syntax.</param>
public static void CheckSyntax(string expression, ExpressionLanguage language)
{
Require.NotEmpty(expression, "expression");
DynamicExpressionCache.ParseExpression(expression, language);
}
public static CachedDynamicExpression GetOrCreateCachedDynamicExpression(string expression, ExpressionLanguage language)
{
var key = new CacheKey(expression, language);
lock (_syncRoot)
{
CachedDynamicExpression cached;
if (!_cache.TryGetValue(key, out cached))
{
var parseResult = ParseExpression(expression, language);
cached = new CachedDynamicExpression(parseResult, language);
_cache.Add(key, cached);
}
return(cached);
}
}
protected BulkTests(ExpressionLanguage language)
: base(language)
{
}
/// <summary>
/// Checks the syntax of the specified expression.
/// </summary>
/// <param name="expression">The expression of which to check the syntax.</param>
/// <param name="language">The language used when checking the syntax.</param>
public static void CheckSyntax(string expression, ExpressionLanguage language)
{
Require.NotEmpty(expression, "expression");
DynamicExpressionCache.ParseExpression(expression, language);
}
