public void GetByteArrayMultipleTimes()
{
byte[] a = new byte[]{0x01, 0x02};
Bytes bytes = new Bytes(a);
bytes.Append(new byte[] {0x03, 0x04, 0x05, 0x06});
bytes.Append(new byte[] {0x07});
Assert.AreEqual(7, bytes.ByteArray.Length);
Assert.AreEqual(7, bytes.ByteArray.Length);
}
private void Get(int offset, int getLength, Bytes intoBytes)
{
if (offset < 0)
{
throw new ArgumentOutOfRangeException(string.Format("offset {0} must be >= 0", offset));
}
if (getLength < 0)
{
throw new ArgumentOutOfRangeException(string.Format("getLength {0} must be >= 0", getLength));
}
if (offset >= Length)
{
throw new ArgumentOutOfRangeException(string.Format("offset {0} must be < Length {1}", offset, Length));
}
if ((getLength + offset) > Length)
{
throw new ArgumentOutOfRangeException(
string.Format("offset {0} + getLength {1} = {2} must be < Length {3}", offset, getLength, offset + getLength,
Length));
}
if (IsArray)
{
if (offset == 0 && getLength == Length)
{
intoBytes.Append(_byteArray);
return;
}
intoBytes.Append(MidByteArray(_byteArray, offset, getLength));
return;
}
foreach (Bytes bytes in _bytesList)
{
if (bytes.Length <= offset)
{
offset -= bytes.Length;
continue;
}
if (bytes.Length >= (offset + getLength))
{
bytes.Get(offset, getLength, intoBytes);
return;
}
int lengthToGet = bytes.Length - offset;
bytes.Get(offset, lengthToGet, intoBytes);
getLength -= lengthToGet;
offset = 0;
}
}
// Token: 0x0600001C RID: 28 RVA: 0x000026E0 File Offset: 0x000016E0
private void Get(int offset, int getLength, Bytes intoBytes)
{
if (offset < 0)
{
throw new ArgumentOutOfRangeException(string.Format("offset {0} must be >= 0", offset));
}
if (getLength < 0)
{
throw new ArgumentOutOfRangeException(string.Format("getLength {0} must be >= 0", getLength));
}
if (offset >= this.Length)
{
throw new ArgumentOutOfRangeException(string.Format("offset {0} must be < Length {1}", offset, this.Length));
}
if (getLength + offset > this.Length)
{
throw new ArgumentOutOfRangeException(string.Format("offset {0} + getLength {1} = {2} must be < Length {3}", new object[]
{
offset,
getLength,
offset + getLength,
this.Length
}));
}
if (!this.IsArray)
{
foreach (Bytes bytes in this._bytesList)
{
if (bytes.Length <= offset)
{
offset -= bytes.Length;
}
else
{
if (bytes.Length >= offset + getLength)
{
bytes.Get(offset, getLength, intoBytes);
break;
}
int num = bytes.Length - offset;
bytes.Get(offset, num, intoBytes);
getLength -= num;
offset = 0;
}
}
return;
}
if (offset == 0 && getLength == this.Length)
{
intoBytes.Append(this._byteArray);
return;
}
intoBytes.Append(Bytes.MidByteArray(this._byteArray, offset, getLength));
}
public void ConvertArrayToList()
{
Bytes bytes = new Bytes(new byte[] { sixteenBytes[0], sixteenBytes[1] });
Assert.IsTrue(bytes.IsArray);
bytes.Append(new byte[] { sixteenBytes[2], sixteenBytes[3] });
Assert.IsFalse(bytes.IsArray);
}
public void AppendBytesObject()
{
Bytes bytes = new Bytes(new byte[] { sixteenBytes[0], sixteenBytes[1] });
bytes.Append(new Bytes(new byte[] { sixteenBytes[2], sixteenBytes[3] }));
Assert.AreEqual(4, bytes.Length);
Assert.IsFalse(bytes.IsArray);
}
public void LittleEndian0xFE()
{
byte b = 0xFE;
Bytes bytes = new Bytes();
bytes.Append(b);
bool[] bits = bytes.GetBits().Values;
Assert.AreEqual(8, bits.Length, "Bits length");
Assert.IsFalse(bits[0], "Bit 0 value");
for (int i = 1; i < 8; i++)
Assert.IsTrue(bits[i], string.Format("Bit {0} value", i));
}
public void LittleEndian0x0101()
{
byte[] bs = new byte[] { 0x01, 0x01 };
Bytes bytes = new Bytes();
bytes.Append(bs);
bool[] bits = bytes.GetBits().Values;
Assert.AreEqual(16, bits.Length, "Bits length");
Assert.IsTrue(bits[0], "Bit 0 value");
Assert.IsTrue(bits[8], "Bit 8 value");
for (int i = 1; i < 8; i++)
Assert.IsFalse(bits[i], string.Format("Bit {0} value", i));
for (int i = 9; i < 16; i++)
Assert.IsFalse(bits[i], string.Format("Bit {0} value", i));
}
public void Test_Get()
{
Bytes bytes = new Bytes();
Bytes newBytes = new Bytes();
newBytes.Append(new byte[] { sixteenBytes[0], sixteenBytes[1] });
newBytes.Append(new byte[] { sixteenBytes[2], sixteenBytes[3] });
bytes.Append(newBytes);
bytes.Append(new Bytes(new byte[] { sixteenBytes[4], sixteenBytes[5] }));
newBytes = new Bytes();
newBytes.Append(new byte[] { sixteenBytes[6], sixteenBytes[7], sixteenBytes[8] });
newBytes.Append(new byte[] { sixteenBytes[9] });
bytes.Append(newBytes);
newBytes = new Bytes();
newBytes.Append(new Bytes(new byte[] { sixteenBytes[10] }));
newBytes.Append(new Bytes(new byte[] { sixteenBytes[11] }));
bytes.Append(newBytes);
newBytes = new Bytes();
newBytes.Append(new Bytes(new byte[] { sixteenBytes[12] }));
newBytes.Append(new Bytes(new byte[] { sixteenBytes[13], sixteenBytes[14] }));
newBytes.Append(new Bytes(new byte[] { sixteenBytes[15] }));
bytes.Append(newBytes);
AssertArraysAreEqual(bytes.ByteArray, sixteenBytes);
for (int offset = 0; offset < 16; offset++)
{
for (int length = 0; length <= (16 - offset); length++)
{
AssertArraysAreEqual(Bytes.MidByteArray(sixteenBytes, offset, length), bytes.Get(offset, length).ByteArray);
}
}
}
internal Bytes GetStandardOLE2Stream(Bytes bytes)
{
uint standardLength = _ole2Doc.StandardStreamMinBytes;
uint padLength = standardLength = ((uint)bytes.Length % standardLength);
if (padLength < standardLength)
bytes.Append(new byte[padLength]);
return bytes;
}
private static Bytes ROW(Row row)
{
Bytes bytes = new Bytes();
//Index of this row
bytes.Append(BitConverter.GetBytes((ushort)(row.RowIndex - 1)));
//Index to column of the first cell which is described by a cell record
bytes.Append(BitConverter.GetBytes((ushort)(row.MinCellCol - 1)));
//Index to column of the last cell which is described by a cell record, + 1
bytes.Append(BitConverter.GetBytes(row.MaxCellCol));
//Height of row in twips, custom row height indicator
//TODO: Implement Row height and custom height indicators (excelfileformat.pdf p.190)
bytes.Append(new byte[] {0x08, 0x01});
//Not used
bytes.Append(new byte[] {0x00, 0x00});
//Not used anymore in BIFF8 (DBCELL instead)
bytes.Append(new byte[] {0x00, 0x00});
//Option flags and default row formatting
//TODO: Implement Row option flags and default row formatting (excelfileformat.pdf p.190)
bytes.Append(new byte[] {0x00, 0x01, 0x0F, 0x00});
return Record.GetBytes(RID.ROW, bytes);
}
private static Bytes GetBytesLPSTR(object value)
{
Bytes lpstr = new Bytes();
string theString = value as string;
Encoder encoder = Encoding.UTF8.GetEncoder();
char[] theChars = theString.ToCharArray();
int paddedLength = theChars.Length + 1; //add one for terminating null
paddedLength += (paddedLength % 4); //must be multiple of 4
byte[] bytes = new byte[paddedLength];
encoder.GetBytes(theChars, 0, theChars.Length, bytes, 0, true);
lpstr.Append(BitConverter.GetBytes((uint) paddedLength));
lpstr.Append(bytes);
return lpstr;
}
private Bytes MERGEDCELLS()
{
Bytes mergedcells = new Bytes();
int areaIndex = 0;
int mergeAreaCount = _mergeAreas.Count;
long areasPerRecord = 1027;
int recordsRequired = (int)Math.Ceiling(_mergeAreas.Count/(double)areasPerRecord);
for (int recordIndex = 0; recordIndex < recordsRequired; recordIndex++)
{
ushort blockAreaIndex = 0;
Bytes rangeAddresses = new Bytes();
while (areaIndex < mergeAreaCount && blockAreaIndex < areasPerRecord)
{
rangeAddresses.Append(CellRangeAddress(_mergeAreas[areaIndex]));
blockAreaIndex++;
areaIndex++;
}
rangeAddresses.Prepend(BitConverter.GetBytes(blockAreaIndex));
mergedcells.Append(Record.GetBytes(RID.MERGEDCELLS, rangeAddresses));
}
return mergedcells;
}
private Bytes COLINFOS()
{
Bytes colinfos = new Bytes();
for (int i = 0; i < _columnInfos.Count; i++)
colinfos.Append(_columnInfos[i].Bytes);
return colinfos;
}
private static Bytes BOUNDSHEET(Worksheet sheet, int basePosition)
{
Bytes bytes = new Bytes();
Bytes sheetName = XlsDocument.GetUnicodeString(sheet.Name, 8);
bytes.Append(WorksheetVisibility.GetBytes(sheet.Visibility));
bytes.Append(WorksheetType.GetBytes(sheet.SheetType));
bytes.Append(sheetName);
bytes.Prepend(BitConverter.GetBytes((int) basePosition)); //TODO: this should probably be unsigned 32 instead
bytes.Prepend(BitConverter.GetBytes((ushort) bytes.Length));
bytes.Prepend(RID.BOUNDSHEET);
return bytes;
}
private Bytes GetFormatRecord(ushort id, string format)
{
Bytes bytes = new Bytes();
bytes.Append(BitConverter.GetBytes(id));
bytes.Append(XlsDocument.GetUnicodeString(format, 16));
return Record.GetBytes(RID.FORMAT, bytes);
}
//NOTE: Don't want to pass recordBytes by ref or when we set it to a new Bytes
//instance, it will wipe out what was appended to bytes
private Bytes Continue(Bytes sst, Bytes bytes, out int remainingRecordBytes, ref bool isFirstContinue)
{
sst.Append(Record.GetBytes(isFirstContinue ? RID.SST : RID.CONTINUE, bytes));
remainingRecordBytes = BIFF8.MaxDataBytesPerRecord;
isFirstContinue = false;
return new Bytes();
}
private Bytes CellRangeAddress(ushort minRow, ushort maxRow, ushort minCol, ushort maxCol)
{
minRow--;
maxRow--;
minCol--;
maxCol--;
Bytes rangeAddress = new Bytes();
rangeAddress.Append(BitConverter.GetBytes(minRow));
rangeAddress.Append(BitConverter.GetBytes(maxRow));
rangeAddress.Append(BitConverter.GetBytes(minCol));
rangeAddress.Append(BitConverter.GetBytes(maxCol));
return rangeAddress;
}
private Bytes BLANK()
{
Bytes blank = new Bytes();
//Index to row
blank.Append(BitConverter.GetBytes((ushort)(Row - 1)));
//Index to column
blank.Append(BitConverter.GetBytes((ushort)(Column - 1)));
//Index to XF record
blank.Append(BitConverter.GetBytes((ushort) _xfIdx));
return Record.GetBytes(RID.BLANK, blank);
}
private Bytes INDEX(int baseLength)
{
Bytes index = new Bytes();
//Not used
index.Append(new byte[] { 0x00, 0x00, 0x00, 0x00 });
//Index to first used row (0-based)
index.Append(BitConverter.GetBytes(_rows.MinRow - 1));
//Index to first row of unused tail of sheet(last row + 1, 0-based)
index.Append(BitConverter.GetBytes(_rows.MaxRow));
//Absolute stream position of the DEFCOLWIDTH record
//TODO: Implement Worksheet.INDEX Absolute stream position of the DEFCOLWIDTH record (not necessary)
index.Append(BitConverter.GetBytes((uint)0));
for (int i = 1; i < _dbCellOffsets.Length; i++)
index.Append(BitConverter.GetBytes((uint)(baseLength + _dbCellOffsets[i])));
return Record.GetBytes(RID.INDEX, index);
}
private Bytes LABEL()
{
Bytes label = new Bytes();
label.Append(LABELBase());
//Unicode string, 16-bit string length
label.Append(XlsDocument.GetUnicodeString((string)Value ?? string.Empty, 16));
return Record.GetBytes(RID.LABEL, label);
}
private Bytes WINDOW2()
{
Bytes window2 = new Bytes();
//TODO: Implement options - excelfileformat.pdf pp.210-211
if (_doc.Workbook.Worksheets.GetIndex(Name) == 0) //NOTE: This was == 1, but the base of the worksheets collection must have changed
window2.Append(new byte[] { 0xB6, 0x06 });
else
window2.Append(new byte[] { 0xB6, 0x04 });
window2.Append(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 });
return Record.GetBytes(RID.WINDOW2, window2);
}
private Bytes LABELBase()
{
Bytes labelBase = new Bytes();
//Index to row
labelBase.Append(BitConverter.GetBytes((ushort)(Row - 1)));
//Index to column
labelBase.Append(BitConverter.GetBytes((ushort)(Column - 1)));
//Index to XF record
labelBase.Append(BitConverter.GetBytes((ushort)_xfIdx));
return labelBase;
}
private Bytes SectorBinData(int sectorIndex)
{
if (0 > sectorIndex || sectorIndex > SectorCount)
throw new ArgumentOutOfRangeException(string.Format("sectorIndex must be >= 0 and <= SectorCount {0}", SectorCount));
int satSectors, satSid0, startSector, stopSector;
Bytes bytes = new Bytes();
satSectors = _doc.SAT.SectorCount;
satSid0 = _doc.SAT.SID0;
if (sectorIndex == 0)
{
startSector = 1;
stopSector = 109;
}
else
{
startSector = 110 + ((sectorIndex - 1)*127);
stopSector = startSector + 126;
}
for (int i = startSector; i <= stopSector; i++)
{
if (i < (satSectors + 1))
bytes.Append(BitConverter.GetBytes((int) (satSid0 + (i - 1))));
else
bytes.Append(BitConverter.GetBytes((int) -1));
}
if (sectorIndex > 0)
{
if (stopSector >= satSectors)
bytes.Append(BitConverter.GetBytes((int) -2));
else
bytes.Append(BitConverter.GetBytes((int) (SID0 + sectorIndex)));
}
return bytes;
}
private Bytes LABELSST()
{
Bytes labelsst = new Bytes();
labelsst.Append(LABELBase());
//Index of string value in Shared String Table
labelsst.Append(BitConverter.GetBytes((uint) _value));
return Record.GetBytes(RID.LABELSST, labelsst);
}
private static Bytes DBCELL(ushort[] cOff)
{
Bytes dbcell = new Bytes();
for (int i = 0; i < cOff.Length; i++)
{
if (i == 0)
dbcell.Append(BitConverter.GetBytes((uint) cOff[i]));
else
dbcell.Append(BitConverter.GetBytes(cOff[i]));
}
return Record.GetBytes(RID.DBCELL, dbcell);
}
private Bytes NUMBER()
{
double value = Convert.ToDouble(Value);
Bytes number = new Bytes();
//Index to row
number.Append(BitConverter.GetBytes((ushort) (Row - 1)));
//Index to column
number.Append(BitConverter.GetBytes((ushort) (Column - 1)));
//Index to XF record
number.Append(BitConverter.GetBytes((ushort) _xfIdx));
//NUMBER Value
number.Append(NUMBERVal(value));
return Record.GetBytes(RID.NUMBER, number);
}
private Bytes GetStream(System.IO.Stream fromDocumentStream, int did, Dictionary<int, byte[]> dir, ushort sectorSize, int[] sat, ushort shortSectorSize, int[] ssat, uint minStandardStreamSize)
{
Bytes stream = new Bytes();
Bytes fromBytes;
int[] fromSAT;
ushort fromSectorSize;
int sidNext;
string shortness;
int streamLength = BitConverter.ToInt32(MidByteArray(dir[did], 120, 4), 0);
Bytes streamBytes = null;
if (did == 0 || (streamLength >= minStandardStreamSize))
{
byte[] streamByteArray;
streamByteArray = new byte[fromDocumentStream.Length];
fromDocumentStream.Position = 0;
fromDocumentStream.Read(streamByteArray, 0, streamByteArray.Length);
streamBytes = new Bytes(streamByteArray);
}
if (did == 0)
{
fromSectorSize = sectorSize;
fromSAT = sat;
shortness = string.Empty;
fromBytes = streamBytes;
}
else if (streamLength < minStandardStreamSize)
{
fromSectorSize = shortSectorSize;
fromSAT = ssat;
shortness = "Short ";
fromBytes = GetStream(fromDocumentStream, 0, dir, sectorSize, sat, shortSectorSize, ssat, minStandardStreamSize);
}
else
{
fromSectorSize = sectorSize;
fromSAT = sat;
shortness = string.Empty;
fromBytes = streamBytes;
}
sidNext = BitConverter.ToInt32(MidByteArray(dir[did], 116, 4), 0);
while (sidNext > -2)
{
Bytes sector;
if (did > 0 && streamLength < minStandardStreamSize)
sector = GetShortSectorBytes(fromBytes, fromSectorSize, sidNext);
else
sector = GetSectorBytes(fromBytes, fromSectorSize, sidNext);
if (sector.Length == 0)
throw new Exception(string.Format("{0}Sector not found [SID{1}]", shortness, sidNext));
stream.Append(sector);
sidNext = fromSAT[sidNext];
}
return stream.Get(streamLength);
}
private Bytes RK(bool trueFalse)
{
Bytes rk = new Bytes();
//Index to row
rk.Append(BitConverter.GetBytes((ushort) (Row - 1)));
//Index to column
rk.Append(BitConverter.GetBytes((ushort) (Column - 1)));
//Index to XF record
rk.Append(BitConverter.GetBytes((ushort) _xfIdx));
//RK Value
if (Type == CellTypes.Integer)
rk.Append(RKIntegerValue(Value, trueFalse));
else if (Type == CellTypes.Float)
rk.Append(RKDecimalValue(Value, trueFalse));
return Record.GetBytes(RID.RK, rk);
}
internal static Bytes GetUnicodeString(string text, int lengthBits)
{
int textLength;
int limit = lengthBits == 8 ? byte.MaxValue : ushort.MaxValue;
byte[] binaryLength = new byte[0];
byte[] compression;
byte[] compressedText = new byte[0];
textLength = text.Length;
if (textLength > limit)
text = text.Substring(0, limit); //NOTE: Should throw Exception here?
if (limit == 255)
binaryLength = new byte[1] { (byte)text.Length };
else if (limit == 65535)
binaryLength = BitConverter.GetBytes((ushort)text.Length);
if (IsCompressible(text))
{
compression = new byte[1];
char[] chars = text.ToCharArray();
compressedText = new byte[chars.Length];
for (int i = 0; i < chars.Length; i++)
compressedText[i] = (byte)chars[i];
}
else
{
compression = new byte[1] { 1 };
}
Bytes bytes = new Bytes();
bytes.Append(binaryLength);
bytes.Append(compression);
if (compressedText.Length > 0)
bytes.Append(compressedText);
else
bytes.Append(Encoding.Unicode.GetBytes(text));
return bytes;
}
private void Get(int offset, int getLength, Bytes intoBytes)
{
if (offset < 0)
throw new ArgumentOutOfRangeException(string.Format("offset {0} must be >= 0", offset));
if (getLength < 0)
throw new ArgumentOutOfRangeException(string.Format("getLength {0} must be >= 0", getLength));
if (offset >= Length)
throw new ArgumentOutOfRangeException(string.Format("offset {0} must be < Length {1}", offset, Length));
if ((getLength + offset) > Length)
throw new ArgumentOutOfRangeException(
string.Format("offset {0} + getLength {1} = {2} must be < Length {3}", offset, getLength, offset + getLength,
Length));
if (IsArray)
{
if (offset == 0 && getLength == Length)
{
intoBytes.Append(_byteArray);
return;
}
intoBytes.Append(MidByteArray(_byteArray, offset, getLength));
return;
}
foreach (Bytes bytes in _bytesList)
{
if (bytes.Length <= offset)
{
offset -= bytes.Length;
continue;
}
if (bytes.Length >= (offset + getLength))
{
bytes.Get(offset, getLength, intoBytes);
return;
}
int lengthToGet = bytes.Length - offset;
bytes.Get(offset, lengthToGet, intoBytes);
getLength -= lengthToGet;
offset = 0;
}
}
internal static Bytes GetBytes(byte[] rid, Bytes data)
{
if (rid.Length != 2)
throw new ArgumentException("must be 2 bytes", "rid");
Bytes record = new Bytes();
ushort offset = 0;
ushort totalLength = (ushort)data.Length;
do
{
ushort length = Math.Min((ushort) (totalLength - offset), BIFF8.MaxDataBytesPerRecord);
if (offset == 0)
{
record.Append(rid);
record.Append(BitConverter.GetBytes(length));
record.Append(data.Get(offset, length));
}
else
{
record.Append(MyXls.RID.CONTINUE);
record.Append(BitConverter.GetBytes(length));
record.Append(data.Get(offset, length));
}
offset += length;
} while (offset < totalLength);
return record;
}
private Bytes StreamDirectoryBytes(Stream stream)
{
Bytes bytes = new Bytes();
//Stream Name
bytes.Append(stream.Name);
//Stream Name buffer fill
bytes.Append(new byte[64 - bytes.Length]);
//Stream Name length (including ending 0x00)
bytes.Append(BitConverter.GetBytes((ushort)stream.Name.Length));
//Type of entry {&H00 -> Empty, &H01 -> User Storage,
// &H02 -> User Stream, &H03 -> LockBytes (unknown),
// &H04 -> Property (unknown), &H05 -> Root storage}
//TODO: UnHack this
bytes.Append(HackDirectoryType(stream.Name));
//TODO: Implement Red-Black Tree Node color {&H00 -> Red, &H01 -> Black} (Doesn't matter)
bytes.Append(0x01);
//TODO: UnHack Red-Black Tree Left-Child Node DID (-1 if no left child)
bytes.Append(BitConverter.GetBytes(HackDirectoryDID(stream.Name, "LeftDID")));
//TODO: UnHack Red-Black Tree Right-Child Node DID (-1 if no right child)
bytes.Append(BitConverter.GetBytes(HackDirectoryDID(stream.Name, "RightDID")));
//TODO: UnHack Storage Member Red-Black Tree Root Node DID (-1 if not storage)
bytes.Append(BitConverter.GetBytes(HackDirectoryDID(stream.Name, "RootDID")));
//Unique identifier for storage (Doesn't matter)
bytes.Append(new byte[16]);
//User flags (Doesn't matter)
bytes.Append(new byte[4]);
//Entry Creation Timestamp (Can be all 0's)
bytes.Append(new byte[8]);
//Entry Modification Timestamp (Can be all 0's)
bytes.Append(new byte[8]);
//SID of Stream's First Sector (for Short or Standard Streams)
bytes.Append(BitConverter.GetBytes(stream.SID0));
//Stream Size in Bytes (0 if storage, but not Root Storage entry)
bytes.Append(BitConverter.GetBytes(stream.ByteCount));
//Not used
bytes.Append(new byte[4]);
return bytes;
}