/** * Call this on any ptg reference contained in a row of cells that was copied. * If the ptg reference is relative, the references will be shifted by the distance * that the rows were copied. * In the future similar functions could be written due to column copying or * individual cell copying. Just make sure to only call adjustPtgDueToRowCopy on * formula cells that are copied (unless row shifting, where references outside * of the shifted region need to be updated to reflect the shift, a copy is self-contained). * * @param ptg the ptg to shift * @return deleted ref ptg, in-place modified ptg, or null * If Ptg would be shifted off the first or last row of a sheet, return deleted ref * If Ptg needs to be changed, modifies Ptg in-place * If Ptg doesn't need to be changed, returns <code>null</code> */ private Ptg AdjustPtgDueToRowCopy(Ptg ptg) { if (ptg is RefPtg) { RefPtg rptg = (RefPtg)ptg; return(RowCopyRefPtg(rptg)); } if (ptg is Ref3DPtg) { Ref3DPtg rptg = (Ref3DPtg)ptg; return(RowCopyRefPtg(rptg)); } if (ptg is Ref3DPxg) { Ref3DPxg rpxg = (Ref3DPxg)ptg; return(RowCopyRefPtg(rpxg)); } if (ptg is Area2DPtgBase) { return(RowCopyAreaPtg((Area2DPtgBase)ptg)); } if (ptg is Area3DPtg) { Area3DPtg aptg = (Area3DPtg)ptg; return(RowCopyAreaPtg(aptg)); } if (ptg is Area3DPxg) { Area3DPxg apxg = (Area3DPxg)ptg; return(RowCopyAreaPtg(apxg)); } return(null); }
public void TestColumnGreater255() { RefPtgBase ptg; ptg = new RefPtg("IW1"); Assert.AreEqual(256, ptg.Column); Assert.AreEqual("IW1", ptg.FormatReferenceAsString()); ptg = new RefPtg("JA1"); Assert.AreEqual(260, ptg.Column); Assert.AreEqual("JA1", ptg.FormatReferenceAsString()); }
/** * Creates a non shared formula from the shared formula counterpart, i.e. * Converts the shared formula into the equivalent {@link org.apache.poi.ss.formula.ptg.Ptg} array that it would have, * were it not shared. * * @param ptgs parsed tokens of the shared formula * @param formulaRow * @param formulaColumn */ public Ptg[] ConvertSharedFormulas(Ptg[] ptgs, int formulaRow, int formulaColumn) { Ptg[] newPtgStack = new Ptg[ptgs.Length]; for (int k = 0; k < ptgs.Length; k++) { Ptg ptg = ptgs[k]; byte originalOperandClass = unchecked((byte)-1); if (!ptg.IsBaseToken) { originalOperandClass = ptg.PtgClass; } if (ptg is RefPtgBase) { RefPtgBase refNPtg = (RefPtgBase)ptg; ptg = new RefPtg(FixupRelativeRow(formulaRow, refNPtg.Row, refNPtg.IsRowRelative), FixupRelativeColumn(formulaColumn, refNPtg.Column, refNPtg.IsColRelative), refNPtg.IsRowRelative, refNPtg.IsColRelative); ptg.PtgClass = (originalOperandClass); } else if (ptg is AreaPtgBase) { AreaPtgBase areaNPtg = (AreaPtgBase)ptg; ptg = new AreaPtg(FixupRelativeRow(formulaRow, areaNPtg.FirstRow, areaNPtg.IsFirstRowRelative), FixupRelativeRow(formulaRow, areaNPtg.LastRow, areaNPtg.IsLastRowRelative), FixupRelativeColumn(formulaColumn, areaNPtg.FirstColumn, areaNPtg.IsFirstColRelative), FixupRelativeColumn(formulaColumn, areaNPtg.LastColumn, areaNPtg.IsLastColRelative), areaNPtg.IsFirstRowRelative, areaNPtg.IsLastRowRelative, areaNPtg.IsFirstColRelative, areaNPtg.IsLastColRelative); ptg.PtgClass = (originalOperandClass); } else if (ptg is OperandPtg) { // Any subclass of OperandPtg is mutable, so it's safest to not share these instances. ptg = ((OperandPtg)ptg).Copy(); } else { // all other Ptgs are immutable and can be shared } newPtgStack[k] = ptg; } return newPtgStack; }
/** * Creates a non shared formula from the shared formula counterpart, i.e. * Converts the shared formula into the equivalent {@link org.apache.poi.ss.formula.ptg.Ptg} array that it would have, * were it not shared. * * @param ptgs parsed tokens of the shared formula * @param formulaRow * @param formulaColumn */ public Ptg[] ConvertSharedFormulas(Ptg[] ptgs, int formulaRow, int formulaColumn) { Ptg[] newPtgStack = new Ptg[ptgs.Length]; for (int k = 0; k < ptgs.Length; k++) { Ptg ptg = ptgs[k]; byte originalOperandClass = unchecked ((byte)-1); if (!ptg.IsBaseToken) { originalOperandClass = ptg.PtgClass; } if (ptg is RefPtgBase) { RefPtgBase refNPtg = (RefPtgBase)ptg; ptg = new RefPtg(FixupRelativeRow(formulaRow, refNPtg.Row, refNPtg.IsRowRelative), FixupRelativeColumn(formulaColumn, refNPtg.Column, refNPtg.IsColRelative), refNPtg.IsRowRelative, refNPtg.IsColRelative); ptg.PtgClass = (originalOperandClass); } else if (ptg is AreaPtgBase) { AreaPtgBase areaNPtg = (AreaPtgBase)ptg; ptg = new AreaPtg(FixupRelativeRow(formulaRow, areaNPtg.FirstRow, areaNPtg.IsFirstRowRelative), FixupRelativeRow(formulaRow, areaNPtg.LastRow, areaNPtg.IsLastRowRelative), FixupRelativeColumn(formulaColumn, areaNPtg.FirstColumn, areaNPtg.IsFirstColRelative), FixupRelativeColumn(formulaColumn, areaNPtg.LastColumn, areaNPtg.IsLastColRelative), areaNPtg.IsFirstRowRelative, areaNPtg.IsLastRowRelative, areaNPtg.IsFirstColRelative, areaNPtg.IsLastColRelative); ptg.PtgClass = (originalOperandClass); } else if (ptg is OperandPtg) { // Any subclass of OperandPtg is mutable, so it's safest to not share these instances. ptg = ((OperandPtg)ptg).Copy(); } else { // all other Ptgs are immutable and can be shared } newPtgStack[k] = ptg; } return(newPtgStack); }
/** * @return <c>true</c> if this Ptg needed to be changed */ private Ptg AdjustPtgDueToRowMove(Ptg ptg, int currentExternSheetIx) { if (ptg is RefPtg) { if (currentExternSheetIx != _externSheetIndex) { // local refs on other sheets are unaffected return(null); } RefPtg rptg = (RefPtg)ptg; return(RowMoveRefPtg(rptg)); } if (ptg is Ref3DPtg) { Ref3DPtg rptg = (Ref3DPtg)ptg; if (_externSheetIndex != rptg.ExternSheetIndex) { // only move 3D refs that refer to the sheet with cells being moved // (currentExternSheetIx is irrelevant) return(null); } return(RowMoveRefPtg(rptg)); } if (ptg is Area2DPtgBase) { if (currentExternSheetIx != _externSheetIndex) { // local refs on other sheets are unaffected return(ptg); } return(RowMoveAreaPtg((Area2DPtgBase)ptg)); } if (ptg is Area3DPtg) { Area3DPtg aptg = (Area3DPtg)ptg; if (_externSheetIndex != aptg.ExternSheetIndex) { // only move 3D refs that refer to the sheet with cells being moved // (currentExternSheetIx is irrelevant) return(null); } return(RowMoveAreaPtg(aptg)); } return(null); }
public void TestLinkFormula() { RecordInputStream is1 = new RecordInputStream(new MemoryStream(linkData)); is1.NextRecord(); TextObjectRecord rec = new TextObjectRecord(is1); Ptg ptg = rec.LinkRefPtg; Assert.IsNotNull(ptg); Assert.AreEqual(typeof(RefPtg), ptg.GetType()); RefPtg rptg = (RefPtg)ptg; Assert.AreEqual("T2", rptg.ToFormulaString()); byte[] data2 = rec.Serialize(); Assert.AreEqual(linkData.Length, data2.Length); Assert.IsTrue(Arrays.Equals(linkData, data2)); }
public void TestConvertSharedFormulasOperandClasses_bug45123() { RecordInputStream in1 = TestcaseRecordInputStream.Create(0, SHARED_FORMULA_WITH_REF_ARRAYS_DATA); short encodedLen = in1.ReadShort(); Ptg[] sharedFormula = Ptg.ReadTokens(encodedLen, in1); Ptg[] convertedFormula = SharedFormulaRecord.ConvertSharedFormulas(sharedFormula, 100, 200); RefPtg refPtg = (RefPtg)convertedFormula[1]; Assert.AreEqual("$C101", refPtg.ToFormulaString()); if (refPtg.PtgClass == Ptg.CLASS_REF) { throw new AssertFailedException("Identified bug 45123"); } ConfirmOperandClasses(sharedFormula, convertedFormula); }
public void TestReSerialize() { FormulaRecord formulaRecord = new FormulaRecord(); formulaRecord.Row = (/*setter*/ 1); formulaRecord.Column = (/*setter*/ (short)1); formulaRecord.ParsedExpression = (/*setter*/ new Ptg[] { new RefPtg("B$5"), }); formulaRecord.Value = (/*setter*/ 3.3); byte[] ser = formulaRecord.Serialize(); Assert.AreEqual(31, ser.Length); RecordInputStream in1 = TestcaseRecordInputStream.Create(ser); FormulaRecord fr2 = new FormulaRecord(in1); Assert.AreEqual(3.3, fr2.Value, 0.0); Ptg[] ptgs = fr2.ParsedExpression; Assert.AreEqual(1, ptgs.Length); RefPtg rp = (RefPtg)ptgs[0]; Assert.AreEqual("B$5", rp.ToFormulaString()); }
public void TestConvertSharedFormulasOperandClasses_bug45123() { ILittleEndianInput in1 = TestcaseRecordInputStream.CreateLittleEndian(SHARED_FORMULA_WITH_REF_ARRAYS_DATA); int encodedLen = in1.ReadUShort(); Ptg[] sharedFormula = Ptg.ReadTokens(encodedLen, in1); SharedFormula sf = new SharedFormula(SpreadsheetVersion.EXCEL97); Ptg[] ConvertedFormula = sf.ConvertSharedFormulas(sharedFormula, 100, 200); RefPtg refPtg = (RefPtg)ConvertedFormula[1]; Assert.AreEqual("$C101", refPtg.ToFormulaString()); if (refPtg.PtgClass == Ptg.CLASS_REF) { throw new AssertionException("Identified bug 45123"); } ConfirmOperandClasses(sharedFormula, ConvertedFormula); }
public MockRefEval(RefPtg ptg, ValueEval value) : base(-1, -1, ptg.Row, ptg.Column) { _value = value; }
/** * 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 + ")"); }