private static void GetRelativeRowAndCol(int Rw1, int grBit1, out bool RowAbs, out bool ColAbs, out int Row, out int Col)
{
RowAbs = (grBit1 & 0x8000) == 0;
ColAbs = (grBit1 & 0x4000) == 0;
unchecked
{
Row = RowAbs ? Biff8Utils.ExpandBiff8Row(Rw1) : (Int16)Rw1;
Col = ColAbs ? Biff8Utils.ExpandBiff8Col(grBit1 & ColMask) : (sbyte)(grBit1 & ColMask);
}
}
private static void WriteRow(Stream Data, bool CanHaveRelativeOffsets, int r, bool rabs)
{
if (CanHaveRelativeOffsets && !rabs)
{
r = Biff8Utils.CheckAndContractRelativeBiff8Row(r);
}
else
{
r = Biff8Utils.CheckAndContractBiff8Row(r);
}
WriteWord(Data, r);
}
internal override byte[] Biff8Data()
{
byte[] Result = new byte[6];
Biff8Utils.CheckCol(Col);
Biff8Utils.CheckRow(Row1);
int R2 = Biff8Utils.CheckAndContractBiff8Row(Row2);
BitOps.SetWord(Result, 0, Col);
BitOps.SetWord(Result, 2, Row1);
BitOps.SetWord(Result, 4, R2);
return(Result);
}
internal override void SaveToStream(IDataStream Workbook, TSaveData SaveData, int Row)
{
//We can't check for ColSplit/RowSplit since we don't know what it is. It doesn't really matter either.
Biff8Utils.CheckRow(FirstVisibleRow);
Biff8Utils.CheckCol(FirstVisibleCol);
Workbook.WriteHeader((UInt16)Id, (UInt16)TotalSizeNoHeaders());
Workbook.Write16((UInt16)ColSplit);
Workbook.Write16((UInt16)RowSplit);
Workbook.Write16((UInt16)FirstVisibleRow);
Workbook.Write16((UInt16)FirstVisibleCol);
Workbook.Write16((UInt16)ActivePane);
}
internal TVPageBreak(int aCol, int aRow1, int aRow2, bool Expand, bool aGoesAfter) : base(aGoesAfter)
{
Col = aCol;
Row1 = aRow1;
if (Expand)
{
Row2 = Biff8Utils.ExpandBiff8Row(aRow2);
}
else
{
Row2 = aRow2;
}
}
internal override byte[] Biff8Data()
{
byte[] Result = new byte[6];
Biff8Utils.CheckRow(Row);
Biff8Utils.CheckCol(Col1);
int Col3 = Col2 <= FlxConsts.Max_Columns97_2003? Col2: FlxConsts.Max_Columns97_2003; //Col can be stored up to 16384
int C2 = Biff8Utils.CheckAndContractBiff8Col(Col3);
BitOps.SetWord(Result, 0, Row);
BitOps.SetWord(Result, 2, Col1);
BitOps.SetWord(Result, 4, C2);
return(Result);
}
internal THPageBreak(int aRow, int aCol1, int aCol2, bool Expand, bool aGoesAfter) : base(aGoesAfter)
{
Row = aRow;
Col1 = aCol1;
if (Expand)
{
Col2 = Biff8Utils.ExpandBiff8Col(aCol2);
}
else
{
Col2 = aCol2;
}
}
private void AddParsed3dRef(TParsedTokenListBuilder TokenBuilder, ptg RealToken, int ExternSheet, int Rw1, int grBit1)
{
if (Relative3dRanges)
{
bool RowAbs1; bool ColAbs1; int Row1; int Col1;
GetRelativeRowAndCol(Rw1, grBit1, out RowAbs1, out ColAbs1, out Row1, out Col1);
Push(TokenBuilder, new TRef3dNToken(RealToken, ExternSheet, Row1, Col1, RowAbs1, ColAbs1, true));
}
else
{
Push(TokenBuilder, new TRef3dToken(RealToken, ExternSheet, Biff8Utils.ExpandBiff8Row(Rw1),
Biff8Utils.ExpandBiff8Col(grBit1 & ColMask), (grBit1 & 0x8000) == 0, (grBit1 & 0x4000) == 0));
}
}
private static void WriteCol(Stream Data, bool CanHaveRelativeOffsets, bool rabs, int c, bool cabs)
{
if (CanHaveRelativeOffsets && !cabs)
{
c = Biff8Utils.CheckAndContractRelativeBiff8Col(c);
}
else
{
c = Biff8Utils.CheckAndContractBiff8Col(c);
}
if (!rabs)
{
c |= 0x8000;
}
if (!cabs)
{
c |= 0x4000;
}
WriteWord(Data, c);
}
protected static void AddParsedArea(TParsedTokenListBuilder TokenBuilder, ptg aId, int Rw1, int Rw2, int grBit1, int grBit2)
{
Push(TokenBuilder, new TAreaToken(aId, Biff8Utils.ExpandBiff8Row(Rw1), Biff8Utils.ExpandBiff8Col(grBit1 & ColMask), (grBit1 & 0x8000) == 0, (grBit1 & 0x4000) == 0,
Biff8Utils.ExpandBiff8Row(Rw2), Biff8Utils.ExpandBiff8Col(grBit2 & ColMask), (grBit2 & 0x8000) == 0, (grBit2 & 0x4000) == 0));
}
private static void Add(Stream Data, Stream ArrayData, TBaseParsedToken Token, ptg BaseToken, TParsedTokenList Tokens, TTokenOffset StreamPos, TFormulaType FmlaType, Int32List FuturePos)
{
if (IsError(BaseToken, FmlaType))
{
Data.WriteByte(0x1C); //PtgErr
Data.WriteByte(0x2A);
return;
}
Data.WriteByte((byte)Token.GetId);
switch (BaseToken)
{
case ptg.Exp:
TExp_Token exp = (TExp_Token)Token;
Biff8Utils.CheckRow(exp.Row);
Biff8Utils.CheckCol(exp.Col);
WriteWord(Data, exp.Row);
WriteWord(Data, exp.Col);
break;
case ptg.Tbl:
TTableObjToken tblo = Token as TTableObjToken;
if (tblo != null)
{
//no biff8 checks here. This numbers might be anything.
WriteWord(Data, tblo.Row);
WriteWord(Data, tblo.Col);
}
else
{
TTableToken tbl = (TTableToken)Token;
Biff8Utils.CheckRow(tbl.Row);
Biff8Utils.CheckCol(tbl.Col);
WriteWord(Data, tbl.Row);
WriteWord(Data, tbl.Col);
}
break;
case ptg.Add:
case ptg.Sub:
case ptg.Mul:
case ptg.Div:
case ptg.Power:
case ptg.Concat:
case ptg.LT:
case ptg.LE:
case ptg.EQ:
case ptg.GE:
case ptg.GT:
case ptg.NE:
case ptg.Isect:
case ptg.Union:
case ptg.Range:
case ptg.Uplus:
case ptg.Uminus:
case ptg.Percent:
case ptg.Paren:
case ptg.MissArg:
break;
case ptg.Str:
{
TStrDataToken tkd = Token as TStrDataToken;
string s = tkd.GetData();
if (s.Length > FlxConsts.Max_FormulaStringConstant)
{
FlxMessages.ThrowException(FlxErr.ErrStringConstantInFormulaTooLong, s, String.Empty);
}
TExcelString Xs = new TExcelString(TStrLenLength.is8bits, s, null, false);
byte[] b = new byte[Xs.TotalSize()];
Xs.CopyToPtr(b, 0);
Data.Write(b, 0, b.Length);
break;
}
case ptg.Attr:
WriteAttr(Data, Token, StreamPos, Tokens.SavePosition());
break;
/*
* case ptg.Sheet: //Can't happen, ConvertBiff8ToInternal skips them.
* case ptg.EndSheet: //Can't happen, ConvertBiff8ToInternal skips them.
* break;*/
case ptg.Err:
{
Data.WriteByte((byte)((TErrDataToken)Token).GetData());
break;
}
case ptg.Bool:
{
if (((TBoolDataToken)Token).GetData())
{
Data.WriteByte(1);
}
else
{
Data.WriteByte(0);
}
break;
}
case ptg.Int:
{
UInt16 a = (UInt16)((TIntDataToken)Token).GetData();
WriteWord(Data, a);
break;
}
case ptg.Num:
{
double d = ((TNumDataToken)Token).GetData();
Data.Write(BitConverter.GetBytes(d), 0, 8);
break;
}
case ptg.Array:
{
Data.Write(new byte[7], 0, 7);
TArrayDataToken tk = (TArrayDataToken)Token;
object[,] Arr = tk.GetData;
int ColCount = Arr.GetLength(1) - 1;
if (ColCount < 0 || ColCount > FlxConsts.Max_Columns97_2003)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidCols, ColCount, FlxConsts.Max_Columns97_2003 + 1);
}
ArrayData.WriteByte((byte)(ColCount));
int RowCount = Arr.GetLength(0) - 1;
if (RowCount < 0 || RowCount > FlxConsts.Max_Rows)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidRows, RowCount, FlxConsts.Max_Rows + 1);
}
WriteWord(ArrayData, RowCount);
for (int r = 0; r <= RowCount; r++)
{
for (int c = 0; c <= ColCount; c++)
{
WriteArrayObject(ArrayData, Arr[r, c]);
}
}
break;
}
case ptg.Func:
{
TBaseFunctionToken ft = (TBaseFunctionToken)Token;
TCellFunctionData fd = ft.GetFunctionData();
WriteWord(Data, fd.Index);
break;
}
case ptg.FuncVar:
{
TBaseFunctionToken ft = (TBaseFunctionToken)Token;
TCellFunctionData fd = ft.GetFunctionData();
if (!BackFromFutureToUserDef(Data, Tokens, FuturePos, ft, fd))
{
Data.WriteByte((byte)ft.ArgumentCount);
WriteWord(Data, fd.Index);
}
break;
}
case ptg.Name:
WriteWord(Data, ((TNameToken)Token).NameIndex);
WriteWord(Data, 0);
break;
case ptg.Ref:
case ptg.RefN:
case ptg.RefErr:
{
TRefToken reft = (TRefToken)Token;
WriteRef(Data, reft.CanHaveRelativeOffsets, reft.Row, reft.RowAbs, reft.Col, reft.ColAbs);
break;
}
case ptg.Area:
case ptg.AreaN:
case ptg.AreaErr:
{
TAreaToken areat = (TAreaToken)Token;
WriteArea(Data, areat.CanHaveRelativeOffsets, areat.Row1, areat.RowAbs1, areat.Col1, areat.ColAbs1, areat.Row2, areat.RowAbs2, areat.Col2, areat.ColAbs2);
break;
}
case ptg.MemArea:
{
WriteWord(Data, 0);
WriteWord(Data, 0);
StreamPos.Add((int)Data.Position, Tokens.SavePosition());
WriteWord(Data, 0);
TRefRange[] Range = ((TMemAreaToken)Token).Data;
WriteWord(ArrayData, Range.Length);
foreach (TRefRange OneRef in Range)
{
int r1 = Biff8Utils.CheckAndContractBiff8Row(OneRef.FirstRow);
int r2 = Biff8Utils.CheckAndContractBiff8Row(OneRef.LastRow);
int c1 = Biff8Utils.CheckAndContractBiff8Col(OneRef.FirstCol);
int c2 = Biff8Utils.CheckAndContractBiff8Col(OneRef.LastCol);
WriteWord(ArrayData, r1);
WriteWord(ArrayData, r2);
WriteWord(ArrayData, c1);
WriteWord(ArrayData, c2);
}
break;
}
case ptg.MemErr:
case ptg.MemNoMem:
WriteWord(Data, 0);
WriteWord(Data, 0);
StreamPos.Add((int)Data.Position, Tokens.SavePosition());
WriteWord(Data, 0);
break;
case ptg.MemFunc:
case ptg.MemAreaN:
case ptg.MemNoMemN:
StreamPos.Add((int)Data.Position, Tokens.SavePosition());
WriteWord(Data, 0);
break;
case ptg.NameX:
TNameXToken NameX = (TNameXToken)Token;
WriteWord(Data, NameX.FExternSheet);
WriteWord(Data, NameX.NameIndex);
WriteWord(Data, 0);
break;
case ptg.Ref3dErr:
case ptg.Ref3d:
TRef3dToken reft3d = (TRef3dToken)Token;
WriteWord(Data, reft3d.FExternSheet);
WriteRef(Data, reft3d.CanHaveRelativeOffsets, reft3d.Row, reft3d.RowAbs, reft3d.Col, reft3d.ColAbs);
break;
case ptg.Area3d:
case ptg.Area3dErr:
TArea3dToken areat3d = (TArea3dToken)Token;
WriteWord(Data, areat3d.FExternSheet);
WriteArea(Data, areat3d.CanHaveRelativeOffsets, areat3d.Row1, areat3d.RowAbs1, areat3d.Col1, areat3d.ColAbs1, areat3d.Row2, areat3d.RowAbs2, areat3d.Col2, areat3d.ColAbs2);
break;
default:
XlsMessages.ThrowException(XlsErr.ErrInternal); //All tokens here should exist
break;
}
}
