lsm/PdfPig
1
0
Fork 0
mirror of https://github.com/UglyToad/PdfPig.git synced 2025-10-14 19:05:01 +08:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

merge from upstream

Browse Source
This commit is contained in:
modest-as
2018-04-13 00:32:12 +01:00
parent 05da4d0726 08f11343d3
commit fe3f627f9c
24 changed files with 1639 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1134
src/UglyToad.PdfPig.Tests/Fonts/Type1/AdobeUtopia.pfa Normal file
View File

File diff suppressed because it is too large Load Diff

BIN
src/UglyToad.PdfPig.Tests/Fonts/Type1/Raleway-Black.pfb Normal file
View File

Binary file not shown.

44
src/UglyToad.PdfPig.Tests/Fonts/Type1/Type1FontParserTests.cs
View File

@@ -1,18 +1,41 @@
namespace UglyToad.PdfPig.Tests.Fonts.Type1
{
using System;
using System.IO;
using System.Linq;
using System.Text;
using PdfPig.Fonts.Type1.Parser;
using PdfPig.IO;
using PdfPig.Util;
using Xunit;
public class Type1FontParserTests
{
private readonly Type1FontParser parser = new Type1FontParser();
private readonly Type1FontParser parser = new Type1FontParser(new Type1EncryptedPortionParser());
[Fact]
public void CanRead()
public void CanReadHexEncryptedPortion()
{
var bytes = GetFileBytes("AdobeUtopia.pfa");
parser.Parse(new ByteArrayInputBytes(bytes),0, 0);
}
[Fact]
public void CanReadBinaryEncryptedPortionOfFullPfb()
{
// TODO: support reading in these pfb files
var bytes = GetFileBytes("Raleway-Black.pfb");
parser.Parse(new ByteArrayInputBytes(bytes), 0, 0);
}
[Fact]
public void CanReadAsciiPart()
{
var bytes = StringBytesTestConverter.Convert(Cmbx12, false);
parser.Parse(bytes.Bytes);
parser.Parse(bytes.Bytes, 0, 0);
}
private const string Cmbx12 = @"%!PS-AdobeFont-1.1: CMBX12 1.0
@@ -91,5 +114,20 @@ currentfile eexec
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
cleartomark";
private static byte[] GetFileBytes(string name)
{
var manifestFiles = typeof(Type1FontParserTests).Assembly.GetManifestResourceNames();
var match = manifestFiles.Single(x => x.IndexOf(name, StringComparison.InvariantCultureIgnoreCase) >= 0);
using (var memoryStream = new MemoryStream())
using (var stream = typeof(Type1FontParserTests).Assembly.GetManifestResourceStream(match))
{
stream.CopyTo(memoryStream);
return memoryStream.ToArray();
}
}
}
}

BIN
src/UglyToad.PdfPig.Tests/Integration/Documents/Pig Production Handbook.pdf Normal file
View File

Binary file not shown.

BIN
src/UglyToad.PdfPig.Tests/Integration/Documents/Pig Reproduction Powerpoint.pdf Normal file
View File

Binary file not shown.

36
src/UglyToad.PdfPig.Tests/Integration/PigProductionHandbookTests.cs Normal file
View File

@@ -0,0 +1,36 @@
namespace UglyToad.PdfPig.Tests.Integration
{
using System;
using System.IO;
using Xunit;
public class PigProductionHandbookTests
{
private static string GetFilename()
{
var documentFolder = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..", "..", "..", "Integration", "Documents"));
return Path.Combine(documentFolder, "Pig Production Handbook.pdf");
}
[Fact]
public void CanReadContent()
{
using (var document = PdfDocument.Open(GetFilename()))
{
var page = document.GetPage(1);
Assert.Contains("For the small holders at village level", page.Text);
}
}
[Fact]
public void HasCorrectNumberOfPages()
{
using (var document = PdfDocument.Open(GetFilename()))
{
Assert.Equal(86, document.NumberOfPages);
}
}
}
}

36
src/UglyToad.PdfPig.Tests/Integration/PigReproductionPowerpointTests.cs Normal file
View File

@@ -0,0 +1,36 @@
namespace UglyToad.PdfPig.Tests.Integration
{
using System;
using System.IO;
using Xunit;
public class PigReproductionPowerpointTests
{
private static string GetFilename()
{
var documentFolder = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "..", "..", "..", "Integration", "Documents"));
return Path.Combine(documentFolder, "Pig Reproduction Powerpoint.pdf");
}
[Fact]
public void CanReadContent()
{
using (var document = PdfDocument.Open(GetFilename()))
{
var page = document.GetPage(1);
Assert.Contains("Pigs per sow per year: 18 to 27", page.Text);
}
}
[Fact]
public void HasCorrectNumberOfPages()
{
using (var document = PdfDocument.Open(GetFilename()))
{
Assert.Equal(35, document.NumberOfPages);
}
}
}
}

13
src/UglyToad.PdfPig.Tests/UglyToad.PdfPig.Tests.csproj
View File

@@ -8,16 +8,21 @@
</PropertyGroup>
<ItemGroup>
<None Remove="Fonts\TrueType\*" />
<None Remove="Fonts\TrueType\*.ttf" />
<None Remove="Fonts\Type1\*.pfa" />
<None Remove="Fonts\Type1\*.pfb" />
<None Remove="Integration\Documents\*" />
</ItemGroup>
<ItemGroup>
<EmbeddedResource Include="Fonts\TrueType\google-simple-doc.ttf">
<EmbeddedResource Include="Fonts\TrueType\*.ttf">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</EmbeddedResource>
<EmbeddedResource Include="Fonts\TrueType\Roboto-Regular.ttf">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
<EmbeddedResource Include="Fonts\Type1\*.pfa">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</EmbeddedResource>
<EmbeddedResource Include="Fonts\Type1\*.pfb">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</EmbeddedResource>
<Content Include="Integration\Documents\*">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>

5
src/UglyToad.PdfPig/Fonts/CidFonts/ICidFont.cs
View File

@@ -1,6 +1,7 @@
namespace UglyToad.PdfPig.Fonts.CidFonts
{
using Core;
using Geometry;
using Tokenization.Tokens;
/// <summary>
@@ -39,8 +40,8 @@
FontDescriptor Descriptor { get; }
decimal GetWidthFromFont(int characterCode);
decimal GetWidthFromDictionary(int cid);
PdfRectangle GetBoundingBox(int characterCode);
}
}

4
src/UglyToad.PdfPig/Fonts/CidFonts/ICidFontProgram.cs
View File

@@ -1,10 +1,12 @@
namespace UglyToad.PdfPig.Fonts.CidFonts
{
using Geometry;
/// <summary>
/// Represents either an Adobe Type 1 or TrueType font program for a CIDFont.
/// </summary>
internal interface ICidFontProgram
{
bool TryGetBoundingBox(int characterCode, out PdfRectangle boundingBox);
}
}

6
src/UglyToad.PdfPig/Fonts/CidFonts/Type0CidFont.cs
View File

@@ -1,6 +1,7 @@
namespace UglyToad.PdfPig.Fonts.CidFonts
{
using Core;
using Geometry;
using Tokenization.Tokens;
/// <inheritdoc/>
@@ -32,5 +33,10 @@
{
throw new System.NotImplementedException();
}
public PdfRectangle GetBoundingBox(int characterCode)
{
throw new System.NotImplementedException();
}
}
}

16
src/UglyToad.PdfPig/Fonts/CidFonts/Type2CidFont.cs
View File

@@ -2,6 +2,7 @@
{
using System.Collections.Generic;
using Core;
using Geometry;
using Tokenization.Tokens;
/// <inheritdoc />
@@ -57,5 +58,20 @@
return Descriptor.MissingWidth;
}
public PdfRectangle GetBoundingBox(int characterCode)
{
if (fontProgram == null)
{
return Descriptor.BoundingBox;
}
if (fontProgram.TryGetBoundingBox(characterCode, out var result))
{
return result;
}
return Descriptor.BoundingBox;
}
}
}

9
src/UglyToad.PdfPig/Fonts/Composite/Type0Font.cs
View File

@@ -76,13 +76,18 @@
return fontMatrix.Transform(GetBoundingBoxInGlyphSpace(characterCode));
}
private PdfRectangle GetBoundingBoxInGlyphSpace(int characterCode)
public decimal GetWidth(int characterCode)
{
var cid = CMap.ConvertToCid(characterCode);
var fromFont = CidFont.GetWidthFromDictionary(cid);
return new PdfRectangle(0, 0, fromFont, 0);
return fromFont;
}
public PdfRectangle GetBoundingBoxInGlyphSpace(int characterCode)
{
return CidFont.GetBoundingBox(characterCode);
}
public TransformationMatrix GetFontMatrix()

12
src/UglyToad.PdfPig/Fonts/Parser/Handlers/Type1FontHandler.cs
View File

@@ -12,6 +12,7 @@
using Tokenization.Tokens;
using Type1;
using Type1.Parser;
using Util;
internal class Type1FontHandler : IFontHandler
{
@@ -102,16 +103,17 @@
try
{
var stream = pdfScanner.Get(descriptor.FontFile.ObjectKey.Data).Data as StreamToken;
if (stream == null)
if (!(pdfScanner.Get(descriptor.FontFile.ObjectKey.Data).Data is StreamToken stream))
{
return null;
}
var length1 = stream.StreamDictionary.Get<NumericToken>(NameToken.Length1, pdfScanner);
var length2 = stream.StreamDictionary.Get<NumericToken>(NameToken.Length2, pdfScanner);
var bytes = stream.Decode(filterProvider);
var font = type1FontParser.Parse(new ByteArrayInputBytes(bytes));
var font = type1FontParser.Parse(new ByteArrayInputBytes(bytes), length1.Int, length2.Int);
return font;
}

10
src/UglyToad.PdfPig/Fonts/Simple/TrueTypeSimpleFont.cs
View File

@@ -85,19 +85,17 @@
private PdfRectangle GetBoundingBoxInGlyphSpace(int characterCode)
{
if (font?.CMapTable == null)
if (font == null)
{
return descriptor.BoundingBox;
}
if (!font.CMapTable.TryGetGlyphIndex(characterCode, out var index))
if (font.TryGetBoundingBox(characterCode, out var bounds))
{
return descriptor.BoundingBox;
return bounds;
}
var glyph = font.GlyphTable.Glyphs[index];
return glyph?.GlyphBounds ?? descriptor.BoundingBox;
return descriptor.BoundingBox;
}
public TransformationMatrix GetFontMatrix()

27
src/UglyToad.PdfPig/Fonts/TrueType/TrueTypeFont.cs
View File

@@ -3,6 +3,7 @@
using System;
using System.Collections.Generic;
using CidFonts;
using Geometry;
using Parser;
using Tables;
@@ -31,5 +32,31 @@
CMapTable = tableRegister.CMapTable;
GlyphTable = tableRegister.GlyphDataTable;
}
public bool TryGetBoundingBox(int characterCode, out PdfRectangle boundingBox)
{
boundingBox = default(PdfRectangle);
if (CMapTable == null)
{
return false;
}
if (!CMapTable.TryGetGlyphIndex(characterCode, out var index))
{
return false;
}
var glyph = GlyphTable.Glyphs[index];
if (glyph?.GlyphBounds == null)
{
return false;
}
boundingBox = glyph.GlyphBounds;
return true;
}
}
}

123
src/UglyToad.PdfPig/Fonts/Type1/Parser/Type1EncryptedPortionParser.cs Normal file
View File

@@ -0,0 +1,123 @@
namespace UglyToad.PdfPig.Fonts.Type1.Parser
{
using System.Collections.Generic;
using System.Linq;
using PdfPig.Parser.Parts;
using Tokenization.Tokens;
using Util;
internal class Type1EncryptedPortionParser
{
private const ushort EexecEncryptionKey = 55665;
private const int EexecRandomBytes = 4;
public void Parse(IReadOnlyList<byte> bytes)
{
if (!IsBinary(bytes))
{
bytes = ConvertHexToBinary(bytes);
}
var decrypted = Decrypt(bytes, EexecEncryptionKey, EexecRandomBytes);
var str = OtherEncodings.BytesAsLatin1String(decrypted.ToArray());
}
/// <summary>
/// To distinguish between binary and hex the first 4 bytes (of the ciphertext) for hex must
/// obey these restrictions:
/// The first byte must not be whitespace.
/// One of the first four ciphertext bytes must not be an ASCII hex character.
/// </summary>
/// <param name="bytes"></param>
/// <returns></returns>
private static bool IsBinary(IReadOnlyList<byte> bytes)
{
if (bytes.Count < 4)
{
return true;
}
if (ReadHelper.IsWhitespace(bytes[0]))
{
return true;
}
for (var i = 1; i < 4; i++)
{
var b = bytes[i];
if (!ReadHelper.IsHex(b))
{
return true;
}
}
return false;
}
private static IReadOnlyList<byte> ConvertHexToBinary(IReadOnlyList<byte> bytes)
{
var result = new List<byte>(bytes.Count / 2);
var last = '\0';
var offset = 0;
for (var i = 0; i < bytes.Count; i++)
{
var c = (char)bytes[i];
if (!ReadHelper.IsHex(c))
{
// TODO: do I need to assert this must be whitespace?
continue;
}
if (offset == 1)
{
result.Add(HexToken.Convert(last, c));
offset = 0;
}
else
{
offset++;
}
last = c;
}
return result;
}
private static IReadOnlyList<byte> Decrypt(IReadOnlyList<byte> bytes, int key, int randomBytes)
{
if (randomBytes == -1)
{
return bytes;
}
if (randomBytes > bytes.Count || bytes.Count == 0)
{
return new byte[0];
}
const int c1 = 52845;
const int c2 = 22719;
var plainBytes = new byte[bytes.Count - randomBytes];
for (var i = 0; i < bytes.Count; i++)
{
var cipher = bytes[i] & 0xFF;
var plain = cipher ^ key >> 8;
if (i >= randomBytes)
{
plainBytes[i - randomBytes] = (byte)plain;
}
key = (cipher + key) * c1 + c2 & 0xffff;
}
return plainBytes;
}
}
}

184
src/UglyToad.PdfPig/Fonts/Type1/Parser/Type1FontParser.cs
View File

