public static void Load(int factPriority = FactPriority)
{
LoadPostFactorial(factPriority);
numE = new CalcNumber((decimal)Math.E);
numPI = new CalcNumber((decimal)Math.PI);
E = new CLCodeFunction("e", (pars, vars, context) => numE);
PI = new CLCodeFunction("pi", (pars, vars, context) => numPI);
Abs = new CLCodeFunction("abs", AbsFunction);
Acos = new CLCodeFunction("acos", AcosFunction);
Acosh = new CLCodeFunction("acosh", AcoshFunction);
Asin = new CLCodeFunction("asin", AsinFunction);
Asinh = new CLCodeFunction("asinh", AsinhFunction);
Atan = new CLCodeFunction("atan", AtanFunction);
Atan2 = new CLCodeFunction("atan2", Atan2Function);
Atanh = new CLCodeFunction("atanh", AtanhFunction);
Cos = new CLCodeFunction("cos", CosFunction);
Cosh = new CLCodeFunction("cosh", CoshFunction);
Sin = new CLCodeFunction("sin", SinFunction);
Sinh = new CLCodeFunction("sinh", SinhFunction);
Tan = new CLCodeFunction("tan", TanFunction);
Tanh = new CLCodeFunction("tanh", TanhFunction);
Ceiling = new CLCodeFunction("ceiling", CeilingFunction);
CopySign = new CLCodeFunction("copysign", CopySignFunction);
Floor = new CLCodeFunction("floor", FloorFunction);
Log = new CLCodeFunction("log", LogFunction);
Max = new CLCodeFunction("max", MaxFunction);
MaxMagnitude = new CLCodeFunction("maxmagnitude", MaxMagnitudeFunction);
Min = new CLCodeFunction("min", MinFunction);
MinMagnitude = new CLCodeFunction("minmagnitude", MinMagnitudeFunction);
Sign = new CLCodeFunction("sign", SignFunction);
}
/// <summary>
/// Creates a new <c>CalcCodeFunction</c>.
/// </summary>
/// <param name="name">The name of the function to call.</param>
/// <param name="pars">The parameters for the called function.</param>
public CalcCodeFunction(string name, CalcObject[] pars)
{
Function = CLCodeFunction.Get(name);
Params = pars;
}
public static void Load()
{
// First we need some local types
Type num = typeof(CalcNumber);
Type lst = typeof(CalcList);
Type val = typeof(CalcValue);
Type obj = typeof(CalcObject);
// The binary "d" operator.
BinaryDice = CLOperators.BinaryOperators.GetOrNull("d") ?? new CLBinaryOperator("d", DicePriority, true, true);
BinaryDice.AddFunction(num, num, BinDice);
BinaryDice.AddFunction(num, lst, BinDice);
BinaryDice.AddFunction(lst, num, (left, right, vars, context) => BinDice(ListToNum(left), right, vars, context));
BinaryDice.AddFunction(lst, lst, (left, right, vars, context) => BinDice(ListToNum(left), right, vars, context));
// The prefix "d" operator.
PrefixDie = CLOperators.PrefixOperators.GetOrNull("d") ?? new CLPrefixOperator("d", DicePriority, true);
PrefixDie.AddFunction(num, (oper, vars, context) => ((CalcList)BinDice(new CalcNumber(1), oper, vars, context))[0]);
PrefixDie.AddFunction(lst, (oper, vars, context) => ((CalcList)BinDice(new CalcNumber(1), oper, vars, context))[0]);
// The comparison "u" operator.
ComparisonUntil = (CLOperators.BinaryOperators.GetOrNull("u=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("u", DicePriority, true, true);
ComparisonUntil.AddFunction(num, num, CompUntil);
ComparisonUntil.AddFunction(lst, num, CompUntil);
ComparisonUntil.AddFunction(num, lst, (left, comp, right, vars, context) => CompUntil(left, comp, ListToNum(right), vars, context));
ComparisonUntil.AddFunction(lst, lst, (left, comp, right, vars, context) => CompUntil(left, comp, ListToNum(right), vars, context));
// The binary "r" operator.
BinaryReroll = (CLOperators.BinaryOperators.GetOrNull("r")) ?? new CLBinaryOperator("r", RerollPriority, true, true);
BinaryReroll.AddFunction(num, num, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, right, vars, context, false, false));
BinaryReroll.AddFunction(lst, num, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, right, vars, context, false, false));
BinaryReroll.AddFunction(num, lst, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, ListToNum(right), vars, context, false, false));
BinaryReroll.AddFunction(lst, lst, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, ListToNum(right), vars, context, false, false));
// The binary "x" operator.
BinaryExplode = (CLOperators.BinaryOperators.GetOrNull("x")) ?? new CLBinaryOperator("x", RerollPriority, true, true);
BinaryExplode.AddFunction(num, num, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, right, vars, context, true, false));
BinaryExplode.AddFunction(lst, num, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, right, vars, context, true, false));
BinaryExplode.AddFunction(num, lst, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, ListToNum(right), vars, context, true, false));
BinaryExplode.AddFunction(lst, lst, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, ListToNum(right), vars, context, true, false));
// The binary "xr" operator.
BinaryExplodeRecursive = (CLOperators.BinaryOperators.GetOrNull("xr")) ?? new CLBinaryOperator("xr", RerollPriority, true, true);
BinaryExplodeRecursive.AddFunction(num, num, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, right, vars, context, true, true));
BinaryExplodeRecursive.AddFunction(lst, num, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, right, vars, context, true, true));
BinaryExplodeRecursive.AddFunction(num, lst, (left, right, vars, context) => CompRerolls(ValToList(left), CLComparison.Equal, ListToNum(right), vars, context, true, true));
BinaryExplodeRecursive.AddFunction(lst, lst, (left, right, vars, context) => CompRerolls(left, CLComparison.Equal, ListToNum(right), vars, context, true, true));
// The comparison "r" operator.
ComparisonReroll = (CLOperators.BinaryOperators.GetOrNull("r=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("r", RerollPriority, true, true);
ComparisonReroll.AddFunction(num, num, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, right, vars, context, false, false));
ComparisonReroll.AddFunction(lst, num, (left, comp, right, vars, context) => CompRerolls(left, comp, right, vars, context, false, false));
ComparisonReroll.AddFunction(num, lst, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, ListToNum(right), vars, context, false, false));
ComparisonReroll.AddFunction(lst, lst, (left, comp, right, vars, context) => CompRerolls(left, comp, ListToNum(right), vars, context, false, false));
// The comparison "x" operator.
ComparisonExplode = (CLOperators.BinaryOperators.GetOrNull("x=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("x", RerollPriority, true, true);
ComparisonExplode.AddFunction(num, num, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, right, vars, context, true, false));
ComparisonExplode.AddFunction(lst, num, (left, comp, right, vars, context) => CompRerolls(left, comp, right, vars, context, true, false));
ComparisonExplode.AddFunction(num, lst, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, ListToNum(right), vars, context, true, false));
ComparisonExplode.AddFunction(lst, lst, (left, comp, right, vars, context) => CompRerolls(left, comp, ListToNum(right), vars, context, true, false));
// The comparison "xr" operator.
ComparisonExplodeRecursive = (CLOperators.BinaryOperators.GetOrNull("xr=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("xr", RerollPriority, true, true);
ComparisonExplodeRecursive.AddFunction(num, num, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, right, vars, context, true, true));
ComparisonExplodeRecursive.AddFunction(lst, num, (left, comp, right, vars, context) => CompRerolls(left, comp, right, vars, context, true, true));
ComparisonExplodeRecursive.AddFunction(num, lst, (left, comp, right, vars, context) => CompRerolls(ValToList(left), comp, ListToNum(right), vars, context, true, true));
ComparisonExplodeRecursive.AddFunction(lst, lst, (left, comp, right, vars, context) => CompRerolls(left, comp, ListToNum(right), vars, context, true, true));
// The binary "k" operator.
BinaryKeep = CLOperators.BinaryOperators.GetOrNull("k") ?? new CLBinaryOperator("k", KeepPriority, true, true);
BinaryKeep.AddFunction(num, num, (left, right, vars, context) => KeepDropProxy(ValToList(left), right, true, true, vars));
BinaryKeep.AddFunction(lst, num, (left, right, vars, context) => KeepDropProxy(left, right, true, true, vars));
BinaryKeep.AddFunction(num, lst, (left, right, vars, context) => KeepDropProxy(ValToList(left), ListToNum(right), true, true, vars));
BinaryKeep.AddFunction(lst, lst, (left, right, vars, context) => KeepDropProxy(left, ListToNum(right), true, true, vars));
// The binary "kh" operator.
BinaryKeepHigh = CLOperators.BinaryOperators.GetOrNull("kh") ?? new CLBinaryOperator("kh", KeepPriority, true, true);
BinaryKeepHigh.AddFunction(num, num, (left, right, vars, context) => KeepDropProxy(ValToList(left), right, true, true, vars));
BinaryKeepHigh.AddFunction(lst, num, (left, right, vars, context) => KeepDropProxy(left, right, true, true, vars));
BinaryKeepHigh.AddFunction(num, lst, (left, right, vars, context) => KeepDropProxy(ValToList(left), ListToNum(right), true, true, vars));
BinaryKeepHigh.AddFunction(lst, lst, (left, right, vars, context) => KeepDropProxy(left, ListToNum(right), true, true, vars));
// The binary "kl" operator.
BinaryKeepLow = CLOperators.BinaryOperators.GetOrNull("kl") ?? new CLBinaryOperator("kl", KeepPriority, true, true);
BinaryKeepLow.AddFunction(num, num, (left, right, vars, context) => KeepDropProxy(ValToList(left), right, true, false, vars));
BinaryKeepLow.AddFunction(lst, num, (left, right, vars, context) => KeepDropProxy(left, right, true, false, vars));
BinaryKeepLow.AddFunction(num, lst, (left, right, vars, context) => KeepDropProxy(ValToList(left), ListToNum(right), true, false, vars));
BinaryKeepLow.AddFunction(lst, lst, (left, right, vars, context) => KeepDropProxy(left, ListToNum(right), true, false, vars));
// The binary "dh" operator.
BinaryDropHigh = CLOperators.BinaryOperators.GetOrNull("dh") ?? new CLBinaryOperator("dh", KeepPriority, true, true);
BinaryDropHigh.AddFunction(num, num, (left, right, vars, context) => KeepDropProxy(ValToList(left), right, false, true, vars));
BinaryDropHigh.AddFunction(lst, num, (left, right, vars, context) => KeepDropProxy(left, right, false, true, vars));
BinaryDropHigh.AddFunction(num, lst, (left, right, vars, context) => KeepDropProxy(ValToList(left), ListToNum(right), false, true, vars));
BinaryDropHigh.AddFunction(lst, lst, (left, right, vars, context) => KeepDropProxy(left, ListToNum(right), false, true, vars));
// The binary "dl" operator.
BinaryDropLow = CLOperators.BinaryOperators.GetOrNull("dl") ?? new CLBinaryOperator("dl", KeepPriority, true, true);
BinaryDropLow.AddFunction(num, num, (left, right, vars, context) => KeepDropProxy(ValToList(left), right, false, false, vars));
BinaryDropLow.AddFunction(lst, num, (left, right, vars, context) => KeepDropProxy(left, right, false, false, vars));
BinaryDropLow.AddFunction(num, lst, (left, right, vars, context) => KeepDropProxy(ValToList(left), ListToNum(right), false, false, vars));
BinaryDropLow.AddFunction(lst, lst, (left, right, vars, context) => KeepDropProxy(left, ListToNum(right), false, false, vars));
// The comparison "k" operator.
ComparisonKeep = (CLOperators.BinaryOperators.GetOrNull("k=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("k", KeepPriority, true, true);
ComparisonKeep.AddFunction(num, num, (left, comp, right, vars, context) => KeepCompare(ValToList(left), comp, right, vars));
ComparisonKeep.AddFunction(lst, num, (left, comp, right, vars, context) => KeepCompare(left, comp, right, vars));
ComparisonKeep.AddFunction(num, lst, (left, comp, right, vars, context) => KeepCompare(ValToList(left), comp, ListToNum(right), vars));
ComparisonKeep.AddFunction(lst, lst, (left, comp, right, vars, context) => KeepCompare(left, comp, ListToNum(right), vars));
// The comparison "d" operator.
ComparisonDrop = (CLOperators.BinaryOperators.GetOrNull("d=") as CLComparisonOperator)?.Parent ?? new CLComparisonOperatorSet("d", KeepPriority, true, true);
ComparisonDrop.AddFunction(num, num, (left, comp, right, vars, context) => KeepCompare(ValToList(left), comp.Opposite, right, vars));
ComparisonDrop.AddFunction(lst, num, (left, comp, right, vars, context) => KeepCompare(left, comp.Opposite, right, vars));
ComparisonDrop.AddFunction(num, lst, (left, comp, right, vars, context) => KeepCompare(ValToList(left), comp.Opposite, ListToNum(right), vars));
ComparisonDrop.AddFunction(lst, lst, (left, comp, right, vars, context) => KeepCompare(left, comp.Opposite, ListToNum(right), vars));
// The binary "**" operator.
BinaryRepeat = CLOperators.BinaryOperators.GetOrNull("**") ?? new CLBinaryOperator("**", RepeatPriority, false, true);
BinaryRepeat.AddFunction(obj, num, BinRepeat);
BinaryRepeat.AddFunction(obj, lst, (left, right, vars, context) => BinRepeat(left, ListToNum(right), vars, context));
// The "!die" function
FuncDie = new CLCodeFunction("die", FunctionDie);
}
/// <summary>
/// Returns the object referenced by the name.
/// </summary>
/// <param name="vars">A <c>CLLocalStore</c> that stores local
/// variables.</param>
/// <param name="context">The object representing the context in which
/// the expression is being evaluated.</param>
public CalcObject GetObject(CLLocalStore vars = null, CLContextProvider context = null)
{
vars ??= new CLLocalStore();
context ??= new CLContextProvider();
if (Name.StartsWith("!"))
{
if (CLCodeFunction.Exists(Name.Substring(1)))
{
return(new CalcCodeFunction(Name.Substring(1), Params));
}
}
if (Name.StartsWith("_") || Name.StartsWith("^"))
{
if (!(vars.ContainsVar(Name)))
{
throw new CLException("No variable named " + Name + " exists.");
}
else
{
return(vars[Name]);
}
}
int count = 0;
if (Int32.TryParse(Name, out count))
{
if (count == 0)
{
return(new CalcString(Name));
}
if (vars.ParamCount >= count)
{
return(vars[count - 1]);
}
else if (Params.Length > 0)
{
return(Params[0]);
}
else
{
throw new CLException("No parameter #" + count + " exists.");
}
}
if (Name == "...")
{
return(new CalcListExpression(vars.CopyParams()));
}
CalcObject ret = CLVariables.Load(Name, context);
if (ret != null)
{
return(ret);
}
throw new CLException("No variable named " + Name + " exists.");
}
