public void TestLine(string input, bool resolve = true)
{
// First, let's parse it
CalcObject obj1 = CLInterpreter.Interpret(input);
// And put it back to string and back
string code2 = obj1.ToCode();
CalcObject obj3 = CLInterpreter.Interpret(code2);
string code4 = obj3.ToCode();
// code2 and code4 need to match
Assert.AreEqual(code2, code4, "code2 and code4 don't match on line: " + input);
// We'll stop here if we're testing non-deterministic functions
if (!resolve)
{
return;
}
// Then, let's get the value
CalcValue val5 = obj1.GetValue();
string code6 = val5.ToCode();
CalcObject obj7 = CLInterpreter.Interpret(code6);
string code8 = obj7.ToCode();
CalcValue val9 = obj7.GetValue();
// code6 and code8 need to match
Assert.AreEqual(code6, code8, "code6 and code8 don't match on line: " + input);
// val5 and val9 also need to match
Assert.AreEqual(val5, val9, "val5 and val9 don't match on line: " + input);
}
public string TestLine(string line, CLLocalStore vars, CLContextProvider context, string expected)
{
// We'll parse the line as usual
CalcObject obj1 = CLInterpreter.Interpret(line);
string code2 = obj1.ToCode();
CalcObject obj3 = CLInterpreter.Interpret(code2);
string code4 = obj3.ToCode();
// Make sure things look right
Assert.AreEqual(code2, code4);
// Now get the value out of it
CalcValue val5 = obj3.GetValue(vars, context);
string code6 = val5.ToCode();
CalcObject obj7 = CLInterpreter.Interpret(code6);
string code8 = val5.ToCode();
CalcValue val9 = obj7.GetValue(vars, context);
// Make sure things still look right
Assert.AreEqual(code6, code8);
Assert.AreEqual(val5, val9);
// Now we should also make sure the values reported are as expected.
Assert.AreEqual(code8, expected);
// And we'll return the final value so it can be used later!
return(code8);
}
// Concatenates two strings.
public static CalcValue BinPlusStrings(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context)
{
CalcString strLeft = left as CalcString;
CalcString strRight = right as CalcString;
return(new CalcString(strLeft + strRight));
}
private void CalculateAll()
{
string fromdate = "";
string todate = endtimeTB.Text;
calObjectList.Clear();
for (int i = 0; i < cfpCount; i++)
{
string barcode = cfpTable.Rows[i]["CFP_Barcode"].ToString();
string date = PersianDateTime.MiladiToShamsi(cfpTable.Rows[i]["CFP_Date"].ToString());
//انتقال به جدول موقت برای مقایسه و فقط یکبار
if (fromdate.Length == 0)
{
fromdate = date;
helper.TransferPTableToTempTable(helper.GetPtableFromDate(fromdate));
helper.TransferPTableToTempTable(helper.GetPtableFromDate(todate));
}
CalcObject calcObj = new CalcObject();
calcObj.barcode = barcode;
calcObj.fromDate = date;
calcObj.toDate = endtimeTB.Text;
calObjectList.Add(calcObj);
}
if (fromdate.Length > 0)
{
helper.DeletePTable(helper.GetPtableFromDate(fromdate));
helper.DeletePTable(helper.GetPtableFromDate(todate));
helper.GTSCalculateAll(todate);
timer1.Start();
}
}
// Parses a parenthesized expression.
private static CalcObject ParseParentheses(List <CLObjectPiece> pieces)
{
// First, get the "(" that spawned this method.
CLObjectPiece lpar = pieces[0];
pieces.RemoveAt(0);
CalcObject ret = ParseChain(pieces);
// If we now have an empty expression, we never closed the "(".
if (pieces.Count == 0)
{
throw new CLSyntaxException("Unmatched (", lpar.Position);
}
else
{
// Otherwise, we should have a ")" next.
CLObjectPiece rpar = pieces[0];
pieces.RemoveAt(0);
if (rpar.Contents != ")")
{
// Maybe it's a "]", "}", or "," though.
throw new CLSyntaxException("Unmatched ( and " + rpar.Contents, lpar.Position);
}
}
// But if we've made it here, we're fine.
return(ret);
}
private static CalcValue BinRepeat(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context)
{
List <CalcValue> ret = new List <CalcValue>();
CalcNumber numRight = (CalcNumber)right;
int count = (int)numRight.Value;
CalcObject _i = null;
if (vars.ContainsVar("_i"))
{
_i = vars["_i"];
}
for (int i = 0; i < count; i++)
{
vars["_i"] = new CalcNumber(i);
ret.Add(left.GetValue(vars, context));
}
if (_i != null)
{
vars["_i"] = _i;
}
return(new CalcList(ret.ToArray()));
}
// Adds two numbers.
public static CalcValue BinPlusNumbers(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context)
{
CalcNumber numLeft = left as CalcNumber;
CalcNumber numRight = right as CalcNumber;
return(new CalcNumber(numLeft + numRight));
}
// Returns the left raised to the power of the right.
public static CalcValue BinPowerNumbers(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context)
{
CalcNumber numLeft = left as CalcNumber;
CalcNumber numRight = right as CalcNumber;
return(new CalcNumber((decimal)Math.Pow((double)(numLeft.Value), (double)(numRight.Value))));
}
public static CalcValue BinIntDivideNumbers(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context)
{
CalcNumber numLeft = left as CalcNumber;
CalcNumber numRight = right as CalcNumber;
return(new CalcNumber(decimal.Floor(numLeft / numRight)));
}
/// <summary>Runs the Operator on two operands.</summary>
/// <param name="left">The left operand.</param>
/// <param name="right">The right operand.</param>
/// <param name="vars">The local variable storage.</param>
/// <param name="context">An object representing context.</param>
public CalcValue Run(CalcObject left, CalcObject right, CLLocalStore vars = null, CLContextProvider context = null)
{
// If the operator is value-based, we'll automatically convert expressions.
if (ValueBasedLeft)
{
left = left.GetValue(vars, context);
}
if (ValueBasedRight)
{
right = right.GetValue(vars, context);
}
// Now get the func.
CLBinaryOperatorFunc func = this[left.GetType(), right.GetType()];
// If it's null, we'll throw an exception.
if (func == null)
{
throw new CLException(
"Binary operator " + Symbol + " doesn't support parameters " + left.GetType().Name + " and " + right.GetType().Name
);
}
// Now let's run it.
return(func(left, right, vars, context));
}
// Returns the string, reversed.
public static CalcValue PreMinusString(CalcObject param, CLLocalStore vars, CLContextProvider context)
{
CalcString strParam = param as CalcString;
char[] chars = strParam.Value.ToCharArray();
Array.Reverse(chars);
return(new CalcString(new string(chars)));
}
void FixedUpdate()
{
if (!blast)
{
return;
}
rb.AddForce(CalcObject.RotationToShotVector(transform.rotation.eulerAngles.z) * Power);
blast = false;
}
// Parses a list.
private static CalcListExpression ParseList(List <CLObjectPiece> pieces)
{
// First, get the "[" that spawned this method.
CLObjectPiece lbracket = pieces[0];
pieces.RemoveAt(0);
List <CalcObject> ret = new List <CalcObject>();
// Also, we'll allow empty lists.
CLObjectPiece next = pieces[0];
if (next.Contents == "]")
{
pieces.RemoveAt(0);
return(new CalcListExpression(ret.ToArray()));
}
// But anyway, let's start populating non-empty lists.
while (pieces.Count != 0)
{
// Get the value
CalcObject obj = ParseChain(pieces);
// But no empty values are allowed
if (obj == null)
{
throw new CLSyntaxException("Value expected in list", pieces[0].Position);
}
// Add it to the list
ret.Add(obj);
// Now get the next bracket
next = pieces[0];
pieces.RemoveAt(0);
// If it's a ")" or "}", error.
if (next.Contents == ")" || next.Contents == "}")
{
throw new CLSyntaxException("Unclosed [ and " + next.Contents, lbracket.Position);
}
// If it's a "]", we're done.
if (next.Contents == "]")
{
return(new CalcListExpression(ret.ToArray()));
}
// Otherwise, keep looping.
}
// Oh, if we're out of pieces...
throw new CLSyntaxException("Unclosed [", lbracket.Position);
}
private void Calculate(object sender, Jacksonsoft.WaitWindowEventArgs e)
{
string fromdate = "";
string todate = "";
if (endtimeTB.InvokeRequired)
{
calculatedTB.Invoke(new MethodInvoker(delegate { todate = endtimeTB.Text; }));
}
else
{
todate = endtimeTB.Text;
}
calObjectList.Clear();
for (int i = 0; i < cfpCount; i++)
{
string barcode = cfpTable.Rows[i]["CFP_Barcode"].ToString();
string date = cfpTable.Rows[i]["CFP_Date"].ToString();
//انتقال به جدول موقت برای مقایسه و فقط یکبار
if (fromdate.Length == 0)
{
fromdate = date;
helper.TransferPTableToTempTable(helper.GetPtableFromDate(fromdate));
helper.TransferPTableToTempTable(helper.GetPtableFromDate(todate));
}
GTS.Clock.AppSetup.DataSet.GTSDBTableAdapters.TA_PersonTableAdapter PersonTA = new GTS.Clock.AppSetup.DataSet.GTSDBTableAdapters.TA_PersonTableAdapter();
decimal PersonId = (decimal)PersonTA.GetPrsID(barcode);
helper.GTSCalculate(barcode, PersonId, date, todate);
if (calculatedTB.InvokeRequired)
{
calculatedTB.Invoke(new MethodInvoker(delegate { calculatedTB.Text += "- " + barcode; }));
}
else
{
calculatedTB.Text += "- " + barcode;
}
//toolStripStatusLabel1.Text = String.Format("{0} of {1}", i + 1, cfpCount);
e.Window.Message = String.Format("Calculating {0} of {1}", i + 1, cfpCount);
CalcObject calcObj = new CalcObject();
calcObj.barcode = barcode;
calcObj.fromDate = date;
calcObj.toDate = endtimeTB.Text;
calObjectList.Add(calcObj);
//toolStripStatusLabel1.Invalidate();
//this.Invalidate();
//this.Update();
}
}
// Converts a value to a number.
internal static decimal ValueOf(CalcObject obj)
{
if (obj is CalcNumber num)
{
return(num.Value);
}
else
{
return((obj as CalcList).Sum());
}
}
/// <summary>
/// The method that turns a <c>List</c> of pieces into a full tree of
/// <c>CalcObject</c>s.
/// </summary>
/// <param name="pieces">The list of pieces.</param>
public static CalcObject Parse(List <CLObjectPiece> pieces)
{
CalcObject obj = ParseChain(pieces);
if (pieces.Count > 0)
{
CLObjectPiece piece = pieces[0];
throw new CLSyntaxException("Unmatched " + piece.Contents, piece.Position);
}
return(obj);
}
public IActionResult Get(int calcId)
{
var calcObj = new CalcObject
{
CalcTime = DateTime.Now,
CalcBaseData = calcId,
};
this._queue.Enqueue(calcObj.CalcTask);
return(this.Ok(calcId));
}
public static CalcValue PostFactNumber(CalcObject param, CLLocalStore vars, CLContextProvider context)
{
CalcNumber num = param as CalcNumber;
int o = 1;
for (int i = 2; i < num.Value; i++)
{
o *= i;
}
return(new CalcNumber(o));
}
private void Compaire()
{
helper.InitTA_PTable();
DataSet.DBDataSetTableAdapters.TA_CompaireDiffrenceTableAdapter cdTA = new DataSet.DBDataSetTableAdapters.TA_CompaireDiffrenceTableAdapter();
cdTA.Connection = GTSAppSettings.SQLConnection;
for (int k = 0; k < calObjectList.Count; k++)
{
CalcObject objcet = calObjectList[k];
DBDataSet.TA_PTableUsableColumnsDataTable ta_ptable = new DBDataSet.TA_PTableUsableColumnsDataTable();
DataSet.DBDataSetTableAdapters.TA_PTableUsableColumnsTableAdapter ptableTA = new DataSet.DBDataSetTableAdapters.TA_PTableUsableColumnsTableAdapter();
ptableTA.Connection = GTSAppSettings.SQLConnection;
ptableTA.Fill(ta_ptable);
DBDataSet.TA_PTableUsableColumnsDataTable ptable1 = helper.GetPTableUsableColumns(objcet.barcode, objcet.fromDate, objcet.toDate, "Clock6", true);
DBDataSet.TA_PTableUsableColumnsDataTable ptable2 = helper.GetPTableUsableColumns(objcet.barcode, objcet.fromDate, objcet.toDate, "GTS", false);
DBDataSet.TA_PTableUsableColumnsDataTable ptable = helper.AppendPTable(ptable1, ptable2);
string monthDate = objcet.toDate;
monthDate = monthDate.Remove(monthDate.Length - 2, 2);
monthDate += "00";
ptable.DefaultView.Sort = "prc_date";
ta_ptable = helper.AppendPTable(ta_ptable, ptable.DefaultView);
bool[,] deffMat = helper.GetDifferenceIndex(ta_ptable, objcet.barcode);
int diffCount = 0;
int difMonthCount = 0;
for (int i = 1; i < deffMat.GetLength(0); i++)
{
for (int j = 0; j < deffMat.GetLength(1) - 1; j++)
{
if ((ta_ptable.Rows[i][1].ToString() == monthDate) && (j == 2 || j == 3 || j == 4 || j == 21))
{
continue;
}
if (ta_ptable.Rows[i][1].ToString() == monthDate && deffMat[i, j])
{
difMonthCount++;
}
if (deffMat[i, j])
{
diffCount++;
}
}
}
diffCount = diffCount / 2;
cdTA.Insert(objcet.barcode, diffCount, difMonthCount, objcet.fromDate, objcet.toDate);
}
}
// Returns the list, with all its elements negated.
public static CalcValue PreMinusList(CalcObject param, CLLocalStore vars, CLContextProvider context)
{
CalcList lstParam = param as CalcList;
CalcValue[] lstRet = new CalcValue[lstParam.Count];
for (int i = 0; i < lstRet.Length; i++)
{
lstRet[i] = PrefixMinus.Run(lstParam[i], vars, context);
}
return(new CalcList(lstRet));
}
void Update()
{
if (targetLock == null)
{
return;
}
Vector2 direction = targetLock.position - transform.position;
transform.rotation = CalcObject.VectorToRotationSlerp(
transform.rotation, direction, TargetingSpeed
);
}
/// <summary>
/// Saves a <c>CalcObject</c> as a variable.
/// </summary>
/// <param name="name">The name of the variable to save.</param>
/// <param name="val">The value to save.</param>
/// <param name="context">
/// An object representing the context in which it's run.
/// </param>
public static void Save(string name, CalcObject val, CLContextProvider context)
{
CLVariableSave data = new CLVariableSave()
{
Name = name,
Value = val
};
VariableSaved.Invoke(context, data);
if (!data.Saved)
{
InternalStorage[name] = val;
}
}
public IEnumerator OnLaserCollision(CollisionArgs sender)
{
float force = 75 * sender.damage;
Vector2 forceAngle = CalcObject.AngleToAddForce(sender.point, gameObject.transform.position, force
);
body.AddForce(forceAngle);
if (!scream.isPlaying)
{
float maxPan = 33;
scream.panStereo = transform.position.x / maxPan;
scream.Play();
}
yield return(null);
}
// Returns the quotient of a list's items over a number.
public static CalcValue BinDivideList(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context)
{
CalcList lstLeft = left as CalcList;
CalcNumber numRight = right as CalcNumber;
// We will *not* do string checking here
// It's entirely possible someone writes a string divider and this function will use it.
CalcValue[] lstRet = new CalcValue[lstLeft.Count];
for (int i = 0; i < lstRet.Length; i++)
{
lstRet[i] = BinaryDivide.Run(lstLeft[i], numRight, vars, context);
}
return(new CalcList(lstRet));
}
// Multiplies a string by a number.
public static CalcValue BinTimesString(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context)
{
CalcString strLeft = left as CalcString;
CalcNumber numRight = right as CalcNumber;
int count = (int)numRight;
if (count < 0)
{
throw new CLException("Strings cannot be repeated negative times.");
}
string strRet = "";
for (int i = 0; i < count; i++)
{
strRet += strLeft;
}
return(new CalcString(strRet));
}
// Concatenates two lists.
public static CalcValue BinPlusLists(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context)
{
CalcList lstLeft = left as CalcList;
CalcList lstRight = right as CalcList;
CalcValue[] lstRet = new CalcValue[lstLeft.Count + lstRight.Count];
int i;
for (i = 0; i < lstLeft.Count; i++)
{
lstRet[i] = lstLeft[i];
}
for (int j = 0; j < lstRight.Count; j++)
{
lstRet[i + j] = lstRight[j];
}
return(new CalcList(lstRet));
}
/// <summary>Runs the Operator on two operands.</summary>
/// <param name="param">The right operand.</param>
/// <param name="vars">The local variable storage.</param>
/// <param name="context">An object representing context.</param>
public CalcValue Run(CalcObject param, CLLocalStore vars = null, CLContextProvider context = null)
{
// If the operator is value-based, we'll automatically convert expressions.
if (ValueBased)
{
param = param.GetValue(vars, context);
}
// Now get the func.
CLUnaryOperatorFunc func = this[param.GetType()];
// If it's null, we'll throw an exception.
if (func == null)
{
throw new CLException(
"Binary operator " + Symbol + " doesn't support parameter " + param.GetType().Name
);
}
// Now let's run it.
return(func(param, vars, context));
}
// Multiplies a list by a number.
public static CalcValue BinTimesList(CalcObject left, CalcObject right, CLLocalStore vars, CLContextProvider context)
{
CalcList lstLeft = left as CalcList;
CalcNumber numRight = right as CalcNumber;
// If it has a string, we'll just repeat the list multiple times.
if (lstLeft.HasString())
{
int count = (int)numRight;
if (count < 0)
{
throw new CLException("Lists cannot be repeated negative times.");
}
CalcValue[] lstRet = new CalcValue[lstLeft.Count * count];
for (int i = 0; i < count; i++)
{
for (int j = 0; j < lstLeft.Count; j++)
{
lstRet[i * lstLeft.Count + j] = lstLeft[j];
}
}
return(new CalcList(lstRet));
}
else
{
// Otherwise we'll multiply everything by the number.
CalcValue[] lstRet = new CalcValue[lstLeft.Count];
for (int i = 0; i < lstRet.Length; i++)
{
lstRet[i] = BinaryTimes.Run(lstLeft[i], numRight, vars, context);
}
return(new CalcList(lstRet));
}
}
private static CalcValue KeepCompare(CalcObject left, CLComparison comp, CalcObject right, CLLocalStore vars)
{
CalcList lstLeft = (CalcList)left;
CalcNumber numRight = (CalcNumber)right;
List <CalcValue> kept = new List <CalcValue>();
List <CalcValue> dropped = new List <CalcValue>();
foreach (CalcValue val in lstLeft)
{
if (comp.CompareFunction(ValueOf(val), numRight.Value))
{
kept.Add(val);
}
else
{
dropped.Add(val);
}
}
vars["_d"] = new CalcList(dropped.ToArray());
return(new CalcList(kept.ToArray()));
}
// And this method parses Functions, including Code Functions.
private static CalcFunction ParseFunction(List <CLObjectPiece> pieces)
{
// As with the other two methods, we'll get and store the opener.
CLObjectPiece lbrace = pieces[0];
pieces.RemoveAt(0);
string opener = lbrace.Contents;
List <CalcObject> pars = new List <CalcObject>();
Match mtcName = rgxName.Match(opener);
string name = mtcName.Groups[1].Value;
// And again, no-param functions are allowed.
CLObjectPiece next = pieces[0];
if (next.Contents == "}")
{
pieces.RemoveAt(0);
return(new CalcFunction(name, pars.ToArray()));
}
// If the next piece is a comma, let's just get rid of it.
if (next.Contents == ",")
{
pieces.RemoveAt(0);
}
// And parse through the params.
while (pieces.Count != 0)
{
// Get the value
CalcObject obj = ParseChain(pieces);
// But no empty values are allowed
if (obj == null)
{
throw new CLSyntaxException("Value expected in function", pieces[0].Position);
}
// Add it to the params
pars.Add(obj);
// Now get the next bracket
next = pieces[0];
pieces.RemoveAt(0);
// If it's a ")" or "]", error.
if (next.Contents == ")" || next.Contents == "]")
{
throw new CLSyntaxException("Unclosed { and " + next.Contents, lbrace.Position);
}
// If it's a "}", we're done.
if (next.Contents == "}")
{
return(new CalcFunction(name, pars.ToArray()));
}
// Otherwise, keep looping.
}
// Oh, if we're out of pieces...
throw new CLSyntaxException("Unclosed {", lbrace.Position);
}