@@ -11,8 +11,39 @@
internal class Type1FontParser
{
public Type1Font Parse(IInputBytes inputBytes)
private const string ClearToMark = "cleartomark";
private const int PfbFileIndicator = 0x80;
private readonly Type1EncryptedPortionParser encryptedPortionParser;
public Type1FontParser(Type1EncryptedPortionParser encryptedPortionParser)
{
this.encryptedPortionParser = encryptedPortionParser;
}
/// <summary>
/// Parses an embedded Adobe Type 1 font file.
/// </summary>
/// <param name="inputBytes">The bytes of the font program.</param>
/// <param name="length1">The length in bytes of the clear text portion of the font program.</param>
/// <param name="length2">The length in bytes of the encrypted portion of the font program.</param>
/// <returns>The parsed type 1 font.</returns>
public Type1Font Parse(IInputBytes inputBytes, int length1, int length2)
{
// Sometimes the entire PFB file including the header bytes can be included which prevents parsing in the normal way.
var isEntirePfbFile = inputBytes.Peek() == PfbFileIndicator;
IReadOnlyList<byte> eexecPortion = new byte[0];
if (isEntirePfbFile)
{
var (ascii, binary) = ReadPfbHeader(inputBytes);
eexecPortion = binary;
inputBytes = new ByteArrayInputBytes(ascii);
}
var scanner = new CoreTokenScanner(inputBytes);
if (!scanner.TryReadToken(out CommentToken comment) || !comment.Data.StartsWith("!"))
@@ -45,20 +76,65 @@
var nameTokenizer = new Type1NameTokenizer();
scanner.RegisterCustomTokenizer((byte)'{', arrayTokenizer);
scanner.RegisterCustomTokenizer((byte)'/', nameTokenizer);
try
{
var tempEexecPortion = new List<byte>();
var tokenSet = new PreviousTokenSet();
tokenSet.Add(scanner.CurrentToken);
while (scanner.MoveNext())
{
if (scanner.CurrentToken is OperatorToken operatorToken)
{
HandleOperator(operatorToken, inputBytes, scanner, tokenSet, dictionaries);
if (Equals(scanner.CurrentToken, OperatorToken.Eexec))
{
int offset = 0;
while (inputBytes.MoveNext())
{
if (inputBytes.CurrentByte == (byte)ClearToMark[offset])
{
offset++;
}
else
{
if (offset > 0)
{
for (int i = 0; i < offset; i++)
{
tempEexecPortion.Add((byte)ClearToMark[i]);
}
}
offset = 0;
}
if (offset == ClearToMark.Length)
{
break;
}
if (offset > 0)
{
continue;
}
tempEexecPortion.Add(inputBytes.CurrentByte);
}
}
else
{
HandleOperator(operatorToken, scanner, tokenSet, dictionaries);
}
}
tokenSet.Add(scanner.CurrentToken);
}
if (!isEntirePfbFile)
{
eexecPortion = tempEexecPortion;
}
}
finally
{
@@ -70,10 +146,79 @@
var matrix = GetFontMatrix(dictionaries);
var boundingBox = GetBoundingBox(dictionaries);
encryptedPortionParser.Parse(eexecPortion);
return new Type1Font(name, encoding, matrix, boundingBox);
}
private void HandleOperator(OperatorToken token, IInputBytes bytes, ISeekableTokenScanner scanner, PreviousTokenSet set, List<DictionaryToken> dictionaries)
/// <summary>
/// Where an entire PFB file has been embedded in the PDF we read the header first.
/// </summary>
private static (byte[] ascii, byte[] binary) ReadPfbHeader(IInputBytes bytes)
{
/*
* The header is a 6 byte sequence. The first byte is 0x80 followed by 0x01 for the ASCII record indicator.
* The following 4 bytes determine the size/length of the ASCII part of the PFB file.
* After the ASCII part another 6 byte sequence is present, this time 0x80 0x02 for the Binary part length.
* A 3rd sequence is present at the end re-stating the ASCII length but this is surplus to requirements.
*/
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
int ReadSize(byte recordType)
{
bytes.MoveNext();
if (bytes.CurrentByte != PfbFileIndicator)
{
throw new InvalidOperationException($"File does not start with 0x80, which indicates a full PFB file. Instead got: {bytes.CurrentByte}");
}
bytes.MoveNext();
if (bytes.CurrentByte != recordType)
{
throw new InvalidOperationException($"Encountered unexpected header type in the PFB file: {bytes.CurrentByte}");
}
bytes.MoveNext();
int size = bytes.CurrentByte;
bytes.MoveNext();
size += bytes.CurrentByte << 8;
bytes.MoveNext();
size += bytes.CurrentByte << 16;
bytes.MoveNext();
size += bytes.CurrentByte << 24;
return size;
}
var asciiSize = ReadSize(0x01);
var asciiPart = new byte[asciiSize];
int i = 0;
while (i < asciiSize)
{
bytes.MoveNext();
asciiPart[i] = bytes.CurrentByte;
i++;
}
var binarySize = ReadSize(0x02);
var binaryPart = new byte[binarySize];
i = 0;
while (i < binarySize)
{
bytes.MoveNext();
binaryPart[i] = bytes.CurrentByte;
i++;
}
return (asciiPart, binaryPart);
}
private static void HandleOperator(OperatorToken token, ISeekableTokenScanner scanner, PreviousTokenSet set, List<DictionaryToken> dictionaries)
{
switch (token.Data)
{
@@ -83,30 +228,11 @@
dictionaries.Add(dictionary);
break;
case "currentfile":
if (!scanner.MoveNext() || scanner.CurrentToken != OperatorToken.Eexec)
{
return;
}
// For now we will not read this stuff.
SkipEncryptedContent(bytes);
break;
default:
return;
}
}
private void SkipEncryptedContent(IInputBytes bytes)
{
bytes.Seek(bytes.Length - 1);
while (bytes.MoveNext())
{
// skip to end.
}
}
private static DictionaryToken ReadDictionary(int keys, ISeekableTokenScanner scanner)
{
IToken previousToken = null;
@@ -234,8 +360,8 @@
{
for (var i = 0; i < encodingArray.Data.Count; i += 2)
{
var code = (NumericToken) encodingArray.Data[i];
var name = (NameToken) encodingArray.Data[i + 1];
var code = (NumericToken)encodingArray.Data[i];
var name = (NameToken)encodingArray.Data[i + 1];
result[code.Int] = name.Data;
}
@@ -266,10 +392,10 @@
{
if (dictionary.TryGet(NameToken.FontBbox, out var token) && token is ArrayToken array && array.Data.Count == 4)
{
var x1 = (NumericToken) array.Data[0];
var y1 = (NumericToken) array.Data[1];
var x2 = (NumericToken) array.Data[2];
var y2 = (NumericToken) array.Data[3];
var x1 = (NumericToken)array.Data[0];
var y1 = (NumericToken)array.Data[1];
var x2 = (NumericToken)array.Data[2];
var y2 = (NumericToken)array.Data[3];
return new PdfRectangle(x1.Data, y1.Data, x2.Data, y2.Data);
}

2
src/UglyToad.PdfPig/IO/ByteArrayInputBytes.cs
View File

@@ -1,11 +1,13 @@
namespace UglyToad.PdfPig.IO
{
using System.Collections.Generic;
using System.Diagnostics;
internal class ByteArrayInputBytes : IInputBytes
{
private readonly IReadOnlyList<byte> bytes;
[DebuggerStepThrough]
public ByteArrayInputBytes(IReadOnlyList<byte> bytes)
{
this.bytes = bytes;

5
src/UglyToad.PdfPig/Parser/Parts/ReadHelper.cs
View File

@@ -250,8 +250,9 @@
{
return ' ' == c;
}
public static bool IsHexDigit(char ch)
public static bool IsHex(byte b) => IsHex((char) b);
public static bool IsHex(char ch)
{
return char.IsDigit(ch) || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');
}

2
src/UglyToad.PdfPig/Parser/PdfDocumentFactory.cs
View File

@@ -104,7 +104,7 @@
cMapCache,
filterProvider, pdfScanner),
new TrueTypeFontHandler(log, pdfScanner, filterProvider, cMapCache, fontDescriptorFactory, trueTypeFontParser, encodingReader),
new Type1FontHandler(pdfScanner, cMapCache, filterProvider, fontDescriptorFactory, encodingReader, new Type1FontParser()),
new Type1FontHandler(pdfScanner, cMapCache, filterProvider, fontDescriptorFactory, encodingReader, new Type1FontParser(new Type1EncryptedPortionParser())),
new Type3FontHandler(pdfScanner, cMapCache, filterProvider, encodingReader));
var resourceContainer = new ResourceContainer(pdfScanner, fontFactory);

2
src/UglyToad.PdfPig/Tokenization/NameTokenizer.cs
View File

@@ -36,7 +36,7 @@
}
else if (escapeActive)
{
if (ReadHelper.IsHexDigit((char)b))
if (ReadHelper.IsHex((char)b))
{
escapedChars[postEscapeRead] = (char)b;
postEscapeRead++;

17
src/UglyToad.PdfPig/Tokenization/Tokens/DictionaryToken.cs
View File

@@ -3,6 +3,8 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Parser.Parts;
using Scanner;
using Util.JetBrains.Annotations;
internal class DictionaryToken : IDataToken<IReadOnlyDictionary<string, IToken>>
@@ -39,6 +41,21 @@
{
Data = data;
}
public T Get<T>(NameToken name, IPdfTokenScanner scanner) where T : IToken
{
if (!TryGet(name, out var token) || !(token is T typedToken))
{
if (!(token is IndirectReferenceToken indirectReference))
{
throw new InvalidOperationException($"Dictionary does not contain token with name {name} of type {typeof(T).Name}.");
}
typedToken = DirectObjectFinder.Get<T>(indirectReference, scanner);
}
return typedToken;
}
public bool TryGet(NameToken name, out IToken token)
{

16
src/UglyToad.PdfPig/Tokenization/Tokens/HexToken.cs
View File

@@ -32,14 +32,6 @@ namespace UglyToad.PdfPig.Tokenization.Tokens
{'f', 0x0F }
};
private static byte Convert(char high, char low)
{
var highByte = HexMap[high];
var lowByte = HexMap[low];
return (byte)(highByte << 4 | lowByte);
}
public string Data { get; }
public IReadOnlyList<byte> Bytes { get; }
@@ -75,6 +67,14 @@ namespace UglyToad.PdfPig.Tokenization.Tokens
Data = builder.ToString();
}
public static byte Convert(char high, char low)
{
var highByte = HexMap[high];
var lowByte = HexMap[low];
return (byte)(highByte << 4 | lowByte);
}
public static int ConvertHexBytesToInt(HexToken token)
{
var bytes = token.Bytes;