/**
* Gets the raw bytes for the formula. This will include the
* parsed tokens array. Used when copying spreadsheets
*
* @return the raw record data
* @exception FormulaException
*/
public override byte[] getFormulaData()
{
if (!getSheet().getWorkbookBof().isBiff8())
{
throw new FormulaException(FormulaException.BIFF8_SUPPORTED);
}
// Get the tokens, taking into account the mapping from shared
// formula specific values into normal values
FormulaParser fp = new FormulaParser
(getTokens(), this,
getExternalSheet(), getNameTable(),
getSheet().getWorkbook().getSettings());
fp.parse();
byte[] rpnTokens = fp.getBytes();
byte[] data = new byte[rpnTokens.Length + 22];
// Set the standard info for this cell
IntegerHelper.getTwoBytes(getRow(), data, 0);
IntegerHelper.getTwoBytes(getColumn(), data, 2);
IntegerHelper.getTwoBytes(getXFIndex(), data, 4);
// Set the two most significant bytes of the value to be 0xff in
// order to identify this as a string
data[6] = 0;
data[12] = (byte)0xff;
data[13] = (byte)0xff;
// Now copy in the parsed tokens
System.Array.Copy(rpnTokens, 0, data, 22, rpnTokens.Length);
IntegerHelper.getTwoBytes(rpnTokens.Length, data, 20);
// Lop off the standard information
byte[] d = new byte[data.Length - 6];
System.Array.Copy(data, 6, d, 0, data.Length - 6);
return(d);
}
/**
* Initializes the string and the formula bytes. In order to get
* access to the workbook settings, the object is not initialized until
* it is added to the sheet
*
* @param ws the workbook settings
* @param es the external sheet
* @param nt the name table
*/
private void initialize(WorkbookSettings ws, ExternalSheet es,
WorkbookMethods nt)
{
if (copiedFrom != null)
{
initializeCopiedFormula(ws, es, nt);
return;
}
parser = new FormulaParser(formulaToParse, es, nt, ws);
try
{
parser.parse();
formulaString = parser.getFormula();
formulaBytes = parser.getBytes();
}
catch (FormulaException e)
{
//logger.warn(e.Message + " when parsing formula " + formulaToParse + " in cell " +
// getSheet().getName() + "!" +
// CellReferenceHelper.getCellReference(getColumn(), getRow()));
try
{
// try again, with an error formula
formulaToParse = "ERROR(1)";
parser = new FormulaParser(formulaToParse, es, nt, ws);
parser.parse();
formulaString = parser.getFormula();
formulaBytes = parser.getBytes();
}
catch (FormulaException e2)
{
// fail silently
//logger.error(string.Empty, e2);
}
}
}
private static void CalcChain(ExcelWorkbook wb, FormulaParser parser, DependencyChain dc)
{
foreach (var ix in dc.CalcOrder)
{
var item = dc.list[ix];
try
{
var ws = wb.Worksheets.GetBySheetID(item.SheetID);
var v = parser.ParseCell(item.Tokens, ws == null ? "" : ws.Name, item.Row, item.Column);
SetValue(wb, item, v);
}
catch (FormatException fe)
{
throw (fe);
}
catch (Exception e)
{
var error = ExcelErrorValue.Parse(ExcelErrorValue.Values.Value);
SetValue(wb, item, error);
}
}
}
public void RunTest()
{
var parserInstance = new FormulaParser();
var builder = new ParserBuilder <FormulaToken, IFormula>();
var parserResult = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "formulae");
Assert.True(parserResult.IsOk);
var source = @"
aaa = -1 * (bbb + 1)
bbb = ccc + 2
ccc = 3 + 3
";
var t = parserResult.Result.Parse(source);
Assert.True(t.IsOk);
var form = t.Result as Formulae;
var depBuilder = new Dependencies();
bool isCyclic = depBuilder.Build(t.Result as Formulae);
Assert.False(isCyclic);
var checker = new TypeChecker();
checker.Type(form, depBuilder.DependenciesDictionary);
var formulaeEngine = new FormulaeEngine(depBuilder, form);
Assert.Equal(6.0, formulaeEngine.GetValue("ccc"));
Assert.Equal(8.0, formulaeEngine.GetValue("bbb"));
Assert.Equal(-9.0, formulaeEngine.GetValue("aaa"));
formulaeEngine.Set("ccc", 10.0);
Assert.Equal(10.0, formulaeEngine.GetValue("ccc"));
Assert.Equal(12.0, formulaeEngine.GetValue("bbb"));
Assert.Equal(-13.0, formulaeEngine.GetValue("aaa"));
}
/**
* Error formula specific exception handling. Can't really create
* a formula (as it will look for a cell of that name, so just
* create a STRING record containing the contents
*
* @return the bodged data
*/
public override byte[] handleFormulaException()
{
byte[] expressiondata = null;
byte[] celldata = base.getCellData();
// Generate an appropriate dummy formula
WritableWorkbookImpl w = getSheet().getWorkbook();
FormulaParser parser = new FormulaParser(getValue().ToString(), w, w, w.getSettings());
// Get the bytes for the dummy formula
try
{
parser.parse();
}
catch (FormulaException e2)
{
//logger.warn(e2.Message);
}
byte[] formulaBytes = parser.getBytes();
expressiondata = new byte[formulaBytes.Length + 16];
IntegerHelper.getTwoBytes(formulaBytes.Length, expressiondata, 14);
System.Array.Copy(formulaBytes, 0, expressiondata, 16,
formulaBytes.Length);
// Set the recalculate on load bit
expressiondata[8] |= 0x02;
byte[] data = new byte[celldata.Length +
expressiondata.Length];
System.Array.Copy(celldata, 0, data, 0, celldata.Length);
System.Array.Copy(expressiondata, 0, data,
celldata.Length, expressiondata.Length);
// Store the value in the formula
DoubleHelper.getIEEEBytes(getValue(), data, 6);
return(data);
}
private static void CalcChain(ExcelWorkbook wb, FormulaParser parser, DependencyChain dc, ExcelCalculationOption options)
{
wb.FormulaParser.Configure(config =>
{
config.AllowCircularReferences = options.AllowCircularReferences;
config.PrecisionAndRoundingStrategy = options.PrecisionAndRoundingStrategy;
});
var debug = parser.Logger != null;
foreach (var ix in dc.CalcOrder)
{
var item = dc.list[ix];
try
{
var ws = wb.Worksheets.GetBySheetID(item.SheetID);
var v = parser.ParseCell(item.Tokens, ws == null ? "" : ws.Name, item.Row, item.Column);
SetValue(wb, item, v);
if (debug)
{
parser.Logger.LogCellCounted();
}
Thread.Sleep(0);
}
catch (FormatException fe)
{
throw (fe);
}
catch (CircularReferenceException cre)
{
throw cre;
}
catch (Exception e)
{
var error = ExcelErrorValue.Parse(ExcelErrorValue.Values.Value);
SetValue(wb, item, error);
}
}
}
public void TestConvertSharedFormulas()
{
IWorkbook wb = new HSSFWorkbook();
HSSFEvaluationWorkbook fpb = HSSFEvaluationWorkbook.Create(wb);
Ptg[] sharedFormula, ConvertedFormula;
SharedFormula sf = new SharedFormula(SpreadsheetVersion.EXCEL97);
sharedFormula = FormulaParser.Parse("A2", fpb, FormulaType.Cell, -1, -1);
ConvertedFormula = sf.ConvertSharedFormulas(sharedFormula, 0, 0);
ConfirmOperandClasses(sharedFormula, ConvertedFormula);
//conversion relative to [0,0] should return the original formula
Assert.AreEqual(FormulaRenderer.ToFormulaString(fpb, ConvertedFormula), "A2");
ConvertedFormula = sf.ConvertSharedFormulas(sharedFormula, 1, 0);
ConfirmOperandClasses(sharedFormula, ConvertedFormula);
//one row down
Assert.AreEqual(FormulaRenderer.ToFormulaString(fpb, ConvertedFormula), "A3");
ConvertedFormula = sf.ConvertSharedFormulas(sharedFormula, 1, 1);
ConfirmOperandClasses(sharedFormula, ConvertedFormula);
//one row down and one cell right
Assert.AreEqual(FormulaRenderer.ToFormulaString(fpb, ConvertedFormula), "B3");
sharedFormula = FormulaParser.Parse("SUM(A1:C1)", fpb, FormulaType.Cell, -1, -1);
ConvertedFormula = sf.ConvertSharedFormulas(sharedFormula, 0, 0);
ConfirmOperandClasses(sharedFormula, ConvertedFormula);
Assert.AreEqual(FormulaRenderer.ToFormulaString(fpb, ConvertedFormula), "SUM(A1:C1)");
ConvertedFormula = sf.ConvertSharedFormulas(sharedFormula, 1, 0);
ConfirmOperandClasses(sharedFormula, ConvertedFormula);
Assert.AreEqual(FormulaRenderer.ToFormulaString(fpb, ConvertedFormula), "SUM(A2:C2)");
ConvertedFormula = sf.ConvertSharedFormulas(sharedFormula, 1, 1);
ConfirmOperandClasses(sharedFormula, ConvertedFormula);
Assert.AreEqual(FormulaRenderer.ToFormulaString(fpb, ConvertedFormula), "SUM(B2:D2)");
}
/**
* Parse cell formula and re-assemble it back using the specified FormulaRenderingWorkbook.
*
* @param cell the cell to update
* @param frwb the formula rendering workbbok that returns new sheet name
*/
private void UpdateFormula(XSSFCell cell, String oldName, String newName)
{
CT_CellFormula f = cell.GetCTCell().f;
if (f != null)
{
String formula = f.Value;
if (formula != null && formula.Length > 0)
{
int sheetIndex = _wb.GetSheetIndex(cell.Sheet);
Ptg[] ptgs = FormulaParser.Parse(formula, _fpwb, FormulaType.Cell, sheetIndex, -1);
foreach (Ptg ptg in ptgs)
{
UpdatePtg(ptg, oldName, newName);
}
String updatedFormula = FormulaRenderer.ToFormulaString(_fpwb, ptgs);
if (!formula.Equals(updatedFormula))
{
f.Value = (updatedFormula);
}
}
}
}
public void TestRunCostumVisitor()
{
var variables = new Dictionary <string, double>
{
["x"] = 2
};
var parser = FormulaParser.Create();
var node = parser.Parse("1 + 2");
var transformedNode1 = parser.RunVisitor(node, new SwitchPlusAndMinus());
var transformedNode2 = parser.RunVisitor("1 + 2", new SwitchPlusAndMinus());
var transformedNode3 = parser.RunVisitor("1 + x", new SwitchPlusAndMinus(), variables);
foreach (var transformedNode in new[] { transformedNode1, transformedNode2, transformedNode3 })
{
var result = parser.Evaluate(transformedNode, variables);
Assert.AreEqual(-1.0, result.Value);
}
}
public void TestAddFunction()
{
var parser = FormulaParser.CreateBuilder()
.ConfigureFunctions(functions =>
{
functions.Add("MyFunction0", () => 0);
functions.Add("MyFunction1", a => a);
functions.Add("MyFunction2", (a, b) => a + b);
functions.Add("MyFunction3", (a, b, c) => a + b + c);
functions.Add("MyFunction4", (a, b, c, d) => a + b + c + d);
functions.Add("MyFunction5", (a, b, c, d, e) => a + b + c + d + e);
functions.Add("MyFunctionN", args => args.Aggregate((x, y) => x + y));
})
.Build();
Assert.AreEqual(0.0, parser.Evaluate("MyFunction0()").Value);
Assert.AreEqual(1.0, parser.Evaluate("MyFunction1(1)").Value);
Assert.AreEqual(3.0, parser.Evaluate("MyFunction2(1, 2)").Value);
Assert.AreEqual(6.0, parser.Evaluate("MyFunction3(1, 2, 3)").Value);
Assert.AreEqual(10.0, parser.Evaluate("MyFunction4(1, 2, 3, 4)").Value);
Assert.AreEqual(15.0, parser.Evaluate("MyFunction5(1, 2, 3, 4, 5)").Value);
Assert.AreEqual(55.0, parser.Evaluate("MyFunctionN(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)").Value);
}
public void TestCase002()
{
bool equal;
int retVal = Constants.Failure;
string errorMsg = string.Empty;
double expectedElementComposition;
string Formula = "C8H8ClNO3S", formulaSummary;
double expectedMolarMass = 233.68, actualMolarMass;
Dictionary <string, double> expectedComposition = new Dictionary <string, double>()
{
{ "C", 41.12 },
{ "H", 3.45 },
{ "Cl", 15.17 },
{ "N", 5.99 },
{ "O", 20.45 },
{ "S", 13.72 },
};
FormulaParser parser = new FormulaParser();
retVal = parser.SetFormula(Formula, out formulaSummary, out actualMolarMass);
Assert.AreEqual(Constants.Success, retVal);
equal = Math.Abs(expectedMolarMass - actualMolarMass) <= allowedDifference;
Assert.IsTrue(equal);
IDictionary <string, double> actualComposition = parser.ParseElements(out retVal);
Assert.AreEqual(Constants.Success, retVal);
Assert.AreEqual(expectedComposition.Count, actualComposition.Count);
foreach (KeyValuePair <string, double> kvp in actualComposition)
{
expectedElementComposition = expectedComposition[kvp.Key];
equal = Math.Abs(expectedElementComposition - kvp.Value) <= allowedDifference;
Assert.IsTrue(equal);
}
}
public void TestConfigureRegistry()
{
var parser = FormulaParser
.CreateBuilder()
.ConfigureFunctions(functions =>
{
functions.RemoveAll();
functions.Add("sum", args => args.Aggregate((x, y) => x + y));
functions.Add("avg", args => args.Average());
})
.ConfigureConstats(constants =>
{
constants.RemoveAll();
constants.Add("X", 1);
constants.Add("Y", 2);
constants.Add("Z", 3);
})
.Build();
var result = parser.Evaluate("sum(X, Y, Z, 100)");
Assert.IsTrue(result.Success, string.Join(", ", (string)result.Error));
Assert.AreEqual(106.0, result.Value);
}
public void TestCase003()
{
bool equal;
int retVal = Constants.Failure;
string errorMsg = string.Empty;
double expectedElementComposition;
string Formula = "C8H7HgNaO3", formulaSummary;
double expectedMolarMass = 374.74, actualMolarMass;
Dictionary <string, double> expectedComposition = new Dictionary <string, double>()
{
{ "C", 25.64 },
{ "H", 1.88 },
{ "Hg", 53.53 },
{ "Na", 6.14 },
{ "O", 12.81 }
};
FormulaParser parser = new FormulaParser();
retVal = parser.SetFormula(Formula, out formulaSummary, out actualMolarMass);
Assert.AreEqual(Constants.Success, retVal);
equal = Math.Abs(expectedMolarMass - actualMolarMass) <= allowedDifference;
Assert.IsTrue(equal);
IDictionary <string, double> actualComposition = parser.ParseElements(out retVal);
Assert.AreEqual(Constants.Success, retVal);
Assert.AreEqual(expectedComposition.Count, actualComposition.Count);
foreach (KeyValuePair <string, double> kvp in actualComposition)
{
expectedElementComposition = expectedComposition[kvp.Key];
equal = Math.Abs(expectedElementComposition - kvp.Value) <= allowedDifference;
Assert.IsTrue(equal);
}
}
/**
* Shift a formula using the supplied FormulaShifter
*
* @param row the row of the cell this formula belongs to. Used to get a reference to the parent workbook.
* @param formula the formula to shift
* @param Shifter the FormulaShifter object that operates on the Parsed formula tokens
* @return the Shifted formula if the formula was Changed,
* <code>null</code> if the formula wasn't modified
*/
private static String ShiftFormula(XSSFRow row, String formula, FormulaShifter Shifter)
{
ISheet sheet = row.Sheet;
IWorkbook wb = sheet.Workbook;
int sheetIndex = wb.GetSheetIndex(sheet);
XSSFEvaluationWorkbook fpb = XSSFEvaluationWorkbook.Create(wb);
try
{
Ptg[] ptgs = FormulaParser.Parse(formula, fpb, FormulaType.Cell, sheetIndex);
String ShiftedFmla = null;
if (Shifter.AdjustFormula(ptgs, sheetIndex))
{
ShiftedFmla = FormulaRenderer.ToFormulaString(fpb, ptgs);
}
return(ShiftedFmla);
}
catch (FormulaParseException fpe)
{
// Log, but don't change, rather than breaking
Console.WriteLine("Error shifting formula on row {0}, {1}", row.RowNum, fpe);
return(formula);
}
}
public void TestCase008()
{
bool equal;
int retVal = Constants.Failure;
string errorMsg = string.Empty;
double expectedElementComposition;
string Formula = "C20H14CaO8S2", formulaSummary;
double expectedMolarMass = 486.54, actualMolarMass;
Dictionary <string, double> expectedComposition = new Dictionary <string, double>()
{
{ "C", 49.37 },
{ "H", 2.90 },
{ "Ca", 8.24 },
{ "S", 13.18 },
{ "O", 26.31 }
};
FormulaParser parser = new FormulaParser();
retVal = parser.SetFormula(Formula, out formulaSummary, out actualMolarMass);
Assert.AreEqual(Constants.Success, retVal);
equal = Math.Abs(expectedMolarMass - actualMolarMass) <= allowedDifference;
Assert.IsTrue(equal);
IDictionary <string, double> actualComposition = parser.ParseElements(out retVal);
Assert.AreEqual(Constants.Success, retVal);
Assert.AreEqual(expectedComposition.Count, actualComposition.Count);
foreach (KeyValuePair <string, double> kvp in actualComposition)
{
expectedElementComposition = expectedComposition[kvp.Key];
equal = Math.Abs(expectedElementComposition - kvp.Value) <= allowedDifference;
Assert.IsTrue(equal);
}
}
public void Setup()
{
var excelDataProvider = MockRepository.GenerateStub <ExcelDataProvider>();
_parser = new FormulaParser(excelDataProvider);
}
public static Ptg[] Parse(String formula, HSSFWorkbook book)
{
FormulaParser fp = new FormulaParser(formula, book);
fp.Parse();
return fp.GetRPNPtg();
}
public void UpdateConditionalFormatting(FormulaShifter Shifter)
{
IWorkbook workbook = this.sheet.Workbook;
int sheetIndex = workbook.GetSheetIndex((ISheet)this.sheet);
XSSFEvaluationWorkbook evaluationWorkbook = XSSFEvaluationWorkbook.Create(workbook);
List <CT_ConditionalFormatting> conditionalFormatting1 = this.sheet.GetCTWorksheet().conditionalFormatting;
for (int index1 = 0; conditionalFormatting1 != null && index1 < conditionalFormatting1.Count; ++index1)
{
CT_ConditionalFormatting conditionalFormatting2 = conditionalFormatting1[index1];
List <CellRangeAddress> cellRangeAddressList1 = new List <CellRangeAddress>();
foreach (object obj in conditionalFormatting2.sqref)
{
string str = obj.ToString();
char[] chArray = new char[1] {
' '
};
foreach (string reference in str.Split(chArray))
{
cellRangeAddressList1.Add(CellRangeAddress.ValueOf(reference));
}
}
bool flag = false;
List <CellRangeAddress> cellRangeAddressList2 = new List <CellRangeAddress>();
for (int index2 = 0; index2 < cellRangeAddressList1.Count; ++index2)
{
CellRangeAddress cra = cellRangeAddressList1[index2];
CellRangeAddress cellRangeAddress = XSSFRowShifter.ShiftRange(Shifter, cra, sheetIndex);
if (cellRangeAddress == null)
{
flag = true;
}
else
{
cellRangeAddressList2.Add(cellRangeAddress);
if (cellRangeAddress != cra)
{
flag = true;
}
}
}
if (flag)
{
if (cellRangeAddressList2.Count == 0)
{
conditionalFormatting1.RemoveAt(index1);
continue;
}
List <string> stringList = new List <string>();
foreach (CellRangeAddress cellRangeAddress in cellRangeAddressList2)
{
stringList.Add(cellRangeAddress.FormatAsString());
}
conditionalFormatting2.sqref = stringList;
}
foreach (CT_CfRule ctCfRule in conditionalFormatting2.cfRule)
{
List <string> formula = ctCfRule.formula;
for (int index2 = 0; index2 < formula.Count; ++index2)
{
Ptg[] ptgs = FormulaParser.Parse(formula[index2], (IFormulaParsingWorkbook)evaluationWorkbook, FormulaType.CELL, sheetIndex);
if (Shifter.AdjustFormula(ptgs, sheetIndex))
{
string formulaString = FormulaRenderer.ToFormulaString((IFormulaRenderingWorkbook)evaluationWorkbook, ptgs);
formula[index2] = formulaString;
}
}
}
}
}
/**
* @param formulaType a constant from {@link FormulaType}
* @return the parsed formula tokens
*/
public static Ptg[] Parse(string formula, HSSFWorkbook workbook, FormulaType formulaType)
{
return(FormulaParser.Parse(formula, CreateParsingWorkbook(workbook), formulaType));
}
private static Ptg[] Parse(IFormulaParsingWorkbook fpb, String fmla)
{
return(FormulaParser.Parse(fmla, fpb, FormulaType.Cell, -1));
}
public static Ptg[] Parse(String formula, FormulaParsingWorkbook workbook, int formulaType)
{
FormulaParser fp = new FormulaParser(formula, workbook);
fp.Parse();
return fp.GetRPNPtg(formulaType);
}
/**
* @param formula the formula to parse
* @param workbook the parent workbook
* @param formulaType a constant from {@link FormulaType}
* @param sheetIndex the 0-based index of the sheet this formula belongs to.
* The sheet index is required to resolve sheet-level names. <code>-1</code> means that
* the scope of the name will be ignored and the parser will match named ranges only by name
*
* @return the parsed formula tokens
*/
public static Ptg[] Parse(String formula, HSSFWorkbook workbook, FormulaType formulaType, int sheetIndex)
{
return(FormulaParser.Parse(formula, CreateParsingWorkbook(workbook), formulaType, sheetIndex));
}
private static Ptg[] Parse(XSSFEvaluationWorkbook fpb, String fmla)
{
return(FormulaParser.Parse(fmla, fpb, FormulaType.CELL, -1));
}
/**
* Parse a formula into a array of tokens
*
* @param formula the formula to parse
* @param workbook the parent workbook
* @param formulaType the type of the formula, see {@link FormulaType}
* @param sheetIndex the 0-based index of the sheet this formula belongs to.
* The sheet index is required to resolve sheet-level names. <code>-1</code> means that
* the scope of the name will be ignored and the parser will match names only by name
*
* @return array of parsed tokens
* @throws FormulaParseException if the formula is unparsable
*/
public static Ptg[] Parse(String formula, IFormulaParsingWorkbook workbook, FormulaType formulaType, int sheetIndex)
{
FormulaParser fp = new FormulaParser(formula, workbook, sheetIndex);
fp.Parse();
return fp.GetRPNPtg(formulaType);
}
private string ConvertSharedFormula(int si)
{
XSSFSheet sheet = (XSSFSheet)this.Sheet;
CT_CellFormula sharedFormula = sheet.GetSharedFormula(si);
if (sharedFormula == null)
{
throw new InvalidOperationException("Master cell of a shared formula with sid=" + (object)si + " was not found");
}
string formula = sharedFormula.Value;
CellRangeAddress cellRangeAddress = CellRangeAddress.ValueOf(sharedFormula.@ref);
int sheetIndex = sheet.Workbook.GetSheetIndex((ISheet)sheet);
XSSFEvaluationWorkbook evaluationWorkbook = XSSFEvaluationWorkbook.Create(sheet.Workbook);
Ptg[] ptgs = new SharedFormula(SpreadsheetVersion.EXCEL2007).ConvertSharedFormulas(FormulaParser.Parse(formula, (IFormulaParsingWorkbook)evaluationWorkbook, FormulaType.CELL, sheetIndex), this.RowIndex - cellRangeAddress.FirstRow, this.ColumnIndex - cellRangeAddress.FirstColumn);
return(FormulaRenderer.ToFormulaString((IFormulaRenderingWorkbook)evaluationWorkbook, ptgs));
}
/**
* Constructor
*/
public DVParser(byte[] data,
ExternalSheet es,
WorkbookMethods nt,
WorkbookSettings ws)
{
Assert.verify(nt != null);
wasCopied = false;
int options = IntegerHelper.getInt(data[0], data[1], data[2], data[3]);
int typeVal = options & 0xf;
type = DVType.getType(typeVal);
int errorStyleVal = (options & 0x70) >> 4;
errorStyle = ErrorStyle.getErrorStyle(errorStyleVal);
int conditionVal = (options & 0xf00000) >> 20;
condition = Condition.getCondition(conditionVal);
stringListGiven = (options & STRING_LIST_GIVEN_MASK) != 0;
emptyCellsAllowed = (options & EMPTY_CELLS_ALLOWED_MASK) != 0;
suppressArrow = (options & SUPPRESS_ARROW_MASK) != 0;
showPrompt = (options & SHOW_PROMPT_MASK) != 0;
showError = (options & SHOW_ERROR_MASK) != 0;
int pos = 4;
int length = IntegerHelper.getInt(data[pos], data[pos + 1]);
if (length > 0 && data[pos + 2] == 0)
{
promptTitle = StringHelper.getString(data, length, pos + 3, ws);
pos += length + 3;
}
else if (length > 0)
{
promptTitle = StringHelper.getUnicodeString(data, length, pos + 3);
pos += length * 2 + 3;
}
else
{
pos += 3;
}
length = IntegerHelper.getInt(data[pos], data[pos + 1]);
if (length > 0 && data[pos + 2] == 0)
{
errorTitle = StringHelper.getString(data, length, pos + 3, ws);
pos += length + 3;
}
else if (length > 0)
{
errorTitle = StringHelper.getUnicodeString(data, length, pos + 3);
pos += length * 2 + 3;
}
else
{
pos += 3;
}
length = IntegerHelper.getInt(data[pos], data[pos + 1]);
if (length > 0 && data[pos + 2] == 0)
{
promptText = StringHelper.getString(data, length, pos + 3, ws);
pos += length + 3;
}
else if (length > 0)
{
promptText = StringHelper.getUnicodeString(data, length, pos + 3);
pos += length * 2 + 3;
}
else
{
pos += 3;
}
length = IntegerHelper.getInt(data[pos], data[pos + 1]);
if (length > 0 && data[pos + 2] == 0)
{
errorText = StringHelper.getString(data, length, pos + 3, ws);
pos += length + 3;
}
else if (length > 0)
{
errorText = StringHelper.getUnicodeString(data, length, pos + 3);
pos += length * 2 + 3;
}
else
{
pos += 3;
}
int formula1Length = IntegerHelper.getInt(data[pos], data[pos + 1]);
pos += 4;
int formula1Pos = pos;
pos += formula1Length;
int formula2Length = IntegerHelper.getInt(data[pos], data[pos + 1]);
pos += 4;
int formula2Pos = pos;
pos += formula2Length;
pos += 2;
row1 = IntegerHelper.getInt(data[pos], data[pos + 1]);
pos += 2;
row2 = IntegerHelper.getInt(data[pos], data[pos + 1]);
pos += 2;
column1 = IntegerHelper.getInt(data[pos], data[pos + 1]);
pos += 2;
column2 = IntegerHelper.getInt(data[pos], data[pos + 1]);
pos += 2;
hasExtendedCellsValidation = (row1 == row2 && column1 == column2) ? false : true;
// Do the formulas
try
{
// First, create a temporary blank cell for any formula relative
// references
EmptyCell tmprt = new EmptyCell(column1, row1);
if (formula1Length != 0)
{
byte[] tokens = new byte[formula1Length];
System.Array.Copy(data, formula1Pos, tokens, 0, formula1Length);
formula1 = new FormulaParser(tokens, tmprt, es, nt, ws,
ParseContext.DATA_VALIDATION);
formula1.parse();
}
if (formula2Length != 0)
{
byte[] tokens = new byte[formula2Length];
System.Array.Copy(data, formula2Pos, tokens, 0, formula2Length);
formula2 = new FormulaParser(tokens, tmprt, es, nt, ws,
ParseContext.DATA_VALIDATION);
formula2.parse();
}
}
catch (FormulaException e)
{
//logger.warn(e.Message + " for cells " +
// CellReferenceHelper.getCellReference(column1,row1) + "-" +
// CellReferenceHelper.getCellReference(column2,row2));
}
}
public void UpdateConditionalFormatting(FormulaShifter Shifter)
{
IWorkbook wb = sheet.Workbook;
int sheetIndex = wb.GetSheetIndex(sheet);
XSSFEvaluationWorkbook fpb = XSSFEvaluationWorkbook.Create(wb);
CT_Worksheet ctWorksheet = sheet.GetCTWorksheet();
List <CT_ConditionalFormatting> conditionalFormattingArray = ctWorksheet.conditionalFormatting;
// iterate backwards due to possible calls to ctWorksheet.removeConditionalFormatting(j)
for (int j = conditionalFormattingArray.Count - 1; j >= 0; j--)
{
CT_ConditionalFormatting cf = conditionalFormattingArray[j];
List <CellRangeAddress> cellRanges = new List <CellRangeAddress>();
String[] regions = cf.sqref.ToString().Split(new char[] { ' ' });
for (int i = 0; i < regions.Length; i++)
{
cellRanges.Add(CellRangeAddress.ValueOf(regions[i]));
}
bool Changed = false;
List <CellRangeAddress> temp = new List <CellRangeAddress>();
for (int i = 0; i < cellRanges.Count; i++)
{
CellRangeAddress craOld = cellRanges[i];
CellRangeAddress craNew = ShiftRange(Shifter, craOld, sheetIndex);
if (craNew == null)
{
Changed = true;
continue;
}
temp.Add(craNew);
if (craNew != craOld)
{
Changed = true;
}
}
if (Changed)
{
int nRanges = temp.Count;
if (nRanges == 0)
{
conditionalFormattingArray.RemoveAt(j);
continue;
}
string refs = string.Empty;
foreach (CellRangeAddress a in temp)
{
if (refs.Length == 0)
{
refs = a.FormatAsString();
}
else
{
refs += " " + a.FormatAsString();
}
}
cf.sqref = refs;
}
foreach (CT_CfRule cfRule in cf.cfRule)
{
List <String> formulas = cfRule.formula;
for (int i = 0; i < formulas.Count; i++)
{
String formula = formulas[i];
Ptg[] ptgs = FormulaParser.Parse(formula, fpb, FormulaType.Cell, sheetIndex);
if (Shifter.AdjustFormula(ptgs, sheetIndex))
{
String ShiftedFmla = FormulaRenderer.ToFormulaString(fpb, ptgs);
formulas[i] = ShiftedFmla;
}
}
}
}
}
public void Setup()
{
var excelDataProvider = A.Fake <ExcelDataProvider>();
_parser = new FormulaParser(excelDataProvider);
}
/**
* Convenience method for parsing cell formulas. see {@link #parse(String, HSSFWorkbook, int)}
*/
public static Ptg[] Parse(String formula, HSSFWorkbook workbook)
{
return(FormulaParser.Parse(formula, CreateParsingWorkbook(workbook)));
}
protected override void DoQuickLoad(BinaryReader BR, FormulaParser ActiveParser)
{
base.DoQuickLoad(BR, ActiveParser);
LastEvaluationResult = BR.ReadString();
}
public Ptg[] getFormulaTokens(SXSSFEvaluationCell evalCell)
{
SXSSFCell cell = ((SXSSFEvaluationCell)evalCell).getSXSSFCell();
return(FormulaParser.Parse(cell.CellFormula, this, FormulaType.Cell, _uBook.GetSheetIndex(cell.Sheet)));
}
public AttackAnimations GetAttackAnimations(FormulaParser ActiveParser)
{
return(Animations[0].Animations);
}
public override void Attack(Direction direction, Castable castObject = null, Creature target = null)
{
if (target != null)
{
var damage = castObject.Effects.Damage;
if (damage.Formula == null) //will need to be expanded. also will need to account for damage scripts
{
var simple = damage.Simple;
var damageType = EnumUtil.ParseEnum<Enums.DamageType>(damage.Type.ToString(), Enums.DamageType.Magical);
Random rand = new Random();
var dmg = rand.Next(Convert.ToInt32(simple.Min), Convert.ToInt32(simple.Max)); //these need to be set to integers as attributes. note to fix.
target.Damage(dmg, OffensiveElement, damageType, this);
}
else
{
var formula = damage.Formula;
var damageType = EnumUtil.ParseEnum<Enums.DamageType>(damage.Type.ToString(), Enums.DamageType.Magical);
FormulaParser parser = new FormulaParser(this, castObject, target);
var dmg = parser.Eval(formula);
target.Damage(dmg, OffensiveElement, damageType, this);
}
}
}
public MainTest()
{
mParser = new FormulaParser();
}