/**
* Retrieves a single value from a variety of different argument types according to standard
* Excel rules. Does not perform any type conversion.
* @param arg the Evaluated argument as passed to the function or operator.
* @param srcCellRow used when arg Is a single column AreaRef
* @param srcCellCol used when arg Is a single row AreaRef
* @return a <tt>NumberEval</tt>, <tt>StringEval</tt>, <tt>BoolEval</tt> or <tt>BlankEval</tt>.
* Never <c>null</c> or <tt>ErrorEval</tt>.
* @throws EvaluationException(#VALUE!) if srcCellRow or srcCellCol do not properly index into
* an AreaEval. If the actual value retrieved Is an ErrorEval, a corresponding
* EvaluationException Is thrown.
*/
public static ValueEval GetSingleValue(Eval arg, int srcCellRow, short srcCellCol)
{
Eval result;
if (arg is RefEval)
{
result = ((RefEval)arg).InnerValueEval;
}
else if (arg is AreaEval)
{
result = ChooseSingleElementFromArea((AreaEval)arg, srcCellRow, srcCellCol);
}
else
{
result = arg;
}
if (result is ErrorEval)
{
throw new EvaluationException((ErrorEval)result);
}
if (result is ValueEval)
{
return (ValueEval)result;
}
throw new Exception("Unexpected eval type (" + result.GetType().Name + ")");
}
public ValueEval Evaluate(Eval[] args, EvaluationWorkbook workbook, int srcCellSheet, int srcCellRow,
int srcCellCol)
{
double result;
try
{
int basis = 0; // default
switch (args.Length)
{
case 3:
basis = EvaluateIntArg(args[2], srcCellRow, srcCellCol);
break;
case 2:
basis = EvaluateIntArg(args[2], srcCellRow, srcCellCol);
break;
default:
return ErrorEval.VALUE_INVALID;
}
double startDateVal = EvaluateDateArg(args[0], srcCellRow, srcCellCol);
double endDateVal = EvaluateDateArg(args[1], srcCellRow, srcCellCol);
result = YearFracCalculator.Calculate(startDateVal, endDateVal, basis);
}
catch (EvaluationException e)
{
return e.GetErrorEval();
}
return new NumberEval(result);
}
public Eval Evaluate(Eval[] args, int srcCellRow, short srcCellCol)
{
switch (args.Length)
{
default:
return ErrorEval.VALUE_INVALID;
case 1:
break;
}
Eval arg = args[0];
if (arg is RefEval)
{
RefEval re = (RefEval)arg;
arg = re.InnerValueEval;
}
if (arg is StringEval)
{
// Text values are returned Unmodified
return arg;
}
if (arg is ErrorEval)
{
// Error values also returned Unmodified
return arg;
}
// for all other argument types the result Is empty string
return StringEval.EMPTY_INSTANCE;
}
public Eval Evaluate(Eval[] args, int srcCellRow, short srcCellCol)
{
if (args.Length != 1)
{
return ErrorEval.VALUE_INVALID;
}
double d;
try
{
ValueEval ve = OperandResolver.GetSingleValue(args[0], srcCellRow, srcCellCol);
if (ve is BlankEval)
{
return NumberEval.ZERO;
}
if (ve is StringEval)
{
// Note - asymmetric with UnaryMinus
// -"hello" Evaluates to #VALUE!
// but +"hello" Evaluates to "hello"
return ve;
}
d = OperandResolver.CoerceValueToDouble(ve);
}
catch (EvaluationException e)
{
return e.GetErrorEval();
}
return new NumberEval(+d);
}
/**
* Replaces part of a text string based on the number of Chars
* you specify, with another text string.
*
* @see org.apache.poi.hssf.record.formula.eval.Eval
*/
public override ValueEval EvaluateFunc(Eval[] args, int srcCellRow, short srcCellCol)
{
if (args.Length != 4)
{
return ErrorEval.VALUE_INVALID;
}
String oldStr = EvaluateStringArg(args[0], srcCellRow, srcCellCol);
int startNum = EvaluateIntArg(args[1], srcCellRow, srcCellCol);
int numChars = EvaluateIntArg(args[2], srcCellRow, srcCellCol);
String newStr = EvaluateStringArg(args[3], srcCellRow, srcCellCol);
if (startNum < 1 || numChars < 0)
{
return ErrorEval.VALUE_INVALID;
}
StringBuilder strBuff = new StringBuilder(oldStr);
// remove any characters that should be replaced
if (startNum <= oldStr.Length && numChars != 0)
{
strBuff.Remove(startNum - 1, startNum - 1 + numChars);
}
// now insert (or append) newStr
if (startNum > strBuff.Length)
{
strBuff.Append(newStr);
}
else
{
strBuff.Insert(startNum - 1, newStr);
}
return new StringEval(strBuff.ToString());
}
public override Eval Evaluate(Eval[] args, int srcRow, short srcCol)
{
if (args.Length != 2)
{
return ErrorEval.VALUE_INVALID;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 2; i++)
{
ValueEval ve = SingleOperandEvaluate(args[i], srcRow, srcCol);
if (ve is StringValueEval)
{
StringValueEval sve = (StringValueEval)ve;
sb.Append(sve.StringValue);
}
else if (ve is BlankEval)
{
// do nothing
}
else
{ // must be an error eval
return ve;
}
}
return new StringEval(sb.ToString());
}
public Eval Evaluate(Eval[] args, int srcCellRow, short srcCellCol)
{
Eval arg3 = null;
switch (args.Length)
{
case 4:
arg3 = args[3]; // important: assumed array element Is never null
break;
case 3:
break;
default:
// wrong number of arguments
return ErrorEval.VALUE_INVALID;
}
try
{
// Evaluation order:
// arg0 lookup_value, arg1 table_array, arg3 range_lookup, Find lookup value, arg2 row_index, fetch result
ValueEval lookupValue = OperandResolver.GetSingleValue(args[0], srcCellRow, srcCellCol);
AreaEval tableArray = LookupUtils.ResolveTableArrayArg(args[1]);
bool IsRangeLookup = LookupUtils.ResolveRangeLookupArg(arg3, srcCellRow, srcCellCol);
int colIndex = LookupUtils.LookupIndexOfValue(lookupValue, LookupUtils.CreateRowVector(tableArray, 0), IsRangeLookup);
int rowIndex = LookupUtils.ResolveRowOrColIndexArg(args[2], srcCellRow, srcCellCol);
ValueVector resultCol = CreateResultColumnVector(tableArray, rowIndex);
return resultCol.GetItem(colIndex);
}
catch (EvaluationException e)
{
return e.GetErrorEval();
}
}
public Eval Evaluate(Eval[] args, int srcCellRow, short srcCellCol)
{
switch (args.Length)
{
case 1:
// expected
break;
case 0:
// too few arguments
return ErrorEval.VALUE_INVALID;
default:
// too many arguments
return ErrorEval.VALUE_INVALID;
}
Eval firstArg = args[0];
int result;
if (firstArg is AreaEval)
{
AreaEval ae = (AreaEval)firstArg;
result = ae.LastRow - ae.FirstRow + 1;
}
else if (firstArg is RefEval)
{
result = 1;
}
else
{ // anything else Is not valid argument
return ErrorEval.VALUE_INVALID;
}
return new NumberEval(result);
}
public Eval Evaluate(Eval[] args, int srcCellRow, short srcCellCol)
{
int nArgs = args.Length;
if (nArgs < 1)
{
// too few arguments
return ErrorEval.VALUE_INVALID;
}
if (nArgs > 30)
{
// too many arguments
return ErrorEval.VALUE_INVALID;
}
int temp = 0;
// Note - observed behavior of Excel:
// Error values like #VALUE!, #REF!, #DIV/0!, #NAME? etc don't cause this COUNTA to return an error
// in fact, they seem to Get Counted
for (int i = 0; i < nArgs; i++)
{
temp += CountUtils.CountArg(args[i], predicate);
}
return new NumberEval(temp);
}
protected int EvaluateAsInteger(Eval eval)
{
int numval = -1;
if (eval is NumberEval)
{
NumberEval neval = (NumberEval)eval;
double d = neval.NumberValue;
numval = (int)d;
}
else if (eval is StringEval)
{
StringEval seval = (StringEval)eval;
String s = seval.StringValue;
try
{
double d = double.Parse(s);
numval = (int)d;
}
catch (Exception)
{
}
}
else if (eval is BoolEval)
{
BoolEval beval = (BoolEval)eval;
numval = beval.BooleanValue ? 1 : 0;
}
else if (eval is RefEval)
{
numval = EvaluateAsInteger(XlateRefEval((RefEval)eval));
}
return numval;
}
public Eval Evaluate(Eval[] args, int srcCellRow, short srcCellCol)
{
BoolEval beval;
Eval evalWhenFalse = BoolEval.FALSE;
switch (args.Length)
{
case 3:
evalWhenFalse = args[2];
beval = (BoolEval)args[0]; // TODO - class cast exception
if (beval.BooleanValue)
{
return args[1];
}
return evalWhenFalse;
case 2:
beval = (BoolEval)args[0]; // TODO - class cast exception
if (beval.BooleanValue)
{
return args[1];
}
return evalWhenFalse;
default:
return ErrorEval.VALUE_INVALID;
}
}
/**
*Substitutes text in a text string with new text, some number of times.
*
* @see org.apache.poi.hssf.record.formula.eval.Eval
*/
public override ValueEval EvaluateFunc(Eval[] args, int srcCellRow, short srcCellCol)
{
if (args.Length < 3 || args.Length > 4)
{
return ErrorEval.VALUE_INVALID;
}
String oldStr = EvaluateStringArg(args[0], srcCellRow, srcCellCol);
String searchStr = EvaluateStringArg(args[1], srcCellRow, srcCellCol);
String newStr = EvaluateStringArg(args[2], srcCellRow, srcCellCol);
String result;
switch (args.Length)
{
case 4:
int instanceNumber = EvaluateIntArg(args[3], srcCellRow, srcCellCol);
if (instanceNumber < 1)
{
return ErrorEval.VALUE_INVALID;
}
result = ReplaceOneOccurrence(oldStr, searchStr, newStr, instanceNumber);
break;
case 3:
result = ReplaceAllOccurrences(oldStr, searchStr, newStr);
break;
default:
throw new InvalidOperationException("Cannot happen");
}
return new StringEval(result);
}
public override ValueEval EvaluateFunc(Eval[] args, int srcCellRow, short srcCellCol)
{
if (args.Length != 3)
{
return ErrorEval.VALUE_INVALID;
}
String text = EvaluateStringArg(args[0], srcCellRow, srcCellCol);
int startCharNum = EvaluateIntArg(args[1], srcCellRow, srcCellCol);
int numChars = EvaluateIntArg(args[2], srcCellRow, srcCellCol);
int startIx = startCharNum - 1; // convert to zero-based
// Note - for start_num arg, blank/zero causes error(#VALUE!),
// but for num_chars causes empty string to be returned.
if (startIx < 0)
{
return ErrorEval.VALUE_INVALID;
}
if (numChars < 0)
{
return ErrorEval.VALUE_INVALID;
}
int len = text.Length;
if (numChars < 0 || startIx > len)
{
return new StringEval("");
}
int endIx = Math.Min(startIx + numChars, len);
String result = text.Substring(startIx, endIx-startIx);
return new StringEval(result);
}
public override Eval Evaluate(Eval[] operands, int srcCellRow, short srcCellCol)
{
Eval retval = BoolEval.FALSE;
switch (operands.Length)
{
case 1:
Eval eval = operands[0];
if (eval is BoolEval)
{
retval = BoolEval.TRUE;
}
else if (eval is RefEval)
{
Eval xlatedEval = XlateRefEval((RefEval)eval);
if (xlatedEval is BoolEval)
{
retval = BoolEval.TRUE;
}
}
break;
default:
retval = ErrorEval.VALUE_INVALID;
break;
}
return retval;
}
public Eval Evaluate(Eval[] evals, int srcCellRow, short srcCellCol)
{
if (evals.Length > 0)
{
return ErrorEval.VALUE_INVALID;
}
return new NumberEval(HSSFDateUtil.GetExcelDate(DateTime.Today));
}
public override ValueEval EvaluateFunc(Eval[] args, int srcCellRow, short srcCellCol)
{
if (args.Length != 1)
{
return ErrorEval.VALUE_INVALID;
}
String arg = EvaluateStringArg(args[0], srcCellRow, srcCellCol);
return Evaluate(arg);
}
protected override double Eval(Eval[] args, int srcCellRow, short srcCellCol)
{
if (args.Length != 1)
{
throw new EvaluationException(ErrorEval.VALUE_INVALID);
}
double d = SingleOperandEvaluate(args[0], srcCellRow, srcCellCol);
return Evaluate(d);
}
public override Eval Evaluate(Eval[] operands, int srcRow, short srcCol)
{
Eval retval = null;
Function f = GetFunction();
if (f != null)
retval = f.Evaluate(operands, srcRow, srcCol);
else
retval = ErrorEval.FUNCTION_NOT_IMPLEMENTED;
return retval;
}
public override ValueEval EvaluateFunc(Eval[] args, int srcCellRow, short srcCellCol)
{
StringBuilder sb = new StringBuilder();
for (int i=0, iSize=args.Length; i<iSize; i++) {
sb.Append(EvaluateStringArg(args[i], srcCellRow, srcCellCol));
}
return new StringEval(sb.ToString());
}
public override ValueEval EvaluateFunc(Eval[] args, int srcCellRow, short srcCellCol)
{
if (args.Length != 2)
{
return ErrorEval.VALUE_INVALID;
}
String s0 = EvaluateStringArg(args[0], srcCellRow, srcCellCol);
String s1 = EvaluateStringArg(args[1], srcCellRow, srcCellCol);
return BoolEval.ValueOf(s0.Equals(s1));
}
public Eval Evaluate(Eval[] args, int srcCellRow, short srcCellCol)
{
try
{
return EvaluateFunc(args, srcCellRow, srcCellCol);
}
catch (EvaluationException e)
{
return e.GetErrorEval();
}
}
private static int EvaluateArgParity(Eval arg, int srcCellRow, int srcCellCol)
{
ValueEval ve = OperandResolver.GetSingleValue(arg, srcCellRow, (short)srcCellCol);
double d = OperandResolver.CoerceValueToDouble(ve);
if (d < 0)
{
d = -d;
}
long v = (long)Math.Floor(d);
return (int)(v & 0x0001);
}
private static RefEval EvaluateRef(Eval arg)
{
if (arg is RefEval)
{
return (RefEval)arg;
}
if (arg is ErrorEval)
{
throw new EvaluationException((ErrorEval)arg);
}
throw new ArgumentException("Unexpected ref arg class (" + arg.GetType().Name + ")");
}
private void AppendArgument(StreamWriter Output, int Indentation, string Name, string Value, bool Quotes, char QuoteChar)
{
this.AppendArgument(Output, Indentation, Name);
if (Quotes)
{
Eval.ExportPlantUml("\"" + Value.Replace("\"", "\\\"") + "\"", Output, Indentation, QuoteChar, false);
}
else
{
Eval.ExportPlantUml(Value, Output, Indentation, QuoteChar, false);
}
}
public void Equation()
{
var eval = new Eval();
var ev = @"a = -1.90348642570E-002
b = 2.59124284126E+003
c = 1.74712818469E+000
d = 2.19476267227E+000
x = 10
=(a*b+c*x^d)/(b+x^d)";
var expectedValue = 0.0816126249369512;
Assert.AreEqual(Math.Round(expectedValue, 3), Math.Round(eval.ProcessEquation(ev), 3));
}
private bool IsValidAssignment(string name, Location loc)
{
if (Eval.GetInScope(name) is ILocatedMember m)
{
// Class and function definition are processed first, so only override
// if assignment happens after declaration
if (loc.IndexSpan.Start < m.Location.IndexSpan.Start)
{
return(false);
}
}
return(true);
}
public void Aggregate()
{
var P = RelNode.Import(SourceKind.Csv, Testdata, "P", "PNo:text,PName:text,Color:text,Weight:number,City:text");
var pagg = P
.Project("Color,Weight")
.Aggregate("Weight,TotWeight", Eval.Number((v, a) => v + a));
Assert.AreEqual(2, pagg.Degree);
Assert.AreEqual("Color,TotWeight", pagg.Heading.ToNames().Join(","));
Assert.AreEqual(3, pagg.Cardinality);
Assert.AreEqual("Red,45.0;Green,17.0;Blue,29.0", pagg.Join(";"));
}
public override async Task <bool> WalkAsync(ReturnStatement node, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
var value = await Eval.GetValueFromExpressionAsync(node.Expression, cancellationToken);
if (!value.IsUnknown())
{
_result = value;
return(false);
}
return(true);
}
public Eval Evaluate(Eval[] operands, int srcRow, short srcCol) {
ValueEval retval;
switch (operands.Length) {
case 0:
retval = new NumberEval(new Random().NextDouble());
break;
default:
retval = ErrorEval.VALUE_INVALID;
break;
}
return retval;
}
public void testReplaceAndEvaluate()
{
string testExpression = "@+3/20";
string testRegex = "@";
double testValue = 30d;
double expectedResult = 30.15d;
Assert.AreEqual(
expectedResult,
Eval.ReplaceNEvaluate(
testExpression, testRegex, testValue)
);
}
public bool Matches(Eval valueEval)
{
// Note - observed behavior of Excel:
// Error values like #VALUE!, #REF!, #DIV/0!, #NAME? etc don't cause this COUNTA to return an error
// in fact, they seem to get counted
if (valueEval == BlankEval.INSTANCE)
{
return false;
}
// Note - everything but BlankEval counts
return true;
}
public Value Convert(ResolveResult result)
{
if (result.IsCompileTimeConstant && !result.IsError)
{
var type = Import(result.Type);
if (type == null)
{
throw new GetValueException("Error: cannot find '{0}'.", result.Type.FullName);
}
return(Eval.CreateValue(evalThread, result.ConstantValue, type));
}
return(Visit((dynamic)result));
}
static void Main(string[] args)
{
var eval = new Eval();
var res = "";
// Test Case
if ((res = eval.eval(new[] { "1 0 0", "", "", "", }, 0)) != "1")
{
throw new Exception(res);
}
if ((res = eval.eval(new[] { "1 0 2", "", "", "", }, 0)) != "0")
{
throw new Exception(res);
}
if ((res = eval.eval(new[] { "3 0 0", "", "", "", }, 0)) != "1")
{
throw new Exception(res);
}
if ((res = eval.eval(new[] { "4 0 2", "", "", "", }, 0)) != "0")
{
throw new Exception(res);
}
if ((res = eval.eval(new[] { "3 2 0", "", "", "", }, 0)) != "0.75")
{
throw new Exception(res);
}
if ((res = eval.eval(new[] { "3 1 1", "", "", "", }, 0)) != "0.25")
{
throw new Exception(res);
}
if ((res = eval.eval(new[] { "4 1 1", "", "", "", }, 0)) != "0.5")
{
throw new Exception(res);
}
//if ((res = eval.eval(new[] { "", "", "", "", }, 0)) != "") throw new Exception(res);
//return;
File.Delete(OUTPUT);
var lines = File.ReadAllLines(FILE_NAME);
var T = int.Parse(lines[0]);
var l = 1; //行数
for (int t = 0; t < T; t++)
{
res = eval.eval(lines, l);
l += 1;
File.AppendAllText(OUTPUT, string.Format("Case #{0}: {1}\n", t + 1, res));
Console.Write(DateTime.Now.ToShortTimeString() + "." + DateTime.Now.Second + string.Format(" Case #{0}: {1}\n", t + 1, res));
}
}
public static string GetAns(string statement)
{
var complex = false;
foreach (var symbol in statement)
{
if (symbol == 'i')
{
complex = true;
}
}
return(!complex?Eval.Execute <long>(statement).ToString() : MathSolver.GetAnswer(statement));
}
public override void Evaluate()
{
var stub = SymbolTable.ReplacedByStubs.Contains(Target) ||
_function.DeclaringModule.ModuleType == ModuleType.Stub ||
Module.ModuleType == ModuleType.Specialized;
using (Eval.OpenScope(_function.DeclaringModule, FunctionDefinition, out _)) {
// Process annotations.
var annotationType = Eval.GetTypeFromAnnotation(FunctionDefinition.ReturnAnnotation);
if (!annotationType.IsUnknown())
{
// Annotations are typically types while actually functions return
// instances unless specifically annotated to a type such as Type[T].
var instance = annotationType.CreateInstance(annotationType.Name, ArgumentSet.Empty);
_overload.SetReturnValue(instance, true);
}
else
{
// Check if function is a generator
var suite = FunctionDefinition.Body as SuiteStatement;
var yieldExpr = suite?.Statements.OfType <ExpressionStatement>().Select(s => s.Expression as YieldExpression).ExcludeDefault().FirstOrDefault();
if (yieldExpr != null)
{
// Function return is an iterator
var yieldValue = Eval.GetValueFromExpression(yieldExpr.Expression) ?? Eval.UnknownType;
var returnValue = new PythonGenerator(Eval.Interpreter, yieldValue);
_overload.SetReturnValue(returnValue, true);
}
}
DeclareParameters(!stub);
// Do process body of constructors since they may be declaring
// variables that are later used to determine return type of other
// methods and properties.
var ctor = _function.Name.EqualsOrdinal("__init__") || _function.Name.EqualsOrdinal("__new__");
if (ctor || annotationType.IsUnknown() || Module.ModuleType == ModuleType.User)
{
// Return type from the annotation is sufficient for libraries and stubs, no need to walk the body.
FunctionDefinition.Body?.Walk(this);
// For libraries remove declared local function variables to free up some memory.
var optionsProvider = Eval.Services.GetService <IAnalysisOptionsProvider>();
if (Module.ModuleType != ModuleType.User && optionsProvider?.Options.KeepLibraryLocalVariables != true)
{
((VariableCollection)Eval.CurrentScope.Variables).Clear();
}
}
}
Result = _function;
}
// GET: Evals/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Eval eval = db.Evals.Find(id);
if (eval == null)
{
return(HttpNotFound());
}
return(View(eval));
}
private object EvalJScript(string src)
{
var engine = Engine;
try
{
With.JScriptWith(this, Engine);
return(Eval.JScriptEvaluate(src, "unsafe", engine));
}
finally
{
engine.PopScriptObject(/* with */);
}
}
private bool EvaluateScreenAndConditions(Screen screen, ConditionsConfiguration condition)
{
if (condition.Primary.HasValue && condition.Primary.Value != screen.Primary)
{
return(false);
}
if (condition.Expression != null && !Eval.Execute <bool>(condition.Expression, screen.Bounds))
{
return(false);
}
return(true);
}
private void HandleAllAppendExtend(CallExpression node)
{
if (!(node.Target is MemberExpression me))
{
return;
}
if (!IsHandleableAll(me.Target))
{
return;
}
if (node.Args.Count == 0)
{
return;
}
var arg = node.Args[0].Expression;
var v = Eval.GetValueFromExpression(arg);
if (v == null)
{
_allIsUsable = false;
return;
}
IPythonCollection values = null;
switch (me.Name)
{
case "append":
values = PythonCollectionType.CreateList(Module.Interpreter, Eval.GetLoc(arg), new List <IMember>()
{
v
}, exact: true);
break;
case "extend":
values = v as IPythonCollection;
break;
}
if (values == null)
{
_allIsUsable = false;
return;
}
ExtendAll(node, values);
}
public static Parse Any(params Union <Parse, Func <Parse> >[] parsers)
{
return((data, charsHandledSoFar, acc, errors) => {
var result = parsers.Select(
x => {
var newErrors = new List <Error>();
var newAcc = new Result();
return new { result = Eval(x)(data, charsHandledSoFar, newAcc, newErrors), acc = newAcc, errors = newErrors };
}
).ToArray();
if (result.All(x => x.result.Item1 == State.Failure))
{
errors.Add(new Error("All of the following possibilities failed", result.SelectMany(x => x.errors).ToList(), charsHandledSoFar));
return Tuple.Create(State.Failure, data, charsHandledSoFar);
}
var longestMatch = result.Where(x => x.result.Item1 == State.Success).MaxBy(x => x.result.Item3);
acc.AddRange(longestMatch.acc);
errors.AddRange(longestMatch.errors);
return longestMatch.result;
});
}
public bool HandleGlobal(GlobalStatement node)
{
foreach (var nex in node.Names)
{
var m = Eval.LookupNameInScopes(nex.Name, out _, out var v, LookupOptions.Global);
if (m != null)
{
var location = Eval.GetLocationOfName(nex);
Eval.CurrentScope.DeclareGlobal(nex.Name, location);
v?.AddReference(location);
}
}
return(false);
}
public async Task HandleAnnotatedExpressionAsync(ExpressionWithAnnotation expr, IMember value, CancellationToken cancellationToken = default)
{
if (expr?.Annotation == null)
{
return;
}
var variableType = await Eval.GetTypeFromAnnotationAsync(expr.Annotation, cancellationToken);
// If value is null, then this is a pure declaration like
// x: List[str]
// without a value. If value is provided, then this is
// x: List[str] = [...]
// Check value type for compatibility
IMember instance = null;
if (value != null)
{
var valueType = value.GetPythonType();
if (!variableType.IsUnknown() && !valueType.Equals(variableType))
{
// TODO: warn incompatible value type.
// TODO: verify values. Value may be list() while variable type is List[str].
// Leave it as variable type.
}
else
{
instance = value;
}
}
instance = instance ?? variableType?.CreateInstance(variableType.Name, Eval.GetLoc(expr.Expression), ArgumentSet.Empty) ?? Eval.UnknownType;
if (expr.Expression is NameExpression ne)
{
Eval.DeclareVariable(ne.Name, instance, expr.Expression);
return;
}
if (expr.Expression is MemberExpression m)
{
// self.x : int = 42
var self = Eval.LookupNameInScopes("self", out var scope);
var argType = self?.GetPythonType();
if (argType is PythonClassType cls && scope != null)
{
cls.AddMember(m.Name, instance, true);
}
}
}
protected override double Eval(Eval[] args, int srcCellRow, short srcCellCol)
{
int nArgs = args.Length;
if (nArgs < _minArgs || nArgs > _maxArgs)
{
throw new EvaluationException(ErrorEval.VALUE_INVALID);
}
double[] ds = new double[nArgs];
for (int i = 0; i < nArgs; i++)
{
ds[i] = SingleOperandEvaluate(args[i], srcCellRow, srcCellCol);
}
return Evaluate(ds);
}
private void ExtendAll(Node location, IPythonCollection values)
{
Eval.LookupNameInScopes(AllVariableName, out var scope, LookupOptions.Global);
if (scope == null)
{
return;
}
var all = scope.Variables[AllVariableName]?.Value as IPythonCollection;
var list = PythonCollectionType.CreateConcatenatedList(Module.Interpreter, all, values);
var source = list.IsGeneric() ? VariableSource.Generic : VariableSource.Declaration;
Eval.DeclareVariable(AllVariableName, list, source, location);
}
public void Equation_SYM()
{
var eval = new Eval();
var ev = @"a = 4.42907255764E-002
b = 4.28646004865E-003
c = 6.79041100634E-004
d = -6.24669695062E-006
x = iv.alpha
=a+b*x+c*x^2+d*x^3";
var expectedValue = 0.149;
eval.SetSymbol("iv.alpha", 10);
Assert.AreEqual(Math.Round(expectedValue, 3), Math.Round(eval.ProcessEquation(ev), 3));
}
protected internal override void TraverseProp(Prop prop)
{
var ass = prop.Parent as Assign;
(ass != null && ass.Lhs == prop).AssertFalse();
var getter = prop.Property.GetGetMethod(true);
var @this = prop.Property.IsInstance() ? prop.This.MkArray() : Seq.Empty <Expression>();
var args = prop.InvocationIndexers() ?? Seq.Empty <Expression>();
var style = prop.InvokedAsVirtual ? InvocationStyle.Virtual : InvocationStyle.NonVirtual;
var equiv = new Eval(new Apply(new Lambda(getter, style), @this.Concat(args)));
Traverse(equiv);
}
private void TryHandleClassVariable(MemberExpression mex, IMember value)
{
if (mex.Target is NameExpression nex && nex.Name == "self")
{
var m = Eval.LookupNameInScopes(nex.Name, out _, LookupOptions.Local);
var cls = m.GetPythonType <IPythonClassType>();
if (cls != null)
{
using (Eval.OpenScope(Eval.Module, cls.ClassDefinition, out _)) {
Eval.DeclareVariable(mex.Name, value, VariableSource.Declaration, Eval.GetLocationOfName(mex));
}
}
}
}
static private AssemblyResults CompileAssembly(String code)
{
try
{
StreamWriter w = new StreamWriter("C:\\Program Files\\ILNET\\ILNET Server\\Solution\\project.cs");
w.Write(code);
w.Close();
Dictionary <string, string> providerOptions = new Dictionary <string, string>();
providerOptions.Add("CompilerVersion", "v4.0");
CodeDomProvider codeProvider = new CSharpCodeProvider(providerOptions);
ICodeCompiler icc = codeProvider.CreateCompiler();
CompilerParameters cp = new CompilerParameters()
{
GenerateInMemory = false,
IncludeDebugInformation = Debugger.IsAttached,
TreatWarningsAsErrors = false,
WarningLevel = 0,
GenerateExecutable = false,
CompilerOptions = "/optimize+"
};
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add("System.Core.dll");
cp.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
cp.ReferencedAssemblies.Add("System.Data.dll");
cp.ReferencedAssemblies.Add("System.Drawing.dll");
cp.ReferencedAssemblies.Add("System.Windows.Forms.dll");
cp.ReferencedAssemblies.Add(FullReference("System.Xml.dll"));
cp.ReferencedAssemblies.Add(FullReference("System.Xml.Linq.dll"));
//cp.ReferencedAssemblies.Add(FullReference("MySql.Data.dll"));
cp.ReferencedAssemblies.Add(FullReference("Common.dll"));
AssemblyResults asm = Eval.CreateAssembly(icc, code, cp, new CSharpLanguage());
return(asm);
}
catch (CompilationException ce)
{
foreach (CompilerError error in ce.Errors)
{
if (error.IsWarning)
{
continue;
}
throw new Exception(Utils.Extract(code, "fname", code.NthIndexOf("\n", error.Line)).Substring(3), ce);
}
throw new Exception("", ce);
}
}
internal MethodResults CompileConstraints(List <string> constraints, int dims)
{
string code = "return ";
foreach (string eq in constraints)
{
code += "(" + FillCode(eq, dims) + ") &&";
}
// if no constraints then constraints always met (true)
if (constraints.Count == 0)
{
code += "true";
}
else
{
code = code.TrimEnd('&', ' ');
}
code += ";";
StringBuilder source = new StringBuilder();
source.Append("public bool MeetsConstraint(float[] x, float t)");
source.Append(Environment.NewLine);
source.Append("{");
source.Append(Environment.NewLine);
source.Append(code);
source.Append(Environment.NewLine);
source.Append("}");
try
{
return(Eval.CreateVirtualMethod(
new CSharpCodeProvider().CreateCompiler(),
source.ToString(),
"MeetsConstraint",
new CSharpLanguage(),
false,
"System.dll",
"System.Drawing.dll"));
}
catch (CompilationException ce)
{
MessageBox.Show(this, "Compilation Errors: " + Environment.NewLine + ce.ToString());
}
return(null);
}
private static Eval evaluatePush(Action action, Point[] enemyPos)
{
var pos = enemyPos[action.id];
var newEnemyPosition = GetMove(pos, action.moveDirection);
if (!IsValidLocation(newEnemyPosition))
{
return new Eval {
blocksEnemy = -1, helpsEnemy = -1, moveHeight = -1, overBuilt = -1, buildHeight = -1
}
}
;
//if (action.position.Equals(newEnemyPosition)) return new Eval { blocksEnemy = -1, helpsEnemy = -1, moveHeight = -1, overBuilt = -1, buildHeight = -1 };
//Console.Error.WriteLine("na: " + action);
//Console.Error.WriteLine("np: " + newEnemyPosition);
var build = GetMove(newEnemyPosition, action.buildDirection);
var initHeight = GetHeight(pos);
var moveHeight = GetHeight(newEnemyPosition);
var buildHeight = 0;// GetHeight(build);
int netHeight = moveHeight - initHeight;
var myHeight = GetHeight(action.position);
int overBuilt = buildHeight >= 3 ? 1 : 0;
int helpedEnemy = 0;
int blocksEnemy = 0;
for (int i = 0; i < 2; i++)
{
int enemyHeight = GetHeight(enemyPos[i]);
int distance = build.Distance(enemyPos[i]);
if (netHeight > 0 /*|| !Neighbors(action.position).Contains(build)*/)
{
helpedEnemy = 1;
}
if (netHeight < 0)
{
blocksEnemy = -netHeight;
}
}
var result = new Eval {
blocksEnemy = blocksEnemy, helpsEnemy = -helpedEnemy, moveHeight = myHeight - netHeight, overBuilt = -overBuilt, buildHeight = buildHeight
};
Console.Error.WriteLine("PUSHING: " + result);
return(result);
}
private void CheckValidFunction(IPythonFunctionType function, IReadOnlyList <IParameterInfo> parameters)
{
// Don't give diagnostics on functions defined in metaclasses
if (_self.IsMetaclass())
{
return;
}
// Static methods don't need any diagnostics
if (function.IsStatic)
{
return;
}
// Lambdas never get a self/cls argument.
if (function.IsLambda())
{
return;
}
// Error in parameters, don't lint
if (FunctionDefinition.Body == null)
{
return;
}
// Otherwise, functions defined in classes must have at least one argument
if (parameters.IsNullOrEmpty())
{
var funcLoc = Eval.GetLocation(FunctionDefinition.NameExpression);
ReportFunctionParams(Resources.NoMethodArgument, ErrorCodes.NoMethodArgument, funcLoc);
return;
}
var param = parameters[0].Name;
var paramLoc = Eval.GetLocation(FunctionDefinition.Parameters[0]);
// If it is a class method check for cls
if (function.IsClassMethod && !param.Equals("cls"))
{
ReportFunctionParams(Resources.NoClsArgument, ErrorCodes.NoClsArgument, paramLoc);
}
// If it is a method check for self
if (!function.IsClassMethod && !param.Equals("self"))
{
ReportFunctionParams(Resources.NoSelfArgument, ErrorCodes.NoSelfArgument, paramLoc);
}
}
static javascript()
{
#if USEVSAHOST
Engine = Evaluator.Evaluator.Engine;
#else
List <string> assemblies = new List <string>(DefaultAssemblyReferences);
Assembly executingAssembly = Assembly.GetExecutingAssembly();
foreach (var name in executingAssembly.GetReferencedAssemblies())
{
string codeBase = name.CodeBase;
try
{
Assembly assembly = Assembly.Load(name);
if (assembly.GlobalAssemblyCache)
{
codeBase = Path.GetFileName(assembly.Location);
}
else
{
codeBase = assembly.Location;
}
}
catch (ChatSignal ex)
{
throw;
}
catch (Exception)
{
}
if (codeBase == null)
{
codeBase = name.Name + ".dll";
}
if (!assemblies.Contains(codeBase))
{
assemblies.Add(codeBase);
}
}
var GS = VsaEngine.CreateEngineAndGetGlobalScope(true, assemblies.ToArray());
Engine = GS.engine;
#endif
foreach (string reference in DefaultNamespaceReferences)
{
Import.JScriptImport(reference, Engine);
}
object o = Eval.JScriptEvaluate("this", Engine);
writeDebugLine("JSciptThis = " + o);
}
public static Value MakeValue(object obj)
{
Value v = null;
if (!(obj is string))
{
v = Eval.CreateValue(WorkbenchServiceFactory.DebuggerManager.DebuggedProcess, obj);
v.SetPrimitiveValue(obj);
}
else
{
v = Eval.NewString(WorkbenchServiceFactory.DebuggerManager.DebuggedProcess, obj as string);
}
return(v);
}
public void HandleAnnotatedExpression(ExpressionWithAnnotation expr, IMember value)
{
if (expr?.Annotation == null)
{
return;
}
var variableType = Eval.GetTypeFromAnnotation(expr.Annotation);
// If value is null, then this is a pure declaration like
// x: List[str]
// without a value. If value is provided, then this is
// x: List[str] = [...]
HandleTypedVariable(variableType, value, expr.Expression);
}
/* Equality */
private void eqBtn_Click(object sender, EventArgs e)
{
if (output.Text.Trim().Equals(""))
{
return;
}
string result = Eval.eval(output.Text.Trim());
//string resultMsg = output.Text + " = " + result;
history.Add(result);
resultsBox.Text = string.Join("\n---\n", history);
output.Clear();
}
// return true if there was eval to setup and it was setup
internal bool SetupNextEvaluation()
{
this.AssertPaused();
while (pendingEvalsCollection.Count > 0)
{
Eval nextEval = pendingEvalsCollection.Dequeue();
if (nextEval.SetupEvaluation(this.SelectedThread))
{
activeEvals.Add(nextEval);
return(true);
}
}
return(false);
}
public Eval Redirect(Eval eval)
{
var m = eval.InvokedMethod();
var a = eval.InvocationArgs().ToReadOnly();
var redirectors = _redirects.Select(kvp => kvp.Key(m) ? kvp.Value : null).Where(f => f != null);
var f_mredir = redirectors.AssertSingle().Item1;
var m_redir = f_mredir(m, a);
var f_aredir = redirectors.AssertSingle().Item2;
var a_redir = f_aredir(m, a);
if (m_redir == null || a_redir == null) return null;
// todo. this doesn't preserve virtuality of the call!
return new Eval(new Apply(new Lambda(m_redir), a_redir));
}
public Eval Evaluate(Eval[] operands, int srcRow, short srcCol)
{
ValueEval retval;
switch (operands.Length)
{
case 0:
retval = PI_EVAL;
break;
default:
retval = ErrorEval.VALUE_INVALID;
break;
}
return retval;
}
protected ValueEval SingleOperandEvaluate(Eval eval, int srcRow, short srcCol)
{
ValueEval retval;
if (eval is AreaEval)
{
AreaEval ae = (AreaEval)eval;
if (ae.Contains(srcRow, srcCol))
{ // circular ref!
retval = ErrorEval.CIRCULAR_REF_ERROR;
}
else if (ae.IsRow)
{
if (ae.ContainsColumn(srcCol))
{
ValueEval ve = ae.GetValue(ae.FirstRow, srcCol);
ve = Xlator.AttemptXlateToNumeric(ve);
retval = Xlator.AttemptXlateToNumeric(ve);
}
else
{
retval = ErrorEval.VALUE_INVALID;
}
}
else if (ae.IsColumn)
{
if (ae.ContainsRow(srcRow))
{
ValueEval ve = ae.GetValue(srcRow, ae.FirstColumn);
retval = Xlator.AttemptXlateToNumeric(ve);
}
else
{
retval = ErrorEval.VALUE_INVALID;
}
}
else
{
retval = ErrorEval.VALUE_INVALID;
}
}
else
{
retval = Xlator.AttemptXlateToNumeric((ValueEval)eval);
}
return retval;
}
public bool Matches(Eval valueEval)
{
if (valueEval is NumberEval)
{
// only numbers are counted
return true;
}
if (valueEval == MissingArgEval.instance)
{
// oh yeah, and missing arguments
return true;
}
// error values and string values not counted
return false;
}
