public static Number RedirectState(Object state, EvaluationCallback lhs, EvaluationCallback rhs)
{
Combat.Character character = state as Combat.Character;
if (character == null) return new Number();
Number result = rhs(state);
if (result.NumberType == NumberType.None) return new Number();
EvaluationCallback indexcallback = Get(lhs.Target.GetType())(lhs.Target) as EvaluationCallback;
if (indexcallback == null) return new Number();
Number varindex = indexcallback(state);
if (varindex.NumberType == NumberType.None) return new Number();
if (lhs.Target.GetType().Name == typeof(Var).Name)
{
if (character.Variables.SetInteger(varindex.IntValue, false, result.IntValue) == true) return result;
}
else if (lhs.Target.GetType().Name == typeof(FVar).Name)
{
if (character.Variables.SetFloat(varindex.IntValue, false, result.FloatValue) == true) return result;
}
else if (lhs.Target.GetType().Name == typeof(SysVar).Name)
{
if (character.Variables.SetInteger(varindex.IntValue, true, result.IntValue) == true) return result;
}
else if (lhs.Target.GetType().Name == typeof(SysFVar).Name)
{
if (character.Variables.SetFloat(varindex.IntValue, true, result.FloatValue) == true) return result;
}
return new Number();
}
public static Number RedirectState(Object state, EvaluationCallback lhs, EvaluationCallback rhs)
{
Combat.Character character = state as Combat.Character;
if (character == null)
{
return(new Number());
}
Number result = rhs(state);
if (result.NumberType == NumberType.None)
{
return(new Number());
}
EvaluationCallback indexcallback = Get(lhs.Target.GetType())(lhs.Target) as EvaluationCallback;
if (indexcallback == null)
{
return(new Number());
}
Number varindex = indexcallback(state);
if (varindex.NumberType == NumberType.None)
{
return(new Number());
}
if (lhs.Target.GetType().Name == typeof(Var).Name)
{
if (character.Variables.SetInteger(varindex.IntValue, false, result.IntValue) == true)
{
return(result);
}
}
else if (lhs.Target.GetType().Name == typeof(FVar).Name)
{
if (character.Variables.SetFloat(varindex.IntValue, false, result.FloatValue) == true)
{
return(result);
}
}
else if (lhs.Target.GetType().Name == typeof(SysVar).Name)
{
if (character.Variables.SetInteger(varindex.IntValue, true, result.IntValue) == true)
{
return(result);
}
}
else if (lhs.Target.GetType().Name == typeof(SysFVar).Name)
{
if (character.Variables.SetFloat(varindex.IntValue, true, result.FloatValue) == true)
{
return(result);
}
}
return(new Number());
}
/// <summary>
/// Initializes a <see cref="HazardousUsageEvaluator"/> that evaluates a return statement with a return value of the tracked type.
/// </summary>
/// <param name="evaluator">Evaluation callback.</param>
public HazardousUsageEvaluator(HazardousUsageEvaluatorKind kind, EvaluationCallback evaluator)
{
if (kind != HazardousUsageEvaluatorKind.Return && kind != HazardousUsageEvaluatorKind.Initialization)
{
throw new ArgumentException(
"kind must be Return or Initialization. Use other constructors for Invocation.",
nameof(kind));
}
Kind = kind;
ValueEvaluator = evaluator ?? throw new ArgumentNullException(nameof(evaluator));
}
/// <summary>
/// Initializes a <see cref="HazardousUsageEvaluator"/> that evaluates a return statement with a return value of the tracked type.
/// </summary>
/// <param name="evaluator">Evaluation callback.</param>
/// <param name="derivedClass">Whether to consider derived class.</param>
public HazardousUsageEvaluator(HazardousUsageEvaluatorKind kind, EvaluationCallback evaluator, bool derivedClass = false)
{
if (kind is not HazardousUsageEvaluatorKind.Return and not HazardousUsageEvaluatorKind.Initialization and not HazardousUsageEvaluatorKind.Argument)
{
throw new ArgumentException(
"kind must be Return or Initialization or Argument. Use other constructors for Invocation.",
nameof(kind));
}
Kind = kind;
DerivedClass = derivedClass;
ValueEvaluator = evaluator ?? throw new ArgumentNullException(nameof(evaluator));
}
public EvaluationCallback Create(Node node)
{
DynamicMethod method = new DynamicMethod(String.Empty, typeof(Number), new Type[] { typeof(Object) }, typeof(Compiler), true);
CompilerState compilerstate = new CompilerState();
compilerstate.Generator = method.GetILGenerator();
compilerstate.FunctionState = compilerstate.Generator.DeclareLocal(typeof(Object));
compilerstate.ErrorLabel = compilerstate.Generator.DefineLabel();
compilerstate.ErrorVariable = compilerstate.Generator.DeclareLocal(typeof(Boolean));
compilerstate.Generator.Emit(OpCodes.Ldarg, 0);
StoreLocalVariable(compilerstate, compilerstate.FunctionState);
LocalVariableInfo result = Emit(compilerstate, node);
if (result.LocalType == typeof(Int32))
{
LoadLocalVariable(compilerstate, result);
compilerstate.Generator.Emit(OpCodes.Newobj, typeof(Number).GetConstructor(new Type[] { typeof(Int32) }));
}
else if (result.LocalType == typeof(Single))
{
LoadLocalVariable(compilerstate, result);
compilerstate.Generator.Emit(OpCodes.Newobj, typeof(Number).GetConstructor(new Type[] { typeof(Single) }));
}
else
{
throw new Exception();
}
compilerstate.Generator.Emit(OpCodes.Ret);
compilerstate.Generator.MarkLabel(compilerstate.ErrorLabel);
LoadLocalVariable(compilerstate, compilerstate.Generator.DeclareLocal(typeof(Number)));
compilerstate.Generator.Emit(OpCodes.Ret);
EvaluationCallback callback = (EvaluationCallback)method.CreateDelegate(typeof(EvaluationCallback));
return(callback);
}
EvaluationCallback SingleFunctionBuild(Node node)
{
DynamicMethod method = new DynamicMethod(String.Empty, typeof(Number), new Type[] { typeof(Object) }, typeof(TreeCompiler));
ILGenerator generator = method.GetILGenerator();
foreach (Node n in EnumerateNodes(node))
{
if (n.Token.Data is Evaluation.Tokenizing.CustomFunctionData)
{
generator.Emit(OpCodes.Ldarg, 0);
}
}
SingleFunctionBuild(generator, node);
generator.Emit(OpCodes.Ret);
EvaluationCallback callback = (EvaluationCallback)method.CreateDelegate(typeof(EvaluationCallback));
return(callback);
}
/// <summary>
/// Initializes a <see cref="HazardousUsageEvaluator"/> that evaluates a method invocation with an argument of the type being tracked by PropertySetAnalysis.
/// </summary>
/// <param name="instanceTypeName">Name of the instance that the method is invoked on.</param>
/// <param name="methodName">Name of the method within <see cref="instanceTypeName"/>.</param>
/// <param name="parameterNameOfPropertySetObject">Name of the method parameter containing the type being tracked by PropertySetAnalysis.</param>
/// <param name="evaluator">Evaluation callback.</param>
public HazardousUsageEvaluator(string instanceTypeName, string methodName, string parameterNameOfPropertySetObject, EvaluationCallback evaluator)
{
InstanceTypeName = instanceTypeName ?? throw new ArgumentNullException(nameof(instanceTypeName));
MethodName = methodName ?? throw new ArgumentNullException(nameof(methodName));
ParameterNameOfPropertySetObject = parameterNameOfPropertySetObject ?? throw new ArgumentNullException(nameof(parameterNameOfPropertySetObject));
Evaluator = evaluator ?? throw new ArgumentNullException(nameof(evaluator));
}
/// <summary>
/// Initializes a <see cref="HazardousUsageEvaluator"/> that evaluates a method invocation on the type being tracked by PropertySetAnalysis.
/// </summary>
/// <param name="trackedTypeMethodName">Name of the method within the tracked type.</param>
/// <param name="evaluator">Evaluation callback.</param>
public HazardousUsageEvaluator(string trackedTypeMethodName, EvaluationCallback evaluator)
{
MethodName = trackedTypeMethodName ?? throw new ArgumentNullException(nameof(trackedTypeMethodName));
Evaluator = evaluator ?? throw new ArgumentNullException(nameof(evaluator));
}
EvaluationCallback NestedFunctionBuild(Node node)
{
if (node.Token.Data is Evaluation.Tokenizing.NumberData)
{
Number number = (node.Token.Data as Evaluation.Tokenizing.NumberData).GetNumber(node.Token.ToString());
return GetNumberCallback(number);
}
if (node.Token.Data is Evaluation.Tokenizing.RangeData)
{
Object[] args = new Object[node.Children.Count + node.Arguments.Count];
for (Int32 i = 0; i != node.Children.Count; ++i) args[i] = NestedFunctionBuild(node.Children[i]);
for (Int32 i = 0; i != node.Arguments.Count; ++i) args[i + node.Children.Count] = node.Arguments[i];
Constructor constructor = GetRangeConstructor();
IFunction function = (IFunction)constructor(args);
return function.Evaluate;
}
if (node.Token.AsOperator == Operator.Assignment)
{
Object[] args = new Object[node.Children.Count + node.Arguments.Count];
for (Int32 i = 0; i != node.Children.Count; ++i) args[i] = NestedFunctionBuild(node.Children[i]);
for (Int32 i = 0; i != node.Arguments.Count; ++i) args[i + node.Children.Count] = node.Arguments[i];
Constructor constructor = GetCustomFunctionConstructor("_Assignment", typeof(Evaluation.Triggers._Assignment), args);
IFunction function = (IFunction)constructor(args);
return function.Evaluate;
}
if (node.Token.AsOperator != Operator.None)
{
Constructor constructor = GetOperatorTypeConstructor(node.Token.Data as OperatorData);
EvaluationCallback[] childcallbacks;
if (node.Token.AsOperator == Operator.Minus && node.Children.Count == 1)
{
childcallbacks = new EvaluationCallback[2] { GetNumberCallback(new Number(0)), NestedFunctionBuild(node.Children[0]) };
}
else
{
childcallbacks = new EvaluationCallback[node.Children.Count];
for (Int32 i = 0; i != node.Children.Count; ++i) childcallbacks[i] = NestedFunctionBuild(node.Children[i]);
}
IFunction function = (IFunction)constructor(childcallbacks);
return function.Evaluate;
}
if (node.Token.Data is Evaluation.Tokenizing.CustomFunctionData)
{
Object[] args = new Object[node.Children.Count + node.Arguments.Count];
for (Int32 i = 0; i != node.Children.Count; ++i) args[i] = NestedFunctionBuild(node.Children[i]);
for (Int32 i = 0; i != node.Arguments.Count; ++i) args[i + node.Children.Count] = node.Arguments[i];
CustomFunctionData data = node.Token.Data as CustomFunctionData;
Constructor constructor = GetCustomFunctionConstructor(data.Name, data.Type, args);
IFunction function = (IFunction)constructor(args);
return function.Evaluate;
}
return null;
}
EvaluationCallback NestedFunctionBuild(Node node)
{
if (node.Token.Data is Evaluation.Tokenizing.NumberData)
{
Number number = (node.Token.Data as Evaluation.Tokenizing.NumberData).GetNumber(node.Token.ToString());
return(GetNumberCallback(number));
}
if (node.Token.Data is Evaluation.Tokenizing.RangeData)
{
Object[] args = new Object[node.Children.Count + node.Arguments.Count];
for (Int32 i = 0; i != node.Children.Count; ++i)
{
args[i] = NestedFunctionBuild(node.Children[i]);
}
for (Int32 i = 0; i != node.Arguments.Count; ++i)
{
args[i + node.Children.Count] = node.Arguments[i];
}
Constructor constructor = GetRangeConstructor();
IFunction function = (IFunction)constructor(args);
return(function.Evaluate);
}
if (node.Token.AsOperator == Operator.Assignment)
{
Object[] args = new Object[node.Children.Count + node.Arguments.Count];
for (Int32 i = 0; i != node.Children.Count; ++i)
{
args[i] = NestedFunctionBuild(node.Children[i]);
}
for (Int32 i = 0; i != node.Arguments.Count; ++i)
{
args[i + node.Children.Count] = node.Arguments[i];
}
Constructor constructor = GetCustomFunctionConstructor("_Assignment", typeof(Evaluation.Triggers._Assignment), args);
IFunction function = (IFunction)constructor(args);
return(function.Evaluate);
}
if (node.Token.AsOperator != Operator.None)
{
Constructor constructor = GetOperatorTypeConstructor(node.Token.Data as OperatorData);
EvaluationCallback[] childcallbacks;
if (node.Token.AsOperator == Operator.Minus && node.Children.Count == 1)
{
childcallbacks = new EvaluationCallback[2] {
GetNumberCallback(new Number(0)), NestedFunctionBuild(node.Children[0])
};
}
else
{
childcallbacks = new EvaluationCallback[node.Children.Count];
for (Int32 i = 0; i != node.Children.Count; ++i)
{
childcallbacks[i] = NestedFunctionBuild(node.Children[i]);
}
}
IFunction function = (IFunction)constructor(childcallbacks);
return(function.Evaluate);
}
if (node.Token.Data is Evaluation.Tokenizing.CustomFunctionData)
{
Object[] args = new Object[node.Children.Count + node.Arguments.Count];
for (Int32 i = 0; i != node.Children.Count; ++i)
{
args[i] = NestedFunctionBuild(node.Children[i]);
}
for (Int32 i = 0; i != node.Arguments.Count; ++i)
{
args[i + node.Children.Count] = node.Arguments[i];
}
CustomFunctionData data = node.Token.Data as CustomFunctionData;
Constructor constructor = GetCustomFunctionConstructor(data.Name, data.Type, args);
IFunction function = (IFunction)constructor(args);
return(function.Evaluate);
}
return(null);
}
