1923 lines
48 KiB
C#
1923 lines
48 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using CPF.ReoGrid.DataFormat;
|
||
using CPF.ReoGrid.Utility;
|
||
|
||
namespace CPF.ReoGrid.Formula
|
||
{
|
||
internal class Evaluator
|
||
{
|
||
public static FormulaValue Evaluate(Cell cell)
|
||
{
|
||
bool flag = cell == null;
|
||
FormulaValue result;
|
||
if (flag)
|
||
{
|
||
result = null;
|
||
}
|
||
else
|
||
{
|
||
result = Evaluator.Evaluate((cell.Worksheet == null) ? null : cell.Worksheet.workbook, cell, cell.FormulaTree);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
public static FormulaValue Evaluate(IWorkbook workbook, string input)
|
||
{
|
||
return Evaluator.Evaluate(workbook, null, Parser.Parse(workbook, null, input));
|
||
}
|
||
|
||
public static FormulaValue Evaluate(Cell cell, STNode node)
|
||
{
|
||
return Evaluator.Evaluate((cell.Worksheet == null) ? null : cell.Worksheet.workbook, cell, node);
|
||
}
|
||
|
||
private static FormulaValue Evaluate(IWorkbook workbook, Cell cell, STNode node)
|
||
{
|
||
bool flag = node == null;
|
||
FormulaValue nil;
|
||
if (flag)
|
||
{
|
||
nil = FormulaValue.Nil;
|
||
}
|
||
else
|
||
{
|
||
switch (node.Type)
|
||
{
|
||
case STNodeType.CONNECT:
|
||
{
|
||
bool flag2 = node.Children.Count < 2;
|
||
if (flag2)
|
||
{
|
||
return FormulaValue.Nil;
|
||
}
|
||
FormulaValue formulaValue = Evaluator.Evaluate(workbook, cell, node[0]);
|
||
FormulaValue formulaValue2 = Evaluator.Evaluate(workbook, cell, node[1]);
|
||
return Convert.ToString(formulaValue.value) + Convert.ToString(formulaValue2.value);
|
||
}
|
||
case STNodeType.NUMBER:
|
||
return ((STNumberNode)node).Value;
|
||
case STNodeType.STRING:
|
||
return ((STStringNode)node).Text.Replace("\"\"", "\"");
|
||
case STNodeType.TRUE:
|
||
return true;
|
||
case STNodeType.FALSE:
|
||
return false;
|
||
case STNodeType.IDENTIFIER:
|
||
{
|
||
string identifier = ((STIdentifierNode)node).Identifier;
|
||
NamedRange namedRange;
|
||
bool flag3 = cell.Worksheet.TryGetNamedRange(identifier, out namedRange);
|
||
if (flag3)
|
||
{
|
||
bool isSingleCell = namedRange.Position.IsSingleCell;
|
||
if (isSingleCell)
|
||
{
|
||
return Evaluator.CreateFormulaValue(cell.Worksheet.GetCellData(namedRange.StartPos));
|
||
}
|
||
return namedRange.Position;
|
||
}
|
||
else
|
||
{
|
||
bool flag4 = FormulaExtension.NameReferenceProvider != null;
|
||
if (flag4)
|
||
{
|
||
return Evaluator.CreateFormulaValue(FormulaExtension.NameReferenceProvider(cell, identifier));
|
||
}
|
||
throw new FormulaNoNameException(cell);
|
||
}
|
||
break;
|
||
}
|
||
case STNodeType.RANGE:
|
||
return ((STRangeNode)node).Range;
|
||
case STNodeType.CELL:
|
||
{
|
||
STCellNode stcellNode = (STCellNode)node;
|
||
Worksheet worksheet = stcellNode.Worksheet;
|
||
bool flag5 = worksheet == null && cell != null;
|
||
if (flag5)
|
||
{
|
||
worksheet = cell.Worksheet;
|
||
}
|
||
CellPosition position = stcellNode.Position;
|
||
Cell cell2 = worksheet.GetCell(position);
|
||
bool flag6 = cell2 == null;
|
||
if (flag6)
|
||
{
|
||
return FormulaValue.Nil;
|
||
}
|
||
bool flag7 = cell2.formulaStatus > FormulaStatus.Normal;
|
||
if (flag7)
|
||
{
|
||
switch (cell2.formulaStatus)
|
||
{
|
||
case FormulaStatus.InvalidValue:
|
||
throw new FormulaTypeMismatchException(cell2);
|
||
case FormulaStatus.NameNotFound:
|
||
throw new FormulaNoNameException(cell2);
|
||
case FormulaStatus.MismatchedParameter:
|
||
throw new FormulaParameterMismatchException(cell2);
|
||
}
|
||
throw new FormulaEvalutionException(cell2, "formula error happens in " + cell2.Address);
|
||
}
|
||
return Evaluator.CreateFormulaValue(cell2);
|
||
}
|
||
case STNodeType.FUNCTION_CALL:
|
||
return Evaluator.CallFunction(cell, node);
|
||
case STNodeType.ADD:
|
||
{
|
||
bool flag8 = node.Children.Count < 2;
|
||
if (flag8)
|
||
{
|
||
return FormulaValue.Nil;
|
||
}
|
||
FormulaValue formulaValue3 = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(workbook, cell, node[0]));
|
||
FormulaValue formulaValue4 = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(workbook, cell, node[1]));
|
||
bool flag9 = formulaValue3.type != FormulaValueType.Number || formulaValue4.type != FormulaValueType.Number;
|
||
if (flag9)
|
||
{
|
||
throw new FormulaTypeMismatchException(cell);
|
||
}
|
||
return (double)formulaValue3.value + (double)formulaValue4.value;
|
||
}
|
||
case STNodeType.SUB:
|
||
{
|
||
bool flag10 = node.Children.Count < 2;
|
||
if (flag10)
|
||
{
|
||
return FormulaValue.Nil;
|
||
}
|
||
FormulaValue formulaValue5 = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(cell, node[0]));
|
||
FormulaValue formulaValue6 = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(cell, node[1]));
|
||
bool flag11 = formulaValue5.type != FormulaValueType.Number || formulaValue6.type != FormulaValueType.Number;
|
||
if (flag11)
|
||
{
|
||
throw new FormulaTypeMismatchException(cell);
|
||
}
|
||
return (double)formulaValue5.value - (double)formulaValue6.value;
|
||
}
|
||
case STNodeType.MUL:
|
||
{
|
||
bool flag12 = node.Children.Count < 2;
|
||
if (flag12)
|
||
{
|
||
return FormulaValue.Nil;
|
||
}
|
||
FormulaValue formulaValue7 = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(workbook, cell, node[0]));
|
||
FormulaValue formulaValue8 = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(workbook, cell, node[1]));
|
||
bool flag13 = formulaValue7.type != FormulaValueType.Number || formulaValue8.type != FormulaValueType.Number;
|
||
if (flag13)
|
||
{
|
||
throw new FormulaTypeMismatchException(cell);
|
||
}
|
||
return (double)formulaValue7.value * (double)formulaValue8.value;
|
||
}
|
||
case STNodeType.DIV:
|
||
{
|
||
bool flag14 = node.Children.Count < 2;
|
||
if (flag14)
|
||
{
|
||
return FormulaValue.Nil;
|
||
}
|
||
FormulaValue formulaValue9 = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(workbook, cell, node[0]));
|
||
FormulaValue formulaValue10 = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(workbook, cell, node[1]));
|
||
bool flag15 = formulaValue9.type != FormulaValueType.Number || formulaValue10.type != FormulaValueType.Number;
|
||
if (flag15)
|
||
{
|
||
throw new FormulaTypeMismatchException(cell);
|
||
}
|
||
return (double)formulaValue9.value / (double)formulaValue10.value;
|
||
}
|
||
case STNodeType.POW:
|
||
{
|
||
bool flag16 = node.Children.Count < 2;
|
||
if (flag16)
|
||
{
|
||
return FormulaValue.Nil;
|
||
}
|
||
FormulaValue formulaValue11 = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(workbook, cell, node[0]));
|
||
FormulaValue formulaValue12 = Evaluator.CheckAndGetDefaultValue(cell, Evaluator.Evaluate(workbook, cell, node[1]));
|
||
bool flag17 = formulaValue11.type != FormulaValueType.Number || formulaValue12.type != FormulaValueType.Number;
|
||
if (flag17)
|
||
{
|
||
throw new FormulaTypeMismatchException(cell);
|
||
}
|
||
return Math.Pow((double)formulaValue11.value, (double)formulaValue12.value);
|
||
}
|
||
case STNodeType.EQUALS:
|
||
{
|
||
FormulaValue formulaValue13 = Evaluator.Evaluate(workbook, cell, node[0]);
|
||
FormulaValue formulaValue14 = Evaluator.Evaluate(workbook, cell, node[1]);
|
||
bool flag18 = formulaValue13.type != formulaValue14.type;
|
||
if (flag18)
|
||
{
|
||
return false;
|
||
}
|
||
switch (formulaValue13.type)
|
||
{
|
||
case FormulaValueType.Boolean:
|
||
return (bool)formulaValue13.value == (bool)formulaValue14.value;
|
||
case FormulaValueType.Number:
|
||
return (double)formulaValue13.value == (double)formulaValue14.value;
|
||
case FormulaValueType.String:
|
||
return (string)formulaValue13.value == (string)formulaValue14.value;
|
||
default:
|
||
return false;
|
||
}
|
||
break;
|
||
}
|
||
case STNodeType.NOT_EQUALS:
|
||
{
|
||
FormulaValue formulaValue15 = Evaluator.Evaluate(workbook, cell, node[0]);
|
||
FormulaValue formulaValue16 = Evaluator.Evaluate(workbook, cell, node[1]);
|
||
bool flag19 = formulaValue15.type != formulaValue16.type;
|
||
if (flag19)
|
||
{
|
||
return true;
|
||
}
|
||
switch (formulaValue15.type)
|
||
{
|
||
case FormulaValueType.Boolean:
|
||
return (bool)formulaValue15.value != (bool)formulaValue16.value;
|
||
case FormulaValueType.Number:
|
||
return (double)formulaValue15.value != (double)formulaValue16.value;
|
||
case FormulaValueType.String:
|
||
return (string)formulaValue15.value != (string)formulaValue16.value;
|
||
default:
|
||
return true;
|
||
}
|
||
break;
|
||
}
|
||
case STNodeType.GREAT_THAN:
|
||
case STNodeType.GREAT_EQUALS:
|
||
{
|
||
FormulaValue formulaValue17 = Evaluator.Evaluate(workbook, cell, node[0]);
|
||
FormulaValue formulaValue18 = Evaluator.Evaluate(workbook, cell, node[1]);
|
||
bool flag20 = formulaValue17.type == FormulaValueType.Number && formulaValue18.type == FormulaValueType.Number;
|
||
if (flag20)
|
||
{
|
||
return (node.Type == STNodeType.GREAT_EQUALS) ? ((double)formulaValue17.value >= (double)formulaValue18.value) : ((double)formulaValue17.value > (double)formulaValue18.value);
|
||
}
|
||
bool flag21 = formulaValue17.type == FormulaValueType.String || formulaValue18.type == FormulaValueType.String;
|
||
if (flag21)
|
||
{
|
||
string strA = (formulaValue17.type == FormulaValueType.String) ? ((string)formulaValue17.value) : Convert.ToString(formulaValue17.value);
|
||
string strB = (formulaValue18.type == FormulaValueType.String) ? ((string)formulaValue18.value) : Convert.ToString(formulaValue18.value);
|
||
return (node.Type == STNodeType.GREAT_EQUALS) ? (string.Compare(strA, strB) >= 0) : (string.Compare(strA, strB) > 0);
|
||
}
|
||
bool flag22 = formulaValue17.type == FormulaValueType.Boolean && formulaValue18.type == FormulaValueType.Boolean;
|
||
if (flag22)
|
||
{
|
||
return (node.Type == STNodeType.GREAT_EQUALS) ? ((((bool)formulaValue17.value) ? 1 : 0) >= (((bool)formulaValue18.value) ? 1 : 0)) : ((((bool)formulaValue17.value) ? 1 : 0) > (((bool)formulaValue18.value) ? 1 : 0));
|
||
}
|
||
return false;
|
||
}
|
||
case STNodeType.LESS_THAN:
|
||
case STNodeType.LESS_EQUALS:
|
||
{
|
||
FormulaValue formulaValue19 = Evaluator.Evaluate(workbook, cell, node[0]);
|
||
FormulaValue formulaValue20 = Evaluator.Evaluate(workbook, cell, node[1]);
|
||
bool flag23 = formulaValue19.type == FormulaValueType.Number && formulaValue20.type == FormulaValueType.Number;
|
||
if (flag23)
|
||
{
|
||
return (node.Type == STNodeType.LESS_EQUALS) ? ((double)formulaValue19.value <= (double)formulaValue20.value) : ((double)formulaValue19.value < (double)formulaValue20.value);
|
||
}
|
||
bool flag24 = formulaValue19.type == FormulaValueType.String || formulaValue20.type == FormulaValueType.String;
|
||
if (flag24)
|
||
{
|
||
string strA2 = (formulaValue19.type == FormulaValueType.String) ? ((string)formulaValue19.value) : Convert.ToString(formulaValue19.value);
|
||
string strB2 = (formulaValue20.type == FormulaValueType.String) ? ((string)formulaValue20.value) : Convert.ToString(formulaValue20.value);
|
||
return (node.Type == STNodeType.LESS_EQUALS) ? (string.Compare(strA2, strB2) <= 0) : (string.Compare(strA2, strB2) < 0);
|
||
}
|
||
bool flag25 = formulaValue19.type == FormulaValueType.Boolean && formulaValue20.type == FormulaValueType.Boolean;
|
||
if (flag25)
|
||
{
|
||
return (node.Type == STNodeType.LESS_EQUALS) ? ((((bool)formulaValue19.value) ? 1 : 0) <= (((bool)formulaValue20.value) ? 1 : 0)) : ((((bool)formulaValue19.value) ? 1 : 0) < (((bool)formulaValue20.value) ? 1 : 0));
|
||
}
|
||
return false;
|
||
}
|
||
case STNodeType.UNARY_MINUS:
|
||
{
|
||
FormulaValue formulaValue21 = Evaluator.Evaluate(workbook, cell, node[0]);
|
||
bool flag26 = formulaValue21.type != FormulaValueType.Number;
|
||
if (flag26)
|
||
{
|
||
throw new FormulaTypeMismatchException(cell);
|
||
}
|
||
return -(double)formulaValue21.value;
|
||
}
|
||
case STNodeType.UNARY_PERCENT:
|
||
{
|
||
FormulaValue formulaValue22 = Evaluator.Evaluate(workbook, cell, node[0]);
|
||
bool flag27 = formulaValue22.type != FormulaValueType.Number;
|
||
if (flag27)
|
||
{
|
||
throw new FormulaTypeMismatchException(cell);
|
||
}
|
||
return (double)formulaValue22.value / 100.0;
|
||
}
|
||
case STNodeType.SUB_EXPR:
|
||
return (node.Children.Count < 1) ? FormulaValue.Nil : Evaluator.Evaluate(workbook, cell, node[0]);
|
||
case STNodeType._FORMULA_VALUE:
|
||
return ((STValueNode)node).Value;
|
||
}
|
||
nil = FormulaValue.Nil;
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
internal static FormulaValue CheckAndGetDefaultValue(Cell cell, FormulaValue val)
|
||
{
|
||
bool flag = val.type == FormulaValueType.Nil;
|
||
FormulaValue result;
|
||
if (flag)
|
||
{
|
||
bool flag2 = FormulaExtension.EmptyCellReferenceProvider != null;
|
||
if (flag2)
|
||
{
|
||
result = Evaluator.CreateFormulaValue(FormulaExtension.EmptyCellReferenceProvider(cell.Worksheet, cell.InternalPos, null));
|
||
}
|
||
else
|
||
{
|
||
result = 0.0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
result = val;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
internal static FormulaValue CreateFormulaValue(Cell cell)
|
||
{
|
||
object obj = null;
|
||
bool flag = cell != null;
|
||
if (flag)
|
||
{
|
||
obj = cell.Data;
|
||
}
|
||
bool flag2 = obj == null;
|
||
FormulaValue result;
|
||
if (flag2)
|
||
{
|
||
result = FormulaValue.Nil;
|
||
}
|
||
else
|
||
{
|
||
result = Evaluator.CreateFormulaValue(obj);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
internal static FormulaValue CreateFormulaValue(object obj)
|
||
{
|
||
bool flag = obj == null;
|
||
FormulaValue result;
|
||
if (flag)
|
||
{
|
||
result = FormulaValue.Nil;
|
||
}
|
||
else
|
||
{
|
||
double num;
|
||
bool flag2 = CellUtility.TryGetNumberData(obj, out num);
|
||
if (flag2)
|
||
{
|
||
result = num;
|
||
}
|
||
else
|
||
{
|
||
bool flag3 = obj is string;
|
||
if (flag3)
|
||
{
|
||
result = (string)obj;
|
||
}
|
||
else
|
||
{
|
||
bool flag4 = obj is bool;
|
||
if (flag4)
|
||
{
|
||
result = (bool)obj;
|
||
}
|
||
else
|
||
{
|
||
bool flag5 = obj is DateTime;
|
||
if (flag5)
|
||
{
|
||
result = (DateTime)obj;
|
||
}
|
||
else
|
||
{
|
||
result = Convert.ToString(obj);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
internal static FormulaValue CallFunction(Cell cell, STNode node)
|
||
{
|
||
STFunctionNode stfunctionNode = (STFunctionNode)node;
|
||
bool flag = stfunctionNode == null || string.IsNullOrEmpty(stfunctionNode.Name);
|
||
FormulaValue nil;
|
||
if (flag)
|
||
{
|
||
nil = FormulaValue.Nil;
|
||
}
|
||
else
|
||
{
|
||
string name = stfunctionNode.Name;
|
||
string text = name;
|
||
uint num = PrivateImplementationDetails.ComputeStringHash(text);
|
||
FormulaValue[] functionArgs;
|
||
string text2;
|
||
int i;
|
||
DateTime b;
|
||
if (num <= 2417884890U)
|
||
{
|
||
if (num > 963988464U)
|
||
{
|
||
if (num > 1683223459U)
|
||
{
|
||
if (num <= 2013082377U)
|
||
{
|
||
if (num <= 1820608667U)
|
||
{
|
||
if (num != 1745587424U)
|
||
{
|
||
if (num != 1762353940U)
|
||
{
|
||
if (num != 1820608667U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ABS"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
return Math.Abs(Evaluator.GetFunctionNumberArg(cell, stfunctionNode.Children));
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "МЕСЯЦ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_16D3;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ОСТАТ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_149D;
|
||
}
|
||
}
|
||
else if (num != 1870609647U)
|
||
{
|
||
if (num != 1919111119U)
|
||
{
|
||
if (num != 2013082377U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "TRIM"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1C4C;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "SUMIF"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1080;
|
||
}
|
||
}
|
||
else if (!(text == "VLOOKUP"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else if (num <= 2263364763U)
|
||
{
|
||
if (num != 2095360516U)
|
||
{
|
||
if (num != 2166317526U)
|
||
{
|
||
if (num != 2263364763U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ROW"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1139;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "СЧЁТ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1012;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "OR"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_110D;
|
||
}
|
||
}
|
||
else if (num <= 2313237979U)
|
||
{
|
||
if (num != 2285537267U)
|
||
{
|
||
if (num != 2313237979U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ВРЕМЯ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_15C1;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ОКРВНИЗ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_11E8;
|
||
}
|
||
}
|
||
else if (num != 2362077734U)
|
||
{
|
||
if (num != 2417884890U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ВПР"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "POWER"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1319;
|
||
}
|
||
return ExcelFunctions.VLookup(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 3, 4));
|
||
}
|
||
if (num <= 1302945936U)
|
||
{
|
||
if (num <= 1109532211U)
|
||
{
|
||
if (num != 1047001532U)
|
||
{
|
||
if (num != 1105666343U)
|
||
{
|
||
if (num != 1109532211U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ТДАТА"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_150D;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "COLUMN"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_114C;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "COS"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
return Math.Cos(Evaluator.GetFunctionNumberArg(cell, stfunctionNode.Children));
|
||
}
|
||
}
|
||
else if (num != 1122648243U)
|
||
{
|
||
if (num != 1266810881U)
|
||
{
|
||
if (num != 1302945936U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "LOG10"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
double d = (double)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.Number, false);
|
||
return Math.Log10(d);
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "СЖПРОБЕЛЫ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1C4C;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ADDRESS"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_115F;
|
||
}
|
||
}
|
||
else if (num <= 1491660422U)
|
||
{
|
||
if (num != 1327090656U)
|
||
{
|
||
if (num != 1327115355U)
|
||
{
|
||
if (num != 1491660422U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "IF"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_10EC;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ПРАВСИМВ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_18F8;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "CEILING"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_11CD;
|
||
}
|
||
}
|
||
else if (num != 1661549938U)
|
||
{
|
||
if (num != 1661642285U)
|
||
{
|
||
if (num != 1683223459U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "MOD"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "SIN"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
return Math.Sin(Evaluator.GetFunctionNumberArg(cell, stfunctionNode.Children));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "МИНУТЫ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_174B;
|
||
}
|
||
IL_149D:
|
||
functionArgs = Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1);
|
||
bool flag2 = functionArgs[0].type != FormulaValueType.Number || functionArgs[1].type != FormulaValueType.Number;
|
||
if (flag2)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell);
|
||
}
|
||
return (double)functionArgs[0].value % (double)functionArgs[1].value;
|
||
IL_1C4C:
|
||
return ((string)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.String, false)).Trim();
|
||
}
|
||
if (num <= 475632249U)
|
||
{
|
||
if (num <= 149012991U)
|
||
{
|
||
if (num <= 91041491U)
|
||
{
|
||
if (num != 14998175U)
|
||
{
|
||
if (num != 47006193U)
|
||
{
|
||
if (num != 91041491U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "СЧЁТЗ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_102E;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "НАЙТИ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1B25;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ACOS"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
return Math.Acos(Evaluator.GetFunctionNumberArg(cell, stfunctionNode.Children));
|
||
}
|
||
}
|
||
else if (num != 121479417U)
|
||
{
|
||
if (num != 138799941U)
|
||
{
|
||
if (num != 149012991U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ATAN"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
return Math.Atan(Evaluator.GetFunctionNumberArg(cell, stfunctionNode.Children));
|
||
}
|
||
else if (!(text == "MID"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ЧАС"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1723;
|
||
}
|
||
}
|
||
else if (num <= 251570269U)
|
||
{
|
||
if (num != 154926889U)
|
||
{
|
||
if (num != 239465655U)
|
||
{
|
||
if (num != 251570269U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "SECOND"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1773;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "MIN"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_104A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ОКРВВЕРХ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_11CD;
|
||
}
|
||
}
|
||
else if (num != 272375920U)
|
||
{
|
||
if (num != 462935941U)
|
||
{
|
||
if (num != 475632249U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "MAX"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1065;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "RIGHT"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_18F8;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "LEFT"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1840;
|
||
}
|
||
}
|
||
else if (num <= 632323358U)
|
||
{
|
||
if (num <= 539513288U)
|
||
{
|
||
if (num != 486946535U)
|
||
{
|
||
if (num != 523493304U)
|
||
{
|
||
if (num != 539513288U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "SUM"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_FDC;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "TAN"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
return Math.Tan(Evaluator.GetFunctionNumberArg(cell, stfunctionNode.Children));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "И"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_10FA;
|
||
}
|
||
}
|
||
else if (num != 559698679U)
|
||
{
|
||
if (num != 582941476U)
|
||
{
|
||
if (num != 632323358U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "TODAY"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1567;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "TIME"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_15C1;
|
||
}
|
||
}
|
||
else if (!(text == "ПСТР"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else if (num <= 827996992U)
|
||
{
|
||
if (num != 688247133U)
|
||
{
|
||
if (num != 714880010U)
|
||
{
|
||
if (num != 827996992U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "СТЕПЕНЬ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1319;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "MILLISECOND"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_179B;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "DAY"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_16FB;
|
||
}
|
||
}
|
||
else if (num != 857216927U)
|
||
{
|
||
if (num != 955346867U)
|
||
{
|
||
if (num != 963988464U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ЕСЛИ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_10EC;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "COUNTIF"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_10B6;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ЕЧИСЛО"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1CD5;
|
||
}
|
||
functionArgs = Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 3, -1);
|
||
bool flag3 = functionArgs[0].type != FormulaValueType.String || functionArgs[1].type != FormulaValueType.Number || functionArgs[2].type != FormulaValueType.Number;
|
||
if (flag3)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell);
|
||
}
|
||
text2 = (string)functionArgs[0].value;
|
||
i = (int)((double)functionArgs[1].value);
|
||
bool flag4 = i > text2.Length;
|
||
if (flag4)
|
||
{
|
||
return null;
|
||
}
|
||
bool flag5 = i < 1;
|
||
if (flag5)
|
||
{
|
||
i = 1;
|
||
}
|
||
int num2 = (int)((double)functionArgs[2].value);
|
||
bool flag6 = i + num2 > text2.Length;
|
||
if (flag6)
|
||
{
|
||
num2 = text2.Length - i + 1;
|
||
}
|
||
return text2.Substring(i - 1, num2);
|
||
IL_10EC:
|
||
return ExcelFunctions.If(cell, stfunctionNode);
|
||
IL_11CD:
|
||
return ExcelFunctions.Ceiling(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, 2));
|
||
IL_1319:
|
||
functionArgs = Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1);
|
||
bool flag7 = functionArgs[0].type != FormulaValueType.Number || functionArgs[1].type != FormulaValueType.Number;
|
||
if (flag7)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell);
|
||
}
|
||
return Math.Pow((double)functionArgs[0].value, (double)functionArgs[1].value);
|
||
IL_15C1:
|
||
functionArgs = Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 3, -1);
|
||
bool flag8 = functionArgs[0].type != FormulaValueType.Number || functionArgs[1].type != FormulaValueType.Number || functionArgs[2].type != FormulaValueType.Number;
|
||
if (flag8)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell);
|
||
}
|
||
b = new DateTime(1900, 1, 1, (int)((double)functionArgs[0].value), (int)((double)functionArgs[1].value), (int)((double)functionArgs[2].value));
|
||
bool flag9 = cell.DataFormat == CellDataFormatFlag.General;
|
||
if (flag9)
|
||
{
|
||
cell.DataFormat = CellDataFormatFlag.DateTime;
|
||
cell.DataFormatArgs = new DateTimeDataFormatter.DateTimeFormatArgs
|
||
{
|
||
Format = "HH:mm:ss",
|
||
CultureName = "en-US"
|
||
};
|
||
}
|
||
return b;
|
||
IL_18F8:
|
||
functionArgs = Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1);
|
||
bool flag10 = functionArgs[0].type != FormulaValueType.String || functionArgs[1].type != FormulaValueType.Number;
|
||
if (flag10)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell);
|
||
}
|
||
text2 = (string)functionArgs[0].value;
|
||
i = (int)((double)functionArgs[1].value);
|
||
bool flag11 = text2 == null;
|
||
if (flag11)
|
||
{
|
||
return null;
|
||
}
|
||
bool flag12 = i >= text2.Length;
|
||
if (flag12)
|
||
{
|
||
return text2;
|
||
}
|
||
return text2.Substring(text2.Length - i);
|
||
}
|
||
else
|
||
{
|
||
if (num <= 3019137039U)
|
||
{
|
||
if (num > 2746049788U)
|
||
{
|
||
if (num <= 2906723303U)
|
||
{
|
||
if (num <= 2859438216U)
|
||
{
|
||
if (num != 2750919380U)
|
||
{
|
||
if (num != 2759112951U)
|
||
{
|
||
if (num != 2859438216U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "AVERAGE"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "СТОЛБЕЦ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_114C;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "COUNT"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1012;
|
||
}
|
||
}
|
||
else if (num != 2867742231U)
|
||
{
|
||
if (num != 2884519850U)
|
||
{
|
||
if (num != 2906723303U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "UPPER"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1AAC;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "NOT"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1120;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "NOW"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_150D;
|
||
}
|
||
}
|
||
else if (num <= 2949633753U)
|
||
{
|
||
if (num != 2928084627U)
|
||
{
|
||
if (num != 2942694112U)
|
||
{
|
||
if (num != 2949633753U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "СРЗНАЧ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ГОД"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_16AB;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ЕСЛИОШИБКА"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1C70;
|
||
}
|
||
}
|
||
else if (num <= 2990205990U)
|
||
{
|
||
if (num != 2983905456U)
|
||
{
|
||
if (num != 2990205990U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ОКРУГЛ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_11B2;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ISNUMBER"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1CD5;
|
||
}
|
||
}
|
||
else if (num != 3018727567U)
|
||
{
|
||
if (num != 3019137039U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "HOUR"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1723;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "COUNTA"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_102E;
|
||
}
|
||
return ExcelFunctions.Average(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, -1));
|
||
}
|
||
if (num <= 2585027932U)
|
||
{
|
||
if (num <= 2490029789U)
|
||
{
|
||
if (num != 2439409094U)
|
||
{
|
||
if (num != 2475890929U)
|
||
{
|
||
if (num != 2490029789U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "СУММ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_FDC;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ПРОПИСН"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1AAC;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "AND"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_10FA;
|
||
}
|
||
}
|
||
else if (num != 2515996122U)
|
||
{
|
||
if (num != 2569648403U)
|
||
{
|
||
if (num != 2585027932U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "YEAR"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ДЕНЬ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_16FB;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "LOWER"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1AD4;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (num <= 2671091948U)
|
||
{
|
||
if (num != 2621144637U)
|
||
{
|
||
if (num != 2621437839U)
|
||
{
|
||
if (num != 2671091948U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ДНЕЙ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_17C3;
|
||
}
|
||
else if (!(text == "AVERAGEIF"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "FLOOR"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_11E8;
|
||
}
|
||
}
|
||
else if (num != 2715107524U)
|
||
{
|
||
if (num != 2720536842U)
|
||
{
|
||
if (num != 2746049788U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "СРЗНАЧЕСЛИ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "DAYS"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_17C3;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ИЛИ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_110D;
|
||
}
|
||
return ExcelFunctions.AverageIf(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1));
|
||
IL_17C3:
|
||
functionArgs = Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1);
|
||
bool flag13 = functionArgs[0].type != FormulaValueType.DateTime || functionArgs[1].type != FormulaValueType.DateTime;
|
||
if (flag13)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell);
|
||
}
|
||
return ((DateTime)functionArgs[0].value - (DateTime)functionArgs[1].value).TotalDays;
|
||
}
|
||
IL_16AB:
|
||
b = (DateTime)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.DateTime, false);
|
||
return (double)b.Year;
|
||
IL_1AAC:
|
||
text2 = (string)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.String, false);
|
||
return text2.ToUpper();
|
||
}
|
||
if (num <= 3331054833U)
|
||
{
|
||
if (num > 3076339336U)
|
||
{
|
||
if (num <= 3239514406U)
|
||
{
|
||
if (num != 3108329196U)
|
||
{
|
||
if (num != 3144808464U)
|
||
{
|
||
if (num != 3239514406U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ASIN"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
return Math.Asin(Evaluator.GetFunctionNumberArg(cell, stfunctionNode.Children));
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "МАКС"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1065;
|
||
}
|
||
}
|
||
else if (!(text == "LEN"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else if (num != 3257650481U)
|
||
{
|
||
if (num != 3320967873U)
|
||
{
|
||
if (num != 3331054833U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ДЛСТР"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ISERROR"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1C70;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "LOG"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
functionArgs = Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, 2);
|
||
bool flag14 = functionArgs.Length < 2;
|
||
if (flag14)
|
||
{
|
||
bool flag15 = functionArgs[0].type != FormulaValueType.Number;
|
||
if (flag15)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell);
|
||
}
|
||
return Math.Log((double)functionArgs[0].value);
|
||
}
|
||
else
|
||
{
|
||
bool flag16 = functionArgs[0].type != FormulaValueType.Number || functionArgs[1].type != FormulaValueType.Number;
|
||
if (flag16)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell);
|
||
}
|
||
return Math.Log((double)functionArgs[0].value, (double)functionArgs[1].value);
|
||
}
|
||
}
|
||
text2 = (string)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.String, false);
|
||
return (double)text2.Length;
|
||
}
|
||
if (num <= 3062220054U)
|
||
{
|
||
if (num != 3045201064U)
|
||
{
|
||
if (num != 3049592643U)
|
||
{
|
||
if (num != 3062220054U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "СЕГОДНЯ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1567;
|
||
}
|
||
else if (!(text == "ДВССЫЛ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "СУММЕСЛИ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1080;
|
||
}
|
||
}
|
||
else if (num != 3065124894U)
|
||
{
|
||
if (num != 3067563547U)
|
||
{
|
||
if (num != 3076339336U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "EXP"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
double d = (double)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.Number, false);
|
||
return Math.Exp(d);
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ROUND"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_11B2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "МИЛЛИСЕКУНДЫ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_179B;
|
||
}
|
||
}
|
||
else if (num <= 3931957582U)
|
||
{
|
||
if (num <= 3695410537U)
|
||
{
|
||
if (num != 3362002359U)
|
||
{
|
||
if (num != 3588602087U)
|
||
{
|
||
if (num != 3695410537U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "MINUTE"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_174B;
|
||
}
|
||
else if (!(text == "INDIRECT"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "ATAN2"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
functionArgs = Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1);
|
||
return (functionArgs[0].type != FormulaValueType.Number || functionArgs[1].type != FormulaValueType.Number) ? null : Math.Atan2((double)functionArgs[0].value, (double)functionArgs[1].value);
|
||
}
|
||
}
|
||
else if (num != 3843143976U)
|
||
{
|
||
if (num != 3865452901U)
|
||
{
|
||
if (num != 3931957582U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "ЛЕВСИМВ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1840;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "MONTH"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_16D3;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "СТРОЧН"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1AD4;
|
||
}
|
||
}
|
||
else if (num <= 4077460233U)
|
||
{
|
||
if (num != 3988786531U)
|
||
{
|
||
if (num != 4004896423U)
|
||
{
|
||
if (num != 4077460233U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "АДРЕС"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_115F;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "НЕ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1120;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "СЧЁТЕСЛИ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_10B6;
|
||
}
|
||
}
|
||
else if (num <= 4093515034U)
|
||
{
|
||
if (num != 4082792854U)
|
||
{
|
||
if (num != 4093515034U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "СТРОКА"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1139;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "СЕКУНДЫ"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1773;
|
||
}
|
||
}
|
||
else if (num != 4215454298U)
|
||
{
|
||
if (num != 4271776428U)
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
if (!(text == "МИН"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_104A;
|
||
}
|
||
else
|
||
{
|
||
if (!(text == "FIND"))
|
||
{
|
||
goto IL_1D6A;
|
||
}
|
||
goto IL_1B25;
|
||
}
|
||
return ExcelFunctions.Indirect(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, -1));
|
||
IL_1120:
|
||
return ExcelFunctions.Not(cell, stfunctionNode.Children[0]);
|
||
IL_11B2:
|
||
return ExcelFunctions.Round(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, 2));
|
||
IL_1AD4:
|
||
text2 = (string)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.String, false);
|
||
return text2.ToLower();
|
||
IL_1C70:
|
||
bool flag17 = stfunctionNode.Children == null || stfunctionNode.Children.Count < 1;
|
||
if (flag17)
|
||
{
|
||
return null;
|
||
}
|
||
try
|
||
{
|
||
Evaluator.Evaluate(cell, stfunctionNode.Children[0]);
|
||
return cell.formulaStatus > FormulaStatus.Normal;
|
||
}
|
||
catch (Exception)
|
||
{
|
||
return true;
|
||
}
|
||
goto IL_1CD5;
|
||
}
|
||
IL_FDC:
|
||
return ExcelFunctions.Sum(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, -1));
|
||
IL_1012:
|
||
return ExcelFunctions.Count(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, -1), false);
|
||
IL_102E:
|
||
return ExcelFunctions.Count(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, -1), true);
|
||
IL_104A:
|
||
return ExcelFunctions.Min(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, -1));
|
||
IL_1065:
|
||
return ExcelFunctions.Max(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, -1));
|
||
IL_1080:
|
||
return ExcelFunctions.SumIf(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1));
|
||
IL_10B6:
|
||
return ExcelFunctions.CountIf(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1));
|
||
IL_10FA:
|
||
return ExcelFunctions.And(cell, stfunctionNode.Children);
|
||
IL_110D:
|
||
return ExcelFunctions.Or(cell, stfunctionNode.Children);
|
||
IL_1139:
|
||
return ExcelFunctions.Row(cell, stfunctionNode.Children);
|
||
IL_114C:
|
||
return ExcelFunctions.Column(cell, stfunctionNode.Children);
|
||
IL_115F:
|
||
return ExcelFunctions.Address(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1));
|
||
IL_11E8:
|
||
return ExcelFunctions.Floor(cell, Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 1, 2));
|
||
IL_150D:
|
||
bool flag18 = cell.DataFormat == CellDataFormatFlag.General;
|
||
if (flag18)
|
||
{
|
||
cell.DataFormat = CellDataFormatFlag.DateTime;
|
||
cell.DataFormatArgs = new DateTimeDataFormatter.DateTimeFormatArgs
|
||
{
|
||
Format = "yyyy/MM/dd HH:mm",
|
||
CultureName = "en-US"
|
||
};
|
||
}
|
||
return DateTime.Now;
|
||
IL_1567:
|
||
bool flag19 = cell.DataFormat == CellDataFormatFlag.General;
|
||
if (flag19)
|
||
{
|
||
cell.DataFormat = CellDataFormatFlag.DateTime;
|
||
cell.DataFormatArgs = new DateTimeDataFormatter.DateTimeFormatArgs
|
||
{
|
||
Format = "yyyy/MM/dd",
|
||
CultureName = "en-US"
|
||
};
|
||
}
|
||
return DateTime.Now;
|
||
IL_16D3:
|
||
b = (DateTime)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.DateTime, false);
|
||
return (double)b.Month;
|
||
IL_16FB:
|
||
b = (DateTime)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.DateTime, false);
|
||
return (double)b.Day;
|
||
IL_1723:
|
||
b = (DateTime)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.DateTime, false);
|
||
return (double)b.Hour;
|
||
IL_174B:
|
||
b = (DateTime)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.DateTime, false);
|
||
return (double)b.Minute;
|
||
IL_1773:
|
||
b = (DateTime)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.DateTime, false);
|
||
return (double)b.Second;
|
||
IL_179B:
|
||
b = (DateTime)Evaluator.GetFunctionArg(cell, stfunctionNode.Children, FormulaValueType.DateTime, false);
|
||
return (double)b.Millisecond;
|
||
IL_1840:
|
||
functionArgs = Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1);
|
||
bool flag20 = functionArgs[0].type != FormulaValueType.String || functionArgs[1].type != FormulaValueType.Number;
|
||
if (flag20)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell);
|
||
}
|
||
text2 = (string)functionArgs[0].value;
|
||
i = (int)((double)functionArgs[1].value);
|
||
bool flag21 = text2 == null;
|
||
if (flag21)
|
||
{
|
||
return null;
|
||
}
|
||
bool flag22 = i >= text2.Length;
|
||
if (flag22)
|
||
{
|
||
return text2;
|
||
}
|
||
return text2.Substring(0, i);
|
||
IL_1B25:
|
||
functionArgs = Evaluator.GetFunctionArgs(cell, stfunctionNode.Children, 2, -1);
|
||
bool flag23 = functionArgs[0].type != FormulaValueType.String || functionArgs[1].type != FormulaValueType.String;
|
||
if (flag23)
|
||
{
|
||
return null;
|
||
}
|
||
bool flag24 = functionArgs.Length > 2;
|
||
if (flag24)
|
||
{
|
||
bool flag25 = functionArgs[2].type != FormulaValueType.Number;
|
||
if (flag25)
|
||
{
|
||
return null;
|
||
}
|
||
i = (int)functionArgs[2];
|
||
bool flag26 = i < 1;
|
||
if (flag26)
|
||
{
|
||
i = 1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
i = 1;
|
||
}
|
||
text2 = (string)functionArgs[0].value;
|
||
string text3 = (string)functionArgs[1].value;
|
||
bool flag27 = text2 == null || text2.Length <= 0 || text3 == null || text3.Length <= 0 || i > text3.Length;
|
||
if (flag27)
|
||
{
|
||
return 0.0;
|
||
}
|
||
return (double)(text3.IndexOf(text2, i - 1) + 1);
|
||
IL_1CD5:
|
||
bool flag28 = stfunctionNode.Children == null || stfunctionNode.Children.Count < 1;
|
||
if (flag28)
|
||
{
|
||
return false;
|
||
}
|
||
bool flag29 = stfunctionNode.Children[0].Type == STNodeType.NUMBER;
|
||
if (flag29)
|
||
{
|
||
return true;
|
||
}
|
||
FormulaValue formulaValue = Evaluator.Evaluate(cell, stfunctionNode.Children[0]);
|
||
bool flag30 = formulaValue.type == FormulaValueType.Number;
|
||
if (flag30)
|
||
{
|
||
return true;
|
||
}
|
||
return false;
|
||
IL_1D6A:
|
||
bool flag31 = FormulaExtension.customFunctions != null;
|
||
if (flag31)
|
||
{
|
||
Func<Cell, object[], object> func;
|
||
bool flag32 = FormulaExtension.customFunctions.TryGetValue(stfunctionNode.Name, out func);
|
||
if (flag32)
|
||
{
|
||
object[] array = new object[(stfunctionNode.Children == null) ? 0 : stfunctionNode.Children.Count];
|
||
for (i = 0; i < array.Length; i++)
|
||
{
|
||
array[i] = Evaluator.Evaluate(cell, stfunctionNode.Children[i]).value;
|
||
}
|
||
return Evaluator.CreateFormulaValue(func(cell, array));
|
||
}
|
||
}
|
||
nil = FormulaValue.Nil;
|
||
}
|
||
return nil;
|
||
}
|
||
|
||
private static FormulaValue[] GetFunctionArgs(Cell cell, List<STNode> argNodes, int min = -1, int max = -1)
|
||
{
|
||
int num = (argNodes == null) ? 0 : argNodes.Count;
|
||
bool flag = min > num;
|
||
if (flag)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell, string.Format("need at least {0} arguments but only {1} was given", min, num));
|
||
}
|
||
bool flag2 = max == -1 || max > num;
|
||
if (flag2)
|
||
{
|
||
max = num;
|
||
}
|
||
FormulaValue[] array = new FormulaValue[max];
|
||
int i = 0;
|
||
int num2 = 0;
|
||
while (i < max)
|
||
{
|
||
array[num2] = Evaluator.Evaluate(cell, argNodes[i]);
|
||
i++;
|
||
num2++;
|
||
}
|
||
return array;
|
||
}
|
||
|
||
private static double GetFunctionNumberArg(Cell cell, List<STNode> argNodes)
|
||
{
|
||
return (double)Evaluator.GetFunctionArg(cell, argNodes, FormulaValueType.Number, false);
|
||
}
|
||
|
||
private static string GetFunctionStringArg(Cell cell, List<STNode> argNodes)
|
||
{
|
||
return (string)Evaluator.GetFunctionArg(cell, argNodes, FormulaValueType.String, true);
|
||
}
|
||
|
||
private static object GetFunctionArg(Cell cell, List<STNode> argNodes, FormulaValueType type, bool allowConvert = false)
|
||
{
|
||
bool flag = argNodes.Count < 1;
|
||
if (flag)
|
||
{
|
||
throw new FormulaParameterMismatchException(cell, "Function needs at least one argument");
|
||
}
|
||
FormulaValue formulaValue = Evaluator.Evaluate(cell, argNodes[0]);
|
||
bool flag2 = formulaValue.type != type;
|
||
if (flag2)
|
||
{
|
||
if (allowConvert)
|
||
{
|
||
if (type == FormulaValueType.String)
|
||
{
|
||
return Convert.ToString(formulaValue.value);
|
||
}
|
||
}
|
||
throw new FormulaTypeMismatchException(cell);
|
||
}
|
||
return formulaValue.value;
|
||
}
|
||
|
||
internal static Worksheet GetWorksheetFromValue(Cell ownerCell, FormulaValue val)
|
||
{
|
||
Worksheet worksheet = null;
|
||
bool flag = val.type == FormulaValueType.Cell;
|
||
if (flag)
|
||
{
|
||
worksheet = ((SheetCellPosition)val.value).Worksheet;
|
||
}
|
||
else
|
||
{
|
||
bool flag2 = val.type == FormulaValueType.Range;
|
||
if (flag2)
|
||
{
|
||
worksheet = ((SheetRangePosition)val.value).Worksheet;
|
||
}
|
||
}
|
||
return (worksheet == null) ? ownerCell.Worksheet : worksheet;
|
||
}
|
||
|
||
internal static IFunctionNameProvider functionNameProvider = new StandardFunctionNameProvider();
|
||
}
|
||
}
|