// Fetch the workbook this refers to, and the name as defined with that
private ValueEval GetExternalNameXEval(ExternalName externName, String workbookName)
{
try
{
WorkbookEvaluator refWorkbookEvaluator = _bookEvaluator.GetOtherWorkbookEvaluator(workbookName);
IEvaluationName evaluationName = refWorkbookEvaluator.GetName(externName.Name, externName.Ix - 1);
if (evaluationName != null && evaluationName.HasFormula)
{
if (evaluationName.NameDefinition.Length > 1)
{
throw new Exception("Complex name formulas not supported yet");
}
// Need to Evaluate the reference in the context of the other book
OperationEvaluationContext refWorkbookContext = new OperationEvaluationContext(
refWorkbookEvaluator, refWorkbookEvaluator.Workbook, -1, -1, -1, _tracker);
Ptg ptg = evaluationName.NameDefinition[0];
if (ptg is Ref3DPtg)
{
Ref3DPtg ref3D = (Ref3DPtg)ptg;
return(refWorkbookContext.GetRef3DEval(ref3D));
}
else if (ptg is Ref3DPxg)
{
Ref3DPxg ref3D = (Ref3DPxg)ptg;
return(refWorkbookContext.GetRef3DEval(ref3D));
}
else if (ptg is Area3DPtg)
{
Area3DPtg area3D = (Area3DPtg)ptg;
return(refWorkbookContext.GetArea3DEval(area3D));
}
else if (ptg is Area3DPxg)
{
Area3DPxg area3D = (Area3DPxg)ptg;
return(refWorkbookContext.GetArea3DEval(area3D));
}
}
return(ErrorEval.REF_INVALID);
}
catch (WorkbookNotFoundException)
{
return(ErrorEval.REF_INVALID);
}
}
/**
* returns an appropriate Eval impl instance for the Ptg. The Ptg must be
* one of: Area3DPtg, AreaPtg, ReferencePtg, Ref3DPtg, IntPtg, NumberPtg,
* StringPtg, BoolPtg <br/>special Note: OperationPtg subtypes cannot be
* passed here!
*/
private ValueEval GetEvalForPtg(Ptg ptg, OperationEvaluationContext ec)
{
// consider converting all these (ptg is XxxPtg) expressions To (ptg.GetType() == XxxPtg.class)
if (ptg is NamePtg)
{
// named ranges, macro functions
NamePtg namePtg = (NamePtg)ptg;
IEvaluationName nameRecord = _workbook.GetName(namePtg);
if (nameRecord.IsFunctionName)
{
return(new NameEval(nameRecord.NameText));
}
if (nameRecord.HasFormula)
{
return(EvaluateNameFormula(nameRecord.NameDefinition, ec));
}
throw new Exception("Don't now how To evalate name '" + nameRecord.NameText + "'");
}
if (ptg is NameXPtg)
{
return(ec.GetNameXEval(((NameXPtg)ptg)));
}
if (ptg is IntPtg)
{
return(new NumberEval(((IntPtg)ptg).Value));
}
if (ptg is NumberPtg)
{
return(new NumberEval(((NumberPtg)ptg).Value));
}
if (ptg is StringPtg)
{
return(new StringEval(((StringPtg)ptg).Value));
}
if (ptg is BoolPtg)
{
return(BoolEval.ValueOf(((BoolPtg)ptg).Value));
}
if (ptg is ErrPtg)
{
return(ErrorEval.ValueOf(((ErrPtg)ptg).ErrorCode));
}
if (ptg is MissingArgPtg)
{
return(MissingArgEval.instance);
}
if (ptg is AreaErrPtg || ptg is RefErrorPtg ||
ptg is DeletedArea3DPtg || ptg is DeletedRef3DPtg)
{
return(ErrorEval.REF_INVALID);
}
if (ptg is Ref3DPtg)
{
Ref3DPtg rptg = (Ref3DPtg)ptg;
return(ec.GetRef3DEval(rptg.Row, rptg.Column, rptg.ExternSheetIndex));
}
if (ptg is Area3DPtg)
{
Area3DPtg aptg = (Area3DPtg)ptg;
return(ec.GetArea3DEval(aptg.FirstRow, aptg.FirstColumn, aptg.LastRow, aptg.LastColumn, aptg.ExternSheetIndex));
}
if (ptg is RefPtg)
{
RefPtg rptg = (RefPtg)ptg;
return(ec.GetRefEval(rptg.Row, rptg.Column));
}
if (ptg is AreaPtg)
{
AreaPtg aptg = (AreaPtg)ptg;
return(ec.GetAreaEval(aptg.FirstRow, aptg.FirstColumn, aptg.LastRow, aptg.LastColumn));
}
if (ptg is UnknownPtg)
{
// POI uses UnknownPtg when the encoded Ptg array seems To be corrupted.
// This seems To occur in very rare cases (e.g. unused name formulas in bug 44774, attachment 21790)
// In any case, formulas are re-parsed before execution, so UnknownPtg should not Get here
throw new RuntimeException("UnknownPtg not allowed");
}
if (ptg is ExpPtg)
{
// ExpPtg is used for array formulas and shared formulas.
// it is currently unsupported, and may not even get implemented here
throw new RuntimeException("ExpPtg currently not supported");
}
throw new RuntimeException("Unexpected ptg class (" + ptg.GetType().Name + ")");
}
/**
* Resolves a cell or area reference dynamically.
* @param workbookName the name of the workbook Containing the reference. If <code>null</code>
* the current workbook is assumed. Note - to Evaluate formulas which use multiple workbooks,
* a {@link CollaboratingWorkbooksEnvironment} must be set up.
* @param sheetName the name of the sheet Containing the reference. May be <code>null</code>
* (when <c>workbookName</c> is also null) in which case the current workbook and sheet is
* assumed.
* @param refStrPart1 the single cell reference or first part of the area reference. Must not
* be <code>null</code>.
* @param refStrPart2 the second part of the area reference. For single cell references this
* parameter must be <code>null</code>
* @param isA1Style specifies the format for <c>refStrPart1</c> and <c>refStrPart2</c>.
* Pass <c>true</c> for 'A1' style and <c>false</c> for 'R1C1' style.
* TODO - currently POI only supports 'A1' reference style
* @return a {@link RefEval} or {@link AreaEval}
*/
public ValueEval GetDynamicReference(string workbookName, string sheetName, string refStrPart1,
string refStrPart2, bool isA1Style)
{
if (!isA1Style)
{
throw new Exception("R1C1 style not supported yet");
}
SheetRefEvaluator se = CreateExternSheetRefEvaluator(workbookName, sheetName);
if (se == null)
{
return(ErrorEval.REF_INVALID);
}
SheetRangeEvaluator sre = new SheetRangeEvaluator(_sheetIndex, se);
// ugly typecast - TODO - make spReadsheet version more easily accessible
SpreadsheetVersion ssVersion = ((IFormulaParsingWorkbook)_workbook).GetSpreadsheetVersion();
NameType part1refType = ClassifyCellReference(refStrPart1, ssVersion);
switch (part1refType)
{
case NameType.BadCellOrNamedRange:
return(ErrorEval.REF_INVALID);
case NameType.NamedRange:
IEvaluationName nm = ((IFormulaParsingWorkbook)_workbook).GetName(refStrPart1, _sheetIndex);
if (!nm.IsRange)
{
throw new Exception("Specified name '" + refStrPart1 + "' is not a range as expected.");
}
return(_bookEvaluator.EvaluateNameFormula(nm.NameDefinition, this));
}
if (refStrPart2 == null)
{
// no ':'
switch (part1refType)
{
case NameType.Column:
case NameType.Row:
return(ErrorEval.REF_INVALID);
case NameType.Cell:
CellReference cr = new CellReference(refStrPart1);
return(new LazyRefEval(cr.Row, cr.Col, sre));
}
throw new InvalidOperationException("Unexpected reference classification of '" + refStrPart1 + "'.");
}
NameType part2refType = ClassifyCellReference(refStrPart1, ssVersion);
switch (part2refType)
{
case NameType.BadCellOrNamedRange:
return(ErrorEval.REF_INVALID);
case NameType.NamedRange:
throw new Exception("Cannot Evaluate '" + refStrPart1
+ "'. Indirect Evaluation of defined names not supported yet");
}
if (part2refType != part1refType)
{
// LHS and RHS of ':' must be compatible
return(ErrorEval.REF_INVALID);
}
int firstRow, firstCol, lastRow, lastCol;
switch (part1refType)
{
case NameType.Column:
firstRow = 0;
if (part2refType.Equals(NameType.Column))
{
lastRow = ssVersion.LastRowIndex;
firstCol = ParseRowRef(refStrPart1);
lastCol = ParseRowRef(refStrPart2);
}
else
{
lastRow = ssVersion.LastRowIndex;
firstCol = ParseColRef(refStrPart1);
lastCol = ParseColRef(refStrPart2);
}
break;
case NameType.Row:
// support of cell range in the form of integer:integer
firstCol = 0;
if (part2refType.Equals(NameType.Row))
{
firstRow = ParseColRef(refStrPart1);
lastRow = ParseColRef(refStrPart2);
lastCol = ssVersion.LastColumnIndex;
}
else
{
lastCol = ssVersion.LastColumnIndex;
firstRow = ParseRowRef(refStrPart1);
lastRow = ParseRowRef(refStrPart2);
}
break;
case NameType.Cell:
CellReference cr;
cr = new CellReference(refStrPart1);
firstRow = cr.Row;
firstCol = cr.Col;
cr = new CellReference(refStrPart2);
lastRow = cr.Row;
lastCol = cr.Col;
break;
default:
throw new InvalidOperationException("Unexpected reference classification of '" + refStrPart1 + "'.");
}
return(new LazyAreaEval(firstRow, firstCol, lastRow, lastCol, sre));
}
/* package */
internal IEvaluationName GetName(string name, int sheetIndex)
{
IEvaluationName evalName = _workbook.GetName(name, sheetIndex);
return(evalName);
}
private ValueEval GetEvalForNameRecord(IEvaluationName nameRecord, OperationEvaluationContext ec)
{
if (nameRecord.IsFunctionName)
{
return new FunctionNameEval(nameRecord.NameText);
}
if (nameRecord.HasFormula)
{
return EvaluateNameFormula(nameRecord.NameDefinition, ec);
}
throw new Exception("Don't now how to Evalate name '" + nameRecord.NameText + "'");
}
public ExternalNameEval(IEvaluationName name)
{
_name = name;
}
public ExternalNameEval(IEvaluationName name)
{
_name = name;
}
