// 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; }