/// <summary> /// /// </summary> /// <param name="stream"></param> /// <returns></returns> public static List<Record> GetAll(Bytes stream) { int i = 0; List<Record> records = new List<Record>(); Record lastNonContinue = Record.Empty; while (i < (stream.Length - 4)) { byte[] rid = org.in2bits.MyXls.RID.ByteArray(stream.Get(i, 2).ByteArray); Bytes data = new Bytes(); if (rid == MyXls.RID.Empty) break; int length = BitConverter.ToUInt16(stream.Get(i + 2, 2).ByteArray, 0); data = stream.Get(i + 4, length); Record record = new Record(rid, data); i += (4 + length); if (rid == MyXls.RID.CONTINUE) { if (lastNonContinue == Record.Empty) throw new Exception("Found CONTINUE record without previous/parent record."); lastNonContinue.Continues.Add(record); } else { lastNonContinue = record; records.Add(record); } } return records; }
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 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 Instantiate() { Bytes bytes = new Bytes(); Assert.IsTrue(bytes.IsEmpty); Assert.IsFalse(bytes.IsArray); Assert.IsNull(bytes._bytesList); }
/// <summary> /// Initializes a new instance of the Bytes class containing the same bytes as the /// provided Bytes object. /// </summary> /// <param name="bytes">Bytes class to initialize this Bytes instance.</param> public Bytes(Bytes bytes) : this() { CheckNewLength(bytes); _bytesList = new List<Bytes>(); _bytesList.Add(bytes); _length = bytes.Length; }
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); }
/// <summary> /// Initializes a new instance of the Bits class from the given Bytes. /// </summary> /// <param name="bytes">The Bytes whose bits this Bits object will represent.</param> public Bits(Bytes bytes) { byte[] byteArray = bytes.ByteArray; _bits = new bool[byteArray.Length * 8]; for (byte i = 0; i < byteArray.Length; i++) { SetBits(i, byteArray[i]); } }
internal Record(byte[] rid, Bytes data) { _rid = org.in2bits.MyXls.RID.ByteArray(rid); int offset = 0; int bytesRemaining = data.Length; int continueIndex = -1; while (bytesRemaining > 0) { int bytesToAppend = Math.Min(bytesRemaining, BIFF8.MaxDataBytesPerRecord); Bytes target; if (continueIndex == -1) _data = data.Get(offset, bytesToAppend); else _continues.Add(new Record(MyXls.RID.CONTINUE, data.Get(offset, bytesToAppend))); offset += bytesToAppend; bytesRemaining -= bytesToAppend; continueIndex++; } }
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 static void Write(string text, Bytes bytes) { ushort offset = 0; Write(text, bytes, ref offset); }
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 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); }
public void WithNullBytes_ThrowsArgumentNullException() { Assert.Throws <ArgumentNullException>(() => Bytes.Split(2, null)); }
private static Bytes GetShortSectorBytes(Bytes fromShortSectorStream, int shortSectorSize, int sid) { int i = (int) Math.Pow(2, shortSectorSize); if (fromShortSectorStream.Length < (sid * i)) throw new Exception(string.Format("Invalid SID [{0}] (EOF reached)", sid)); // return fromShortSectorStream.Get((sid * i) + 1, i); return fromShortSectorStream.Get(sid * i, i); }
public void WithValidBytes_ReturnsTrimEndValue() { Assert.AreEqual(new byte[] { 21, 205, 91 }, Bytes.TrimEnd(7), "Get TrimEnd value"); }
public void WithValidBytes_ReturnsTrimStartValue() { Assert.AreEqual(new byte[] { 205, 91, 7 }, Bytes.TrimStart(21), "Get TrimStart value"); }
public void WithValidBytes_ReturnsTrimValue() { Assert.AreEqual(new byte[] { 21, 205, 91, 7 }, Bytes.Trim(205), "Get Trim value"); }
public void WithValidBytes_ReturnsArray() { Assert.AreEqual(Bytes, Bytes.DeepClone(), "Get DeepClone value"); }
public void WithSequenceLongerThanBuffer_ReturnsNegativeOne() { var bytes = BitConverter.GetBytes(4815162342); Assert.AreEqual(-1, Bytes.GetIndexOf(bytes), "Get index of empty array is -1"); }
public void WithNullSequence_ThrowsArgumentNullException() { Assert.Throws <ArgumentNullException>(() => Bytes.GetIndexOf(null)); }
public void WithValidBytes_ReturnsNegativeOne() { Assert.AreEqual(-1, Bytes.GetIndexOf(new byte[0]), "Get index of empty array is -1"); }
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 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); }
public void WithValidBytes_ReturnsStartsWithValue(bool expected, byte input) { Assert.AreEqual(expected, Bytes.StartsWith(input), "Get StartsWith value"); }
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; }
public IntelHEXfile(string filename) { if (filename.ToLower().EndsWith(".hex") != true) { FileErrorMessages.Add("Файл имеет расширение отличное от hex"); } try { StreamReader sr = new StreamReader(filename); bool eof = false; int lineNumber = 0; while (!eof) { lineNumber++; HEXline line = new HEXline(sr.ReadLine(), lineNumber); //if (ErrorMessage == "") ErrorMessage = line.ErrorMessages; FileErrorMessages.AddRange(line.LineErrorMessages); if (line.CriticalErrors == true) { CriticalError = true; } switch (line.recordtype) { case HEXline.RecordType.DataRecord: //data.AddRange(line.data); ulong ij = 0; foreach (byte bt in line.data) { AddressByteSorted.Add((ulong)(line.address + ij), line.data[ij]); ij++; } break; case HEXline.RecordType.EndOfFile: eof = true; break; } if (sr.EndOfStream) { eof = true; } } foreach (KeyValuePair <ulong, byte> dabs in AddressByteSorted) { Addresses.Add(dabs.Key); Bytes.Add(dabs.Value); } for (int i = 0; i < AddressByteSorted.Count; i++) { if (Addresses[i] < minAddress) { minAddress = Addresses[i]; } } for (int i = 0; i < AddressByteSorted.Count; i++) { if (Addresses[i] > maxAddress) { maxAddress = Addresses[i]; } } sr.Close(); sr.Dispose(); } catch (Exception ex) { ErrorMessage = ex.Message; CriticalError = true; } }
public void Serialize (Bytes bytes) { Serialize ((byte[]) bytes); }
internal Worksheet(XlsDocument doc, Record boundSheet, List <Record> sheetRecords) : this(doc) { byte[] byteArray = boundSheet.Data.ByteArray; byte visibility = byteArray[4]; if (visibility == 0x00) { _visibility = WorksheetVisibilities.Visible; } else if (visibility == 0x01) { _visibility = WorksheetVisibilities.Hidden; } else if (visibility == 0x02) { _visibility = WorksheetVisibilities.StrongHidden; } else { throw new ApplicationException(string.Format("Unknown Visibility {0}", visibility)); } byte type = byteArray[5]; if (type == 0x00) { _sheettype = WorksheetTypes.Worksheet; } else if (type == 0x02) { _sheettype = WorksheetTypes.Chart; } else if (type == 0x06) { _sheettype = WorksheetTypes.VBModule; } else { throw new ApplicationException(string.Format("Unknown Sheet Type {0}", type)); } List <Record> rowRecords = new List <Record>(); List <Record> cellRecords = new List <Record>(); for (int i = 0; i < sheetRecords.Count; i++) { Record record = sheetRecords[i]; if (record.IsCellRecord()) { if (record.RID == RID.FORMULA) { Record formulaStringRecord = null; if ((i + i) < sheetRecords.Count) { formulaStringRecord = sheetRecords[i + 1]; if (formulaStringRecord.RID != RID.STRING) { formulaStringRecord = null; } } record = new FormulaRecord(record, formulaStringRecord); } cellRecords.Add(record); } else if (record.RID == RID.ROW) { rowRecords.Add(record); } } //Add the Rows first so they exist for adding the Cells foreach (Record rowRecord in rowRecords) { Bytes rowBytes = rowRecord.Data; ushort rowIndex = rowBytes.Get(0, 2).GetBits().ToUInt16(); Row row = Rows.AddRow(rowIndex); bool isDefaultHeight = rowBytes.Get(6, 2).GetBits().Values[15]; ushort height = 0; if (!isDefaultHeight) { height = rowBytes.Get(6, 2).GetBits().Get(0, 14).ToUInt16(); //TODO: Set height on Row when reading (after Row Height implemented) } bool defaultsWritten = (rowBytes.Get(10, 1).ByteArray[0] == 0x01); if (defaultsWritten) { //TODO: Read ROW record defaults } } foreach (Record record in cellRecords) { AddCells(record); } _name = UnicodeBytes.Read(boundSheet.Data.Get(6, boundSheet.Data.Length - 6), 8); }
public void WithValidBytes_ReturnsContainsValue(bool expected, byte input) { Assert.AreEqual(expected, Bytes.Contains(input), "Get Contains value"); }
public SSEQTrackEvent(byte EventID, EndianBinaryReader er) { this.EventID = EventID; this.TrackNr = er.ReadByte(); this.Offset = (uint)Bytes.Read3BytesAsInt24(er.ReadBytes(3), 0); }
public byte[] GetBytes() { return(Bytes.ToArray()); }
public void WithValidBytes_ReturnsTrue() { Assert.IsTrue(Bytes.IsEqualTo(Bytes), "Get IsEqualToTest value"); Assert.IsTrue(Bytes.IsEqualTo(BitConverter.GetBytes(Value)), "Get IsEqualToTest value"); }
private void AddCells(Record record) { Bytes bytes = record.Data; ushort rowIndex = bytes.Get(0, 2).GetBits().ToUInt16(); ushort colIndex = bytes.Get(2, 2).GetBits().ToUInt16(); ushort lastColIndex = colIndex; ushort offset = 4; byte[] rid = record.RID; bool isMulti = false; if (rid == RID.MULBLANK) { isMulti = true; rid = RID.BLANK; } else if (rid == RID.MULRK) { isMulti = true; rid = RID.RK; } if (isMulti) { lastColIndex = bytes.Get(bytes.Length - 2, 2).GetBits().ToUInt16(); } while (colIndex <= lastColIndex) { Cell cell = Cells.Add((ushort)(rowIndex + 1), (ushort)(colIndex + 1)); ushort xfIndex = bytes.Get(offset, 2).GetBits().ToUInt16(); offset += 2; Bytes data; if (rid == RID.BLANK) { data = new Bytes(); } else if (rid == RID.RK) { data = bytes.Get(offset, 4); offset += 4; cell.SetValue(rid, data); } else { data = bytes.Get(offset, bytes.Length - offset); if (rid == RID.FORMULA) { FormulaRecord formulaRecord = record as FormulaRecord; cell.SetFormula(data, formulaRecord.StringRecord); } else { cell.SetValue(rid, data); } } colIndex++; } }
public void WithValidBytes_ReturnsToTextValue() { Assert.AreEqual("�[", Bytes.ToText(), "Get ToText value"); }
public (PrivateKey PrivateKey, Result Result) GetKey(Address address, SecureString password) { var serializedKey = ReadKey(address.ToString()); if (serializedKey == null) { return(null, Result.Fail("Cannot find key")); } var keyStoreItem = _jsonSerializer.Deserialize <KeyStoreItem>(serializedKey); if (keyStoreItem?.Crypto == null) { return(null, Result.Fail("Cannot deserialize key")); } var validationResult = Validate(keyStoreItem); if (validationResult.ResultType != ResultType.Success) { return(null, validationResult); } byte[] mac = Bytes.FromHexString(keyStoreItem.Crypto.MAC); byte[] iv = Bytes.FromHexString(keyStoreItem.Crypto.CipherParams.IV); byte[] cipher = Bytes.FromHexString(keyStoreItem.Crypto.CipherText); byte[] salt = Bytes.FromHexString(keyStoreItem.Crypto.KDFParams.Salt); var kdfParams = keyStoreItem.Crypto.KDFParams; var passBytes = password.ToByteArray(_keyStoreEncoding); byte[] derivedKey; var kdf = keyStoreItem.Crypto.KDF.Trim(); switch (kdf) { case "scrypt": derivedKey = SCrypt.ComputeDerivedKey(passBytes, salt, kdfParams.N, kdfParams.R, kdfParams.P, null, kdfParams.DkLen); break; case "pbkdf2": var deriveBytes = new Rfc2898DeriveBytes(passBytes, salt, kdfParams.C, HashAlgorithmName.SHA256); derivedKey = deriveBytes.GetBytes(256); break; default: return(null, Result.Fail($"Unsupported algoritm: {kdf}")); } var restoredMac = Keccak.Compute(derivedKey.Slice(kdfParams.DkLen - 16, 16).Concat(cipher).ToArray()).Bytes; if (!Bytes.AreEqual(mac, restoredMac)) { return(null, Result.Fail("Incorrect MAC")); } var cipherType = keyStoreItem.Crypto.Cipher.Trim(); byte[] decryptKey; if (kdf == "scrypt" && cipherType == "aes-128-cbc") { decryptKey = Keccak.Compute(derivedKey.Slice(0, 16)).Bytes.Slice(0, 16); } else { decryptKey = derivedKey.Slice(0, 16); } byte[] key = _symmetricEncrypter.Decrypt(cipher, decryptKey, iv, cipherType); if (key == null) { return(null, Result.Fail("Error during decryption")); } // TODO: maybe only allow to sign here so the key never leaves the area? return(new PrivateKey(key), Result.Success()); }
public void WithValidBytes_ReturnsString(string expected, bool prefix) { Assert.AreEqual(expected, Bytes.ToUpperHex(prefix), "Get ToUpperHex value"); }
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; }
public void WithValidParams_ReturnsSubArray(long startIndex, long length, int expected) { var sub = Bytes.SubArray(startIndex, length); Assert.AreEqual(expected, sub[0]); }
internal static string Read(Bytes bytes, int lengthBits) { Record record = new Record(RID.Empty, bytes); return Read(record, lengthBits, 0); }
public void WithInvalidParams_ReturnsEmpty(long startIndex, long length) { var sub = Bytes.SubArray(startIndex, length); Assert.IsEmpty(sub); }
internal static void Write(string text, Bytes bytes, ref ushort offset) { throw new NotImplementedException(); }
public void WithValidBytes_ReturnsString() { Assert.AreEqual("15-CD-5B-07", Bytes.ToDashedHex(), "Get ToDashedHex value"); }
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; }
public void WithValidBytes_ReturnsString() { Assert.AreEqual("Fc1bBw==", Bytes.ToBase64(), "Get ToBase64 value"); }
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); }
public void update(Bytes newBytes) { update((IList <byte>)newBytes); }
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); }
public static sha @new(Bytes data) { return(new sha((IList <byte>)data)); }
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 void AssertEip145(TestAllTracerWithOutput receipt, string result) { AssertEip145(receipt, Bytes.FromHexString(result)); }
public ByteDeserializer (Bytes buf) { _buffer = new MemoryStream ((byte[]) buf); }
// Token: 0x0600018F RID: 399 RVA: 0x0000886D File Offset: 0x0000786D public Stream AddNamed(Bytes bytes, byte[] name) { return(this.AddNamed(bytes, name, false)); }
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 COLINFO_OPTION_FLAGS() { bool[] bits = new bool[16]; bits[0] = _hidden; Bytes outlineBytes = new Bytes(_outlineLevel); bool[] outlineLevelBits = outlineBytes.GetBits().Get(3).Values; outlineLevelBits.CopyTo(bits, 8); bits[12] = _collapsed; return new Bytes.Bits(bits).GetBytes(); }
public static HexPrefix Leaf(string path) { return(new HexPrefix(true, Bytes.FromHexString(path))); }
private void SetOptionsValue(Bytes bytes) { ushort options = BitConverter.ToUInt16(bytes.ByteArray, 0); if (options >= 8) { _struckOut = true; options -= 8; } else _struckOut = false; if (options >= 4) { _underlined = true; options -= 4; } else _underlined = false; if (options >= 2) { _italic = true; } else _italic = false; }
private void ReadBytes(Bytes bytes) { byte[] byteArray = bytes.ByteArray; _height = BitConverter.ToUInt16(byteArray, 0); SetOptionsValue(bytes.Get(2, 2)); _color = _doc.Workbook.Palette.GetColor(BitConverter.ToUInt16(byteArray, 4)); _weight = FontWeightConverter.Convert(BitConverter.ToUInt16(byteArray, 6)); _escapement = (EscapementTypes) BitConverter.ToUInt16(byteArray, 8); _underline = (UnderlineTypes) byteArray[10]; _fontFamily = (FontFamilies) byteArray[11]; _characterSet = (CharacterSets) byteArray[12]; //skip byte index 13 _fontName = UnicodeBytes.Read(bytes.Get(14, bytes.Length - 14), 8); }
public static HexPrefix Extension(string path) { return(new HexPrefix(false, Bytes.FromHexString(path))); }
internal Font(XlsDocument doc, Bytes bytes) : this(doc) { ReadBytes(bytes); }
public void Can_Invoke_Blockhash() { var code = Bytes.FromHexString("0x60014000"); Assert.Throws <NotImplementedException>(() => RunVirtualMachine(code)); }