test/java/org/apache/fop/fonts/type1/Type1SubsetFileTestCase.java - xmlgraphics-fop - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 /* $Id$ */

 package org.apache.fop.fonts.type1;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.junit.Test;

 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;

 import org.apache.xmlgraphics.fonts.Glyphs;

 import org.apache.fop.fonts.SingleByteFont;
 import org.apache.fop.fonts.type1.PostscriptParser.PSDictionary;
 import org.apache.fop.fonts.type1.PostscriptParser.PSElement;
 import org.apache.fop.fonts.type1.PostscriptParser.PSFixedArray;
 import org.apache.fop.fonts.type1.Type1SubsetFile.BinaryCoder;
 import org.apache.fop.fonts.type1.Type1SubsetFile.BytesNumber;

 public class Type1SubsetFileTestCase {

     private List<byte[]> decodedSections;
     private static final String TEST_FONT_A = "./test/resources/fonts/type1/c0419bt_.pfb";

     @Test
     public void test() throws IOException {
         InputStream in = new FileInputStream(TEST_FONT_A);
         compareCharStringData(TEST_FONT_A, createFontASubset(in, TEST_FONT_A));
     }

     @Test
     public void testStitchFont() throws IOException {
         ByteArrayOutputStream baosHeader = new ByteArrayOutputStream();
         ByteArrayOutputStream baosMain = new ByteArrayOutputStream();
         ByteArrayOutputStream baosTrailer = new ByteArrayOutputStream();

         //Header
         for (int i = 0; i < 10; i++) {
             baosHeader.write(123);
             baosMain.write(123);
         }
         for (int i = 0; i < 10; i++) {
             baosTrailer.write(0);
         }

         Type1SubsetFile subset = new Type1SubsetFile();
         byte[] result = subset.stitchFont(baosHeader, baosMain, baosTrailer);
         ByteArrayInputStream bais = new ByteArrayInputStream(result);
         assertEquals(result.length, 50);
         PFBParser parser = new PFBParser();
         parser.parsePFB(bais);
     }

     @Test
     public void testUpdateSectionSize() throws IOException {
         Type1SubsetFile subset = new Type1SubsetFile();
         ByteArrayOutputStream baos = subset.updateSectionSize(456);
         byte[] lowOrderSize = baos.toByteArray();
         assertEquals(lowOrderSize[0], -56);
         assertEquals(lowOrderSize[1], 1);
     }

     @Test
     public void testVariableContents() {
         Type1SubsetFile subset = new Type1SubsetFile();
         String result = subset.readVariableContents("/myvariable {some variable contents}");
         assertEquals(result, "some variable contents");
         result = subset.readVariableContents("/myvariable {hello {some more text {test} and some more}test}");
         //Should only reads one level deep
         assertEquals(result, "hello test");
     }

     @Test
     public void getOpPositionAndLength() {
         Type1SubsetFile subset = new Type1SubsetFile();
         ArrayList<BytesNumber> ops = new ArrayList<BytesNumber>();
         ops.add(new BytesNumber(10, 1));
         ops.add(new BytesNumber(255, 2));
         ops.add(new BytesNumber(100, 1));
         ops.add(new BytesNumber(97, 1));
         ops.add(new BytesNumber(856, 2));
         assertEquals(subset.getOpPosition(4, ops), 4);
         assertEquals(subset.getOperandsLength(ops), 7);
     }

     @Test
     public void testConcatArrays() {
         byte[] arrayA = {(byte)1, (byte)2, (byte)3, (byte)4, (byte)5};
         byte[] arrayB = {(byte)6, (byte)7, (byte)8, (byte)9, (byte)10};
         Type1SubsetFile subset = new Type1SubsetFile();
         byte[] concatArray = subset.concatArray(arrayA, arrayB);
         assertEquals(concatArray.length, 10);
         assertEquals(concatArray[5], 6);
         assertEquals(concatArray[3], 4);
     }

     @Test
     public void testGetBinaryEntry() {
         byte[] decoded = {(byte)34, (byte)23, (byte)78, (byte)55, (byte)12,
                          (byte)2, (byte)65, (byte)49, (byte)90, (byte)10};
         int[] section = {3, 7};
         Type1SubsetFile subset = new Type1SubsetFile();
         byte[] segment = subset.getBinaryEntry(section, decoded);
         assertEquals(segment.length, 4);
         assertEquals(segment[0], 55);
         assertEquals(segment[3], 65);
     }

     private void compareCharStringData(String font, byte[] subsetFont)
             throws IOException {
         decodedSections = new ArrayList<byte[]>();

         //Reinitialise the input stream as reset only supports 1000 bytes.
         InputStream in = new FileInputStream(font);
         List<PSElement> origElements = parseElements(in);
         List<PSElement> subsetElements = parseElements(new ByteArrayInputStream(subsetFont));

         PSFixedArray origSubs = (PSFixedArray)findElement(origElements, "/Subrs");
         PSFixedArray subsetSubs = (PSFixedArray)findElement(subsetElements, "/Subrs");
         PSDictionary origCharStrings = (PSDictionary)findElement(origElements, "/CharStrings");
         PSDictionary subsetCharStrings = (PSDictionary)findElement(subsetElements, "/CharStrings");
         for (String element : subsetCharStrings.getEntries().keySet()) {
             if (element.equals("/.notdef")) {
                 continue;
             }
             int[] origBinaryCharLocation = origCharStrings.getBinaryEntries().get(element);
             int[] subsetBinaryCharLocation = subsetCharStrings.getBinaryEntries().get(element);

             int origLength = origBinaryCharLocation[1] - origBinaryCharLocation[0];
             int subsetLength = subsetBinaryCharLocation[1] - subsetBinaryCharLocation[0];
             byte[] origCharData = new byte[origLength];
             byte[] subsetCharData = new byte[subsetLength];
             System.arraycopy(decodedSections.get(0), origBinaryCharLocation[0], origCharData, 0, origLength);
             System.arraycopy(decodedSections.get(1), subsetBinaryCharLocation[0], subsetCharData, 0, subsetLength);
             origCharData = BinaryCoder.decodeBytes(origCharData, 4330, 4);
             subsetCharData = BinaryCoder.decodeBytes(subsetCharData, 4330, 4);
             byte[] origFullCharData = readFullCharString(decodedSections.get(0), origCharData, origSubs);
             byte[] subsetFullCharData = readFullCharString(decodedSections.get(1), subsetCharData, subsetSubs);
             assertArrayEquals(origFullCharData, subsetFullCharData);
         }
     }

     private byte[] createFontASubset(InputStream in, String font) throws IOException {
         SingleByteFont sbfont = mock(SingleByteFont.class);
         //Glyph index & selector
         Map<Integer, Integer> glyphs = new HashMap<Integer, Integer>();
         Map<Integer, String> usedCharNames = new HashMap<Integer, String>();
         int count = 0;
         for (int i = 32; i < 127; i++) {
             glyphs.put(i, count++);
             when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)i);
             usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
             when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
         }
         for (int i = 161; i < 204; i++) {
             glyphs.put(i, count++);
             when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)i);
             usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
             when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
         }
         int[] randomGlyphs = {205, 206, 207, 208, 225, 227, 232, 233, 234, 235, 241, 245,
                 248, 249, 250, 251
         };
         for (int i = 0; i < randomGlyphs.length; i++) {
             glyphs.put(randomGlyphs[i], count++);
             when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)randomGlyphs[i]);
             usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
             when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
         }
         for (int i = 256; i < 335; i++) {
             glyphs.put(i, count++);
             when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)i);
             usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
             when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
         }
         when(sbfont.getUsedGlyphNames()).thenReturn(usedCharNames);
         when(sbfont.getUsedGlyphs()).thenReturn(glyphs);
         when(sbfont.getEmbedFileURI()).thenReturn(URI.create(font));
         Type1SubsetFile subset = new Type1SubsetFile();
         return subset.createSubset(in, sbfont);
     }

     private List<PSElement> parseElements(InputStream in)
             throws IOException {
         PFBParser pfbParser = new PFBParser();
         PFBData origData = pfbParser.parsePFB(in);
         PostscriptParser parser = new PostscriptParser();
         byte[] decoded = BinaryCoder.decodeBytes(origData.getEncryptedSegment(), 55665, 4);
         decodedSections.add(decoded);
         return parser.parse(decoded);
     }

     private PSElement findElement(List<PSElement> elements, String operator) {
         for (PSElement element : elements) {
             if (element.getOperator().equals(operator)) {
                 return element;
             }
         }
         return null;
     }

     private byte[] readFullCharString(byte[] decoded, byte[] data, PSFixedArray subroutines) {
         List<BytesNumber> operands = new ArrayList<BytesNumber>();
         for (int i = 0; i < data.length; i++) {
             int cur = data[i] & 0xFF;
             if (cur >= 0 && cur <= 31) {
                 //Found subroutine. Read subroutine, recursively scan and update references
                 if (cur == 10) {
                     if (operands.size() == 0) {
                         continue;
                     }
                     int[] subrData = subroutines.getBinaryEntryByIndex(operands.get(0).getNumber());
                     byte[] subroutine = getBinaryEntry(subrData, decoded);
                     subroutine = BinaryCoder.decodeBytes(subroutine, 4330, 4);
                     subroutine = readFullCharString(decoded, subroutine, subroutines);
                     data = replaceReference(data, subroutine, i - 1 + operands.get(0).getNumBytes(), i);
                 } else {
                     int next = -1;
                     if (cur == 12) {
                         next = data[++i] & 0xFF;
                     }
                     BytesNumber operand = new BytesNumber(cur, i);
                     operand.setName(getName(cur, next));
                 }
                 operands.clear();
             }
             if (cur >= 32 && cur <= 246) {
                 operands.add(new BytesNumber(cur - 139, 1));
             } else if (cur >= 247 && cur <= 250) {
                 operands.add(new BytesNumber((cur - 247) * 256 + (data[i + 1] & 0xFF) + 108, 2));
                 i++;
             } else if (cur >= 251 && cur <= 254) {
                 operands.add(new BytesNumber(-(cur - 251) * 256 - (data[i + 1] & 0xFF) - 108, 2));
                 i++;
             } else if (cur == 255) {
                 int b1 = data[i + 1] & 0xFF;
                 int b2 = data[i + 2] & 0xFF;
                 int b3 = data[i + 3] & 0xFF;
                 int b4 = data[i + 4] & 0xFF;
                 int value = b1 << 24 | b2 << 16 | b3 << 8 | b4;
                 operands.add(new BytesNumber(value, 5));
                 i += 4;
             }
         }
         return data;
     }

     private String getName(int operator, int next) {
         switch (operator) {
         case 14: return "endchar";
         case 13: return "hsbw";
         case 12:
             switch (next) {
             case 0: return "dotsection";
             case 1: return "vstem3";
             case 2: return "hstem3";
             case 6: return "seac";
             case 7: return "sbw";
             case 16: return "callothersubr";
             case 17: return "pop";
             case 33: return "setcurrentpoint";
             default: return "unknown";
             }
         case 9: return "closepath";
         case 6: return "hlineto";
         case 22: return "hmoveto";
         case 31: return "hvcurveto";
         case 5: return "rlineto";
         case 21: return "rmoveto";
         case 8: return "rrcurveto";
         case 30: return "vhcurveto";
         case 7: return "vlineto";
         case 4: return "vmoveto";
         case 1: return "hstem";
         case 3: return "vstem";
         case 10: return "callsubr";
         case 11: return "return";
         default: return "unknown";
         }
     }

     private byte[] replaceReference(byte[] data, byte[] subroutine, int startRef, int endRef) {
         byte[] preBytes = new byte[startRef - 1];
         System.arraycopy(data, 0, preBytes, 0, startRef - 1);
         byte[] postBytes = new byte[data.length - endRef - 1];
         System.arraycopy(data, endRef + 1, postBytes, 0, data.length - endRef - 1);
         data = concatArray(preBytes, subroutine, 1);
         data = concatArray(data, postBytes, 0);
         return data;
     }

     private byte[] getBinaryEntry(int[] position, byte[] decoded) {
         int start = position[0];
         int finish = position[1];
         byte[] line = new byte[finish - start];
         System.arraycopy(decoded, start, line, 0, finish - start);
         return line;
     }

     private byte[] concatArray(byte[] a, byte[] b, int subtract) {
         int aLen = a.length;
         int bLen = b.length - subtract;
         byte[] c = new byte[aLen + bLen];
         System.arraycopy(a, 0, c, 0, aLen);
         System.arraycopy(b, 0, c, aLen, bLen);
         return c;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/* $Id$ */

	package org.apache.fop.fonts.type1;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.net.URI;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.junit.Test;

	import static org.junit.Assert.assertArrayEquals;
	import static org.junit.Assert.assertEquals;
	import static org.mockito.Mockito.mock;
	import static org.mockito.Mockito.when;

	import org.apache.xmlgraphics.fonts.Glyphs;

	import org.apache.fop.fonts.SingleByteFont;
	import org.apache.fop.fonts.type1.PostscriptParser.PSDictionary;
	import org.apache.fop.fonts.type1.PostscriptParser.PSElement;
	import org.apache.fop.fonts.type1.PostscriptParser.PSFixedArray;
	import org.apache.fop.fonts.type1.Type1SubsetFile.BinaryCoder;
	import org.apache.fop.fonts.type1.Type1SubsetFile.BytesNumber;

	public class Type1SubsetFileTestCase {

	private List<byte[]> decodedSections;
	private static final String TEST_FONT_A = "./test/resources/fonts/type1/c0419bt_.pfb";

	@Test
	public void test() throws IOException {
	InputStream in = new FileInputStream(TEST_FONT_A);
	compareCharStringData(TEST_FONT_A, createFontASubset(in, TEST_FONT_A));
	}

	@Test
	public void testStitchFont() throws IOException {
	ByteArrayOutputStream baosHeader = new ByteArrayOutputStream();
	ByteArrayOutputStream baosMain = new ByteArrayOutputStream();
	ByteArrayOutputStream baosTrailer = new ByteArrayOutputStream();

	//Header
	for (int i = 0; i < 10; i++) {
	baosHeader.write(123);
	baosMain.write(123);
	}
	for (int i = 0; i < 10; i++) {
	baosTrailer.write(0);
	}

	Type1SubsetFile subset = new Type1SubsetFile();
	byte[] result = subset.stitchFont(baosHeader, baosMain, baosTrailer);
	ByteArrayInputStream bais = new ByteArrayInputStream(result);
	assertEquals(result.length, 50);
	PFBParser parser = new PFBParser();
	parser.parsePFB(bais);
	}

	@Test
	public void testUpdateSectionSize() throws IOException {
	Type1SubsetFile subset = new Type1SubsetFile();
	ByteArrayOutputStream baos = subset.updateSectionSize(456);
	byte[] lowOrderSize = baos.toByteArray();
	assertEquals(lowOrderSize[0], -56);
	assertEquals(lowOrderSize[1], 1);
	}

	@Test
	public void testVariableContents() {
	Type1SubsetFile subset = new Type1SubsetFile();
	String result = subset.readVariableContents("/myvariable {some variable contents}");
	assertEquals(result, "some variable contents");
	result = subset.readVariableContents("/myvariable {hello {some more text {test} and some more}test}");
	//Should only reads one level deep
	assertEquals(result, "hello test");
	}

	@Test
	public void getOpPositionAndLength() {
	Type1SubsetFile subset = new Type1SubsetFile();
	ArrayList<BytesNumber> ops = new ArrayList<BytesNumber>();
	ops.add(new BytesNumber(10, 1));
	ops.add(new BytesNumber(255, 2));
	ops.add(new BytesNumber(100, 1));
	ops.add(new BytesNumber(97, 1));
	ops.add(new BytesNumber(856, 2));
	assertEquals(subset.getOpPosition(4, ops), 4);
	assertEquals(subset.getOperandsLength(ops), 7);
	}

	@Test
	public void testConcatArrays() {
	byte[] arrayA = {(byte)1, (byte)2, (byte)3, (byte)4, (byte)5};
	byte[] arrayB = {(byte)6, (byte)7, (byte)8, (byte)9, (byte)10};
	Type1SubsetFile subset = new Type1SubsetFile();
	byte[] concatArray = subset.concatArray(arrayA, arrayB);
	assertEquals(concatArray.length, 10);
	assertEquals(concatArray[5], 6);
	assertEquals(concatArray[3], 4);
	}

	@Test
	public void testGetBinaryEntry() {
	byte[] decoded = {(byte)34, (byte)23, (byte)78, (byte)55, (byte)12,
	(byte)2, (byte)65, (byte)49, (byte)90, (byte)10};
	int[] section = {3, 7};
	Type1SubsetFile subset = new Type1SubsetFile();
	byte[] segment = subset.getBinaryEntry(section, decoded);
	assertEquals(segment.length, 4);
	assertEquals(segment[0], 55);
	assertEquals(segment[3], 65);
	}

	private void compareCharStringData(String font, byte[] subsetFont)
	throws IOException {
	decodedSections = new ArrayList<byte[]>();

	//Reinitialise the input stream as reset only supports 1000 bytes.
	InputStream in = new FileInputStream(font);
	List<PSElement> origElements = parseElements(in);
	List<PSElement> subsetElements = parseElements(new ByteArrayInputStream(subsetFont));

	PSFixedArray origSubs = (PSFixedArray)findElement(origElements, "/Subrs");
	PSFixedArray subsetSubs = (PSFixedArray)findElement(subsetElements, "/Subrs");
	PSDictionary origCharStrings = (PSDictionary)findElement(origElements, "/CharStrings");
	PSDictionary subsetCharStrings = (PSDictionary)findElement(subsetElements, "/CharStrings");
	for (String element : subsetCharStrings.getEntries().keySet()) {
	if (element.equals("/.notdef")) {
	continue;
	}
	int[] origBinaryCharLocation = origCharStrings.getBinaryEntries().get(element);
	int[] subsetBinaryCharLocation = subsetCharStrings.getBinaryEntries().get(element);

	int origLength = origBinaryCharLocation[1] - origBinaryCharLocation[0];
	int subsetLength = subsetBinaryCharLocation[1] - subsetBinaryCharLocation[0];
	byte[] origCharData = new byte[origLength];
	byte[] subsetCharData = new byte[subsetLength];
	System.arraycopy(decodedSections.get(0), origBinaryCharLocation[0], origCharData, 0, origLength);
	System.arraycopy(decodedSections.get(1), subsetBinaryCharLocation[0], subsetCharData, 0, subsetLength);
	origCharData = BinaryCoder.decodeBytes(origCharData, 4330, 4);
	subsetCharData = BinaryCoder.decodeBytes(subsetCharData, 4330, 4);
	byte[] origFullCharData = readFullCharString(decodedSections.get(0), origCharData, origSubs);
	byte[] subsetFullCharData = readFullCharString(decodedSections.get(1), subsetCharData, subsetSubs);
	assertArrayEquals(origFullCharData, subsetFullCharData);
	}
	}

	private byte[] createFontASubset(InputStream in, String font) throws IOException {
	SingleByteFont sbfont = mock(SingleByteFont.class);
	//Glyph index & selector
	Map<Integer, Integer> glyphs = new HashMap<Integer, Integer>();
	Map<Integer, String> usedCharNames = new HashMap<Integer, String>();
	int count = 0;
	for (int i = 32; i < 127; i++) {
	glyphs.put(i, count++);
	when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)i);
	usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
	when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
	}
	for (int i = 161; i < 204; i++) {
	glyphs.put(i, count++);
	when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)i);
	usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
	when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
	}
	int[] randomGlyphs = {205, 206, 207, 208, 225, 227, 232, 233, 234, 235, 241, 245,
	248, 249, 250, 251
	};
	for (int i = 0; i < randomGlyphs.length; i++) {
	glyphs.put(randomGlyphs[i], count++);
	when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)randomGlyphs[i]);
	usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
	when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
	}
	for (int i = 256; i < 335; i++) {
	glyphs.put(i, count++);
	when(sbfont.getUnicodeFromSelector(count)).thenReturn((char)i);
	usedCharNames.put(i, String.format("/%s", Glyphs.charToGlyphName((char)i)));
	when(sbfont.getGlyphName(i)).thenReturn(AdobeStandardEncoding.getCharFromCodePoint(i));
	}
	when(sbfont.getUsedGlyphNames()).thenReturn(usedCharNames);
	when(sbfont.getUsedGlyphs()).thenReturn(glyphs);
	when(sbfont.getEmbedFileURI()).thenReturn(URI.create(font));
	Type1SubsetFile subset = new Type1SubsetFile();
	return subset.createSubset(in, sbfont);
	}

	private List<PSElement> parseElements(InputStream in)
	throws IOException {
	PFBParser pfbParser = new PFBParser();
	PFBData origData = pfbParser.parsePFB(in);
	PostscriptParser parser = new PostscriptParser();
	byte[] decoded = BinaryCoder.decodeBytes(origData.getEncryptedSegment(), 55665, 4);
	decodedSections.add(decoded);
	return parser.parse(decoded);
	}

	private PSElement findElement(List<PSElement> elements, String operator) {
	for (PSElement element : elements) {
	if (element.getOperator().equals(operator)) {
	return element;
	}
	}
	return null;
	}

	private byte[] readFullCharString(byte[] decoded, byte[] data, PSFixedArray subroutines) {
	List<BytesNumber> operands = new ArrayList<BytesNumber>();
	for (int i = 0; i < data.length; i++) {
	int cur = data[i] & 0xFF;
	if (cur >= 0 && cur <= 31) {
	//Found subroutine. Read subroutine, recursively scan and update references
	if (cur == 10) {
	if (operands.size() == 0) {
	continue;
	}
	int[] subrData = subroutines.getBinaryEntryByIndex(operands.get(0).getNumber());
	byte[] subroutine = getBinaryEntry(subrData, decoded);
	subroutine = BinaryCoder.decodeBytes(subroutine, 4330, 4);
	subroutine = readFullCharString(decoded, subroutine, subroutines);
	data = replaceReference(data, subroutine, i - 1 + operands.get(0).getNumBytes(), i);
	} else {
	int next = -1;
	if (cur == 12) {
	next = data[++i] & 0xFF;
	}
	BytesNumber operand = new BytesNumber(cur, i);
	operand.setName(getName(cur, next));
	}
	operands.clear();
	}
	if (cur >= 32 && cur <= 246) {
	operands.add(new BytesNumber(cur - 139, 1));
	} else if (cur >= 247 && cur <= 250) {
	operands.add(new BytesNumber((cur - 247) * 256 + (data[i + 1] & 0xFF) + 108, 2));
	i++;
	} else if (cur >= 251 && cur <= 254) {
	operands.add(new BytesNumber(-(cur - 251) * 256 - (data[i + 1] & 0xFF) - 108, 2));
	i++;
	} else if (cur == 255) {
	int b1 = data[i + 1] & 0xFF;
	int b2 = data[i + 2] & 0xFF;
	int b3 = data[i + 3] & 0xFF;
	int b4 = data[i + 4] & 0xFF;
	int value = b1 << 24 \| b2 << 16 \| b3 << 8 \| b4;
	operands.add(new BytesNumber(value, 5));
	i += 4;
	}
	}
	return data;
	}

	private String getName(int operator, int next) {
	switch (operator) {
	case 14: return "endchar";
	case 13: return "hsbw";
	case 12:
	switch (next) {
	case 0: return "dotsection";
	case 1: return "vstem3";
	case 2: return "hstem3";
	case 6: return "seac";
	case 7: return "sbw";
	case 16: return "callothersubr";
	case 17: return "pop";
	case 33: return "setcurrentpoint";
	default: return "unknown";
	}
	case 9: return "closepath";
	case 6: return "hlineto";
	case 22: return "hmoveto";
	case 31: return "hvcurveto";
	case 5: return "rlineto";
	case 21: return "rmoveto";
	case 8: return "rrcurveto";
	case 30: return "vhcurveto";
	case 7: return "vlineto";
	case 4: return "vmoveto";
	case 1: return "hstem";
	case 3: return "vstem";
	case 10: return "callsubr";
	case 11: return "return";
	default: return "unknown";
	}
	}

	private byte[] replaceReference(byte[] data, byte[] subroutine, int startRef, int endRef) {
	byte[] preBytes = new byte[startRef - 1];
	System.arraycopy(data, 0, preBytes, 0, startRef - 1);
	byte[] postBytes = new byte[data.length - endRef - 1];
	System.arraycopy(data, endRef + 1, postBytes, 0, data.length - endRef - 1);
	data = concatArray(preBytes, subroutine, 1);
	data = concatArray(data, postBytes, 0);
	return data;
	}

	private byte[] getBinaryEntry(int[] position, byte[] decoded) {
	int start = position[0];
	int finish = position[1];
	byte[] line = new byte[finish - start];
	System.arraycopy(decoded, start, line, 0, finish - start);
	return line;
	}

	private byte[] concatArray(byte[] a, byte[] b, int subtract) {
	int aLen = a.length;
	int bLen = b.length - subtract;
	byte[] c = new byte[aLen + bLen];
	System.arraycopy(a, 0, c, 0, aLen);
	System.arraycopy(b, 0, c, aLen, bLen);
	return c;
	}
	}