Author: lehmi
Date: Sun Mar 10 10:41:32 2024
New Revision: 1916209
URL: http://svn.apache.org/viewvc?rev=1916209&view=rev
Log:
PDFBOX-5725: simply the implementation of CharStringCommand as proposed by Axel
Howind
Modified:
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/CharStringCommand.java
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/Type1CharStringParser.java
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/Type2CharString.java
pdfbox/trunk/fontbox/src/test/java/org/apache/fontbox/cff/CharStringCommandTest.java
Modified:
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/CharStringCommand.java
URL:
http://svn.apache.org/viewvc/pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/CharStringCommand.java?rev=1916209&r1=1916208&r2=1916209&view=diff
==============================================================================
---
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/CharStringCommand.java
(original)
+++
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/CharStringCommand.java
Sun Mar 10 10:41:32 2024
@@ -16,193 +16,151 @@
*/
package org.apache.fontbox.cff;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
+import java.util.Arrays;
/**
* This class represents a CharStringCommand.
*
* @author Villu Ruusmann
*/
-public class CharStringCommand
+public enum CharStringCommand
{
+ HSTEM(Type1KeyWord.HSTEM, Type2KeyWord.HSTEM, 1),
+ VSTEM(Type1KeyWord.VSTEM, Type2KeyWord.VSTEM, 3),
+ VMOVETO(Type1KeyWord.VMOVETO, Type2KeyWord.VMOVETO,4),
+ RLINETO(Type1KeyWord.RLINETO, Type2KeyWord.RLINETO,5),
+ HLINETO(Type1KeyWord.HLINETO, Type2KeyWord.HLINETO,6),
+ VLINETO(Type1KeyWord.VLINETO, Type2KeyWord.VLINETO,7),
+ RRCURVETO(Type1KeyWord.RRCURVETO, Type2KeyWord.RRCURVETO,8),
+ CLOSEPATH(Type1KeyWord.CLOSEPATH, null,9),
+ CALLSUBR(Type1KeyWord.CALLSUBR, Type2KeyWord.CALLSUBR,10),
+ RET(Type1KeyWord.RET, Type2KeyWord.RET,11),
+ ESCAPE(Type1KeyWord.ESCAPE, Type2KeyWord.ESCAPE,12),
+ HSBW(Type1KeyWord.HSBW, null,13),
+ ENDCHAR(Type1KeyWord.ENDCHAR, Type2KeyWord.ENDCHAR,14),
+ HSTEMHM(null, Type2KeyWord.HSTEMHM,18),
+ HINTMASK(null, Type2KeyWord.HINTMASK,19),
+ CNTRMASK(null, Type2KeyWord.CNTRMASK,20),
+ RMOVETO(Type1KeyWord.RMOVETO, Type2KeyWord.RMOVETO,21),
+ HMOVETO(Type1KeyWord.HMOVETO, Type2KeyWord.HMOVETO,22),
+ VSTEMHM(null, Type2KeyWord.VSTEMHM,23),
+ RCURVELINE(null, Type2KeyWord.RCURVELINE,24),
+ RLINECURVE(null, Type2KeyWord.RLINECURVE,25),
+ VVCURVETO(null, Type2KeyWord.VVCURVETO,26),
+ HHCURVETO(null, Type2KeyWord.HHCURVETO,27),
+ SHORTINT(null, Type2KeyWord.SHORTINT,28),
+ CALLGSUBR(null, Type2KeyWord.CALLGSUBR,29),
+ VHCURVETO(Type1KeyWord.VHCURVETO, Type2KeyWord.VHCURVETO,30),
+ HVCURVETO(Type1KeyWord.HVCURVETO, Type2KeyWord.HVCURVETO,31),
+ DOTSECTION(Type1KeyWord.DOTSECTION, null,192),
+ VSTEM3(Type1KeyWord.VSTEM3, null,193),
+ HSTEM3(Type1KeyWord.HSTEM3, null,194),
+ AND(null, Type2KeyWord.AND,195),
+ OR(null, Type2KeyWord.OR,196),
+ NOT(null, Type2KeyWord.NOT,197),
+ SEAC(Type1KeyWord.SEAC, null,198),
+ SBW(Type1KeyWord.SBW, null,199),
+ ABS(null, Type2KeyWord.ABS,201),
+ ADD(null, Type2KeyWord.ADD,202),
+ SUB(null, Type2KeyWord.SUB,203),
+ DIV(Type1KeyWord.DIV, Type2KeyWord.DIV,204),
+ NEG(null, Type2KeyWord.NEG,206),
+ EQ(null, Type2KeyWord.EQ,207),
+ CALLOTHERSUBR(Type1KeyWord.CALLOTHERSUBR, null,208),
+ POP(Type1KeyWord.POP, null,209),
+ DROP(null, Type2KeyWord.DROP,210),
+ PUT(null, Type2KeyWord.PUT,212),
+ GET(null, Type2KeyWord.GET,213),
+ IFELSE(null, Type2KeyWord.IFELSE,214),
+ RANDOM(null, Type2KeyWord.RANDOM,215),
+ MUL(null, Type2KeyWord.MUL,216),
+ SQRT(null, Type2KeyWord.SQRT,218),
+ DUP(null, Type2KeyWord.DUP,219),
+ EXCH(null, Type2KeyWord.EXCH,220),
+ INDEX(null, Type2KeyWord.INDEX,221),
+ ROLL(null, Type2KeyWord.ROLL,222),
+ SETCURRENTPOINT(Type1KeyWord.SETCURRENTPOINT, null,225),
+ HFLEX(null, Type2KeyWord.HFLEX,226),
+ FLEX(null, Type2KeyWord.FLEX,227),
+ HFLEX1(null, Type2KeyWord.HFLEX1,228),
+ FLEX1(null, Type2KeyWord.FLEX1,229),
+ UNKNOWN(null, null, 99);
+
+ private static final CharStringCommand[] COMMANDS_BY_VALUE;
+
+ static
+ {
+ int max =
Arrays.stream(CharStringCommand.values()).mapToInt(CharStringCommand::getValue)
+ .max().orElseThrow();
+ COMMANDS_BY_VALUE = new CharStringCommand[max + 1];
+ Arrays.stream(CharStringCommand.values()).forEach(c ->
COMMANDS_BY_VALUE[c.getValue()] = c);
+ }
+
private final Type1KeyWord type1KeyWord;
private final Type2KeyWord type2KeyWord;
+ private final int value;
+ private final String stringValue;
- private static final Map<Integer, CharStringCommand> CHAR_STRING_COMMANDS
= createMap();
-
- public static final CharStringCommand COMMAND_CLOSEPATH = CharStringCommand
- .getInstance(Key.CLOSEPATH.hashValue);
- public static final CharStringCommand COMMAND_RLINETO = CharStringCommand
- .getInstance(Key.RLINETO.hashValue);
- public static final CharStringCommand COMMAND_HLINETO = CharStringCommand
- .getInstance(Key.HLINETO.hashValue);
- public static final CharStringCommand COMMAND_VLINETO = CharStringCommand
- .getInstance(Key.VLINETO.hashValue);
- public static final CharStringCommand COMMAND_RRCURVETO = CharStringCommand
- .getInstance(Key.RRCURVETO.hashValue);
- public static final CharStringCommand COMMAND_HSBW = CharStringCommand
- .getInstance(Key.HSBW.hashValue);
- public static final CharStringCommand COMMAND_CALLOTHERSUBR =
CharStringCommand
- .getInstance(Key.CALLOTHERSUBR.hashValue);
-
- private static final int KEY_UNKNOWN = 99;
- private static final CharStringCommand COMMAND_UNKNOWN = new
CharStringCommand(KEY_UNKNOWN, 0);
-
- private static Map<Integer, CharStringCommand> createMap()
- {
- Map<Integer, CharStringCommand> charStringCommandMap = new HashMap<>();
- // one byte commands
- charStringCommandMap.put(Key.HSTEM.hashValue, new
CharStringCommand(Key.HSTEM));
- charStringCommandMap.put(Key.VSTEM.hashValue, new
CharStringCommand(Key.VSTEM));
- charStringCommandMap.put(Key.VMOVETO.hashValue, new
CharStringCommand(Key.VMOVETO));
- charStringCommandMap.put(Key.RLINETO.hashValue, new
CharStringCommand(Key.RLINETO));
- charStringCommandMap.put(Key.HLINETO.hashValue, new
CharStringCommand(Key.HLINETO));
- charStringCommandMap.put(Key.VLINETO.hashValue, new
CharStringCommand(Key.VLINETO));
- charStringCommandMap.put(Key.RRCURVETO.hashValue, new
CharStringCommand(Key.RRCURVETO));
- charStringCommandMap.put(Key.CLOSEPATH.hashValue, new
CharStringCommand(Key.CLOSEPATH));
- charStringCommandMap.put(Key.CALLSUBR.hashValue, new
CharStringCommand(Key.CALLSUBR));
- charStringCommandMap.put(Key.RET.hashValue, new
CharStringCommand(Key.RET));
- charStringCommandMap.put(Key.ESCAPE.hashValue, new
CharStringCommand(Key.ESCAPE));
-
- charStringCommandMap.put(Key.HSBW.hashValue, new
CharStringCommand(Key.HSBW));
- charStringCommandMap.put(Key.ENDCHAR.hashValue, new
CharStringCommand(Key.ENDCHAR));
- charStringCommandMap.put(Key.HSTEMHM.hashValue, new
CharStringCommand(Key.HSTEMHM));
- charStringCommandMap.put(Key.HINTMASK.hashValue, new
CharStringCommand(Key.HINTMASK));
- charStringCommandMap.put(Key.CNTRMASK.hashValue, new
CharStringCommand(Key.CNTRMASK));
- charStringCommandMap.put(Key.RMOVETO.hashValue, new
CharStringCommand(Key.RMOVETO));
- charStringCommandMap.put(Key.HMOVETO.hashValue, new
CharStringCommand(Key.HMOVETO));
- charStringCommandMap.put(Key.VSTEMHM.hashValue, new
CharStringCommand(Key.VSTEMHM));
- charStringCommandMap.put(Key.RCURVELINE.hashValue, new
CharStringCommand(Key.RCURVELINE));
- charStringCommandMap.put(Key.RLINECURVE.hashValue, new
CharStringCommand(Key.RLINECURVE));
- charStringCommandMap.put(Key.VVCURVETO.hashValue, new
CharStringCommand(Key.VVCURVETO));
- charStringCommandMap.put(Key.HHCURVETO.hashValue, new
CharStringCommand(Key.HHCURVETO));
- charStringCommandMap.put(Key.SHORTINT.hashValue, new
CharStringCommand(Key.SHORTINT));
- charStringCommandMap.put(Key.CALLGSUBR.hashValue, new
CharStringCommand(Key.CALLGSUBR));
- charStringCommandMap.put(Key.VHCURVETO.hashValue, new
CharStringCommand(Key.VHCURVETO));
- charStringCommandMap.put(Key.HVCURVETO.hashValue, new
CharStringCommand(Key.HVCURVETO));
-
- // two byte commands
- charStringCommandMap.put(Key.DOTSECTION.hashValue, new
CharStringCommand(12, 0));
- charStringCommandMap.put(Key.VSTEM3.hashValue, new
CharStringCommand(12, 1));
- charStringCommandMap.put(Key.HSTEM3.hashValue, new
CharStringCommand(12, 2));
- charStringCommandMap.put(Key.AND.hashValue, new CharStringCommand(12,
3));
- charStringCommandMap.put(Key.OR.hashValue, new CharStringCommand(12,
4));
- charStringCommandMap.put(Key.NOT.hashValue, new CharStringCommand(12,
5));
- charStringCommandMap.put(Key.SEAC.hashValue, new CharStringCommand(12,
6));
- charStringCommandMap.put(Key.SBW.hashValue, new CharStringCommand(12,
7));
- charStringCommandMap.put(Key.ABS.hashValue, new CharStringCommand(12,
9));
- charStringCommandMap.put(Key.ADD.hashValue, new CharStringCommand(12,
10));
- charStringCommandMap.put(Key.SUB.hashValue, new CharStringCommand(12,
11));
- charStringCommandMap.put(Key.DIV.hashValue, new CharStringCommand(12,
12));
- charStringCommandMap.put(Key.NEG.hashValue, new CharStringCommand(12,
14));
- charStringCommandMap.put(Key.EQ.hashValue, new CharStringCommand(12,
15));
- charStringCommandMap.put(Key.CALLOTHERSUBR.hashValue, new
CharStringCommand(12, 16));
- charStringCommandMap.put(Key.POP.hashValue, new CharStringCommand(12,
17));
- charStringCommandMap.put(Key.DROP.hashValue, new CharStringCommand(12,
18));
- charStringCommandMap.put(Key.PUT.hashValue, new CharStringCommand(12,
20));
- charStringCommandMap.put(Key.GET.hashValue, new CharStringCommand(12,
21));
- charStringCommandMap.put(Key.IFELSE.hashValue, new
CharStringCommand(12, 22));
- charStringCommandMap.put(Key.RANDOM.hashValue, new
CharStringCommand(12, 23));
- charStringCommandMap.put(Key.MUL.hashValue, new CharStringCommand(12,
24));
- charStringCommandMap.put(Key.SQRT.hashValue, new CharStringCommand(12,
26));
- charStringCommandMap.put(Key.DUP.hashValue, new CharStringCommand(12,
27));
- charStringCommandMap.put(Key.EXCH.hashValue, new CharStringCommand(12,
28));
- charStringCommandMap.put(Key.INDEX.hashValue, new
CharStringCommand(12, 29));
- charStringCommandMap.put(Key.ROLL.hashValue, new CharStringCommand(12,
30));
- charStringCommandMap.put(Key.SETCURRENTPOINT.hashValue, new
CharStringCommand(12, 33));
- charStringCommandMap.put(Key.HFLEX.hashValue, new
CharStringCommand(12, 34));
- charStringCommandMap.put(Key.FLEX.hashValue, new CharStringCommand(12,
35));
- charStringCommandMap.put(Key.HFLEX1.hashValue, new
CharStringCommand(12, 36));
- charStringCommandMap.put(Key.FLEX1.hashValue, new
CharStringCommand(12, 37));
- return charStringCommandMap;
- }
-
- /**
- * Constructor with the CharStringCommand key as value.
- *
- * @param key the key of the char string command
- */
- private CharStringCommand(CharStringCommand.Key key)
+ CharStringCommand(Type1KeyWord type1KeyWord, Type2KeyWord type2KeyWord,
int value)
{
- type1KeyWord = Type1KeyWord.valueOfKey(key.hashValue);
- type2KeyWord = Type2KeyWord.valueOfKey(key.hashValue);
+ this.type1KeyWord = type1KeyWord;
+ this.type2KeyWord = type2KeyWord;
+ this.value = value;
+ this.stringValue = value == 99 ? "unknown command|" : name() + "|";
}
- /**
- * Constructor with two values.
- *
- * @param b0 value1
- * @param b1 value2
- */
- private CharStringCommand(int b0, int b1)
+ public int getValue()
{
- type1KeyWord = Type1KeyWord.valueOfKey(b0, b1);
- type2KeyWord = Type2KeyWord.valueOfKey(b0, b1);
+ return value;
}
-
/**
* Get an instance of the CharStringCommand represented by the given value.
- *
+ *
* @param b0 value
* @return CharStringCommand represented by the given value
*/
public static CharStringCommand getInstance(int b0)
{
- CharStringCommand command = CHAR_STRING_COMMANDS.get(b0);
- return command != null ? command : COMMAND_UNKNOWN;
+ CharStringCommand c = null;
+ if (b0 >= 0 && b0 < COMMANDS_BY_VALUE.length)
+ {
+ c = COMMANDS_BY_VALUE[b0];
+ }
+ return c != null ? c : UNKNOWN;
}
/**
* Get an instance of the CharStringCommand represented by the given two
values.
- *
+ *
* @param b0 value1
* @param b1 value2
- *
+ *
* @return CharStringCommand represented by the given two values
*/
public static CharStringCommand getInstance(int b0, int b1)
{
- CharStringCommand command =
CHAR_STRING_COMMANDS.get(getKeyHashValue(b0, b1));
- return command != null ? command : COMMAND_UNKNOWN;
+ return getInstance((b0 << 4) + b1);
}
/**
* Get an instance of the CharStringCommand represented by the given array.
- *
+ *
* @param values array of values
- *
+ *
* @return CharStringCommand represented by the given values
*/
public static CharStringCommand getInstance(int[] values)
{
- if (values.length == 1)
+ switch (values.length)
{
+ case 1:
return getInstance(values[0]);
- }
- else if (values.length == 2)
- {
+ case 2:
return getInstance(values[0], values[1]);
+ default:
+ return UNKNOWN;
}
- return COMMAND_UNKNOWN;
- }
-
- private static int getKeyHashValue(int b0, int b1)
- {
- Type1KeyWord type1Key = Type1KeyWord.valueOfKey(b0, b1);
- if (type1Key != null)
- {
- return type1Key.key.hashValue;
- }
- Type2KeyWord type2Key = Type2KeyWord.valueOfKey(b0, b1);
- if (type2Key != null)
- {
- return type2Key.key.hashValue;
- }
- return KEY_UNKNOWN;
}
/**
@@ -225,50 +183,10 @@ public class CharStringCommand
return type2KeyWord;
}
- /**
- * {@inheritDoc}
- */
@Override
public String toString()
{
- String str;
- if (type2KeyWord != null)
- {
- str = type2KeyWord.toString();
- }
- else if (type1KeyWord != null)
- {
- str = type1KeyWord.toString();
- }
- else
- {
- str = "unknown command";
- }
- return str + '|';
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public int hashCode()
- {
- return Objects.hash(type1KeyWord, type2KeyWord);
- }
-
- /**
- * {@inheritDoc}
- */
- @Override
- public boolean equals(Object object)
- {
- if (object == null || object.getClass() != this.getClass())
- {
- return false;
- }
-
- CharStringCommand that = (CharStringCommand) object;
- return that.type1KeyWord == type1KeyWord && that.type2KeyWord ==
type2KeyWord;
+ return stringValue;
}
/**
@@ -276,48 +194,32 @@ public class CharStringCommand
*/
public enum Type1KeyWord
{
- HSTEM(Key.HSTEM), VSTEM(Key.VSTEM), VMOVETO(Key.VMOVETO),
RLINETO(Key.RLINETO), //
- HLINETO(Key.HLINETO), VLINETO(Key.VLINETO), RRCURVETO(Key.RRCURVETO),
//
- CLOSEPATH(Key.CLOSEPATH), CALLSUBR(Key.CALLSUBR), RET(Key.RET), //
- ESCAPE(Key.ESCAPE), DOTSECTION(Key.DOTSECTION), //
- VSTEM3(Key.VSTEM3), HSTEM3(Key.HSTEM3), SEAC(Key.SEAC), SBW(Key.SBW),
//
- DIV(Key.DIV), CALLOTHERSUBR(Key.CALLOTHERSUBR), POP(Key.POP), //
- SETCURRENTPOINT(Key.SETCURRENTPOINT), HSBW(Key.HSBW),
ENDCHAR(Key.ENDCHAR), //
- RMOVETO(Key.RMOVETO), HMOVETO(Key.HMOVETO), VHCURVETO(Key.VHCURVETO),
//
- HVCURVETO(Key.HVCURVETO);
-
- final Key key;
-
- private Type1KeyWord(Key key)
- {
- this.key = key;
- }
-
- private static final Map<Key, Type1KeyWord> BY_KEY = new
EnumMap<>(Key.class);
-
- static
- {
- for (Type1KeyWord e : values())
- {
- BY_KEY.put(e.key, e);
- }
- }
-
- public static Type1KeyWord valueOfKey(int b0)
- {
- return BY_KEY.get(Key.valueOfKey(b0));
- }
-
- public static Type1KeyWord valueOfKey(int b0, int b1)
- {
- return BY_KEY.get(Key.valueOfKey(b0, b1));
- }
-
- public static Type1KeyWord valueOfKey(Key key)
- {
- return BY_KEY.get(key);
- }
-
+ HSTEM,
+ VSTEM,
+ VMOVETO,
+ RLINETO,
+ HLINETO,
+ VLINETO,
+ RRCURVETO,
+ CLOSEPATH,
+ CALLSUBR,
+ RET,
+ ESCAPE,
+ HSBW,
+ ENDCHAR,
+ RMOVETO,
+ HMOVETO,
+ VHCURVETO,
+ HVCURVETO,
+ DOTSECTION,
+ VSTEM3,
+ HSTEM3,
+ SEAC,
+ SBW,
+ DIV,
+ CALLOTHERSUBR,
+ POP,
+ SETCURRENTPOINT;
}
/**
@@ -325,102 +227,54 @@ public class CharStringCommand
*/
public enum Type2KeyWord
{
- HSTEM(Key.HSTEM), VSTEM(Key.VSTEM), VMOVETO(Key.VMOVETO),
RLINETO(Key.RLINETO), //
- HLINETO(Key.HLINETO), VLINETO(Key.VLINETO), RRCURVETO(Key.RRCURVETO),
CALLSUBR(Key.CALLSUBR), //
- RET(Key.RET), ESCAPE(Key.ESCAPE), AND(Key.AND), OR(Key.OR), //
- NOT(Key.NOT), ABS(Key.ABS), ADD(Key.ADD), SUB(Key.SUB), //
- DIV(Key.DIV), NEG(Key.NEG), EQ(Key.EQ), DROP(Key.DROP), //
- PUT(Key.PUT), GET(Key.GET), IFELSE(Key.IFELSE), //
- RANDOM(Key.RANDOM), MUL(Key.MUL), SQRT(Key.SQRT), DUP(Key.DUP), //
- EXCH(Key.EXCH), INDEX(Key.INDEX), ROLL(Key.ROLL), //
- HFLEX(Key.HFLEX), FLEX(Key.FLEX), HFLEX1(Key.HFLEX1), //
- FLEX1(Key.FLEX1), ENDCHAR(Key.ENDCHAR), HSTEMHM(Key.HSTEMHM),
HINTMASK(Key.HINTMASK), //
- CNTRMASK(Key.CNTRMASK), RMOVETO(Key.RMOVETO), HMOVETO(Key.HMOVETO),
VSTEMHM(Key.VSTEMHM), //
- RCURVELINE(Key.RCURVELINE), RLINECURVE(Key.RLINECURVE),
VVCURVETO(Key.VVCURVETO), //
- HHCURVETO(Key.HHCURVETO), SHORTINT(Key.SHORTINT),
CALLGSUBR(Key.CALLGSUBR), //
- VHCURVETO(Key.VHCURVETO), HVCURVETO(Key.HVCURVETO);
-
- final Key key;
-
- private Type2KeyWord(Key key)
- {
- this.key = key;
- }
-
- private static final Map<Key, Type2KeyWord> BY_KEY = new
EnumMap<>(Key.class);
-
- static
- {
- for (Type2KeyWord e : values())
- {
- BY_KEY.put(e.key, e);
- }
- }
-
- public static Type2KeyWord valueOfKey(int b0)
- {
- return BY_KEY.get(Key.valueOfKey(b0));
- }
-
- public static Type2KeyWord valueOfKey(int b0, int b1)
- {
- return BY_KEY.get(Key.valueOfKey(b0, b1));
- }
-
- public static Type2KeyWord valueOfKey(Key key)
- {
- return BY_KEY.get(key);
- }
- }
-
- public enum Key
- {
- HSTEM(1), VSTEM(3), VMOVETO(4), RLINETO(5), //
- HLINETO(6), VLINETO(7), RRCURVETO(8), CLOSEPATH(9), CALLSUBR(10), //
- RET(11), ESCAPE(12), DOTSECTION(12, 0), VSTEM3(12, 1), HSTEM3(12, 2),
//
- AND(12, 3), OR(12, 4), NOT(12, 5), SEAC(12, 6), SBW(12, 7), //
- ABS(12, 9), ADD(12, 10), SUB(12, 11), DIV(12, 12), NEG(12, 14), EQ(12,
15), //
- CALLOTHERSUBR(12, 16), POP(12, 17), DROP(12, 18), //
- PUT(12, 20), GET(12, 21), IFELSE(12, 22), //
- RANDOM(12, 23), MUL(12, 24), SQRT(12, 26), DUP(12, 27), //
- EXCH(12, 28), INDEX(12, 29), ROLL(12, 30), SETCURRENTPOINT(12, 33), //
- HFLEX(12, 34), FLEX(12, 35), HFLEX1(12, 36), FLEX1(12, 37), //
- HSBW(13), ENDCHAR(14), HSTEMHM(18), HINTMASK(19), //
- CNTRMASK(20), RMOVETO(21), HMOVETO(22), VSTEMHM(23), //
- RCURVELINE(24), RLINECURVE(25), VVCURVETO(26), //
- HHCURVETO(27), SHORTINT(28), CALLGSUBR(29), //
- VHCURVETO(30), HVCURVETO(31);
-
- private final int hashValue;
-
- private Key(int b0)
- {
- hashValue = b0;
- }
-
- private Key(int b0, int b1)
- {
- hashValue = (b0 << 4) + b1;
- }
-
- private static final Map<Integer, Key> BY_KEY = new HashMap<>();
-
- static
- {
- for (Key e : values())
- {
- BY_KEY.put(e.hashValue, e);
- }
- }
-
- public static Key valueOfKey(int b0)
- {
- return BY_KEY.get(b0);
- }
-
- public static Key valueOfKey(int b0, int b1)
- {
- return BY_KEY.get((b0 << 4) + b1);
- }
+ HSTEM,
+ VSTEM,
+ VMOVETO,
+ RLINETO,
+ HLINETO,
+ VLINETO,
+ RRCURVETO,
+ CALLSUBR,
+ RET,
+ ESCAPE,
+ ENDCHAR,
+ HSTEMHM,
+ HINTMASK,
+ CNTRMASK,
+ RMOVETO,
+ HMOVETO,
+ VSTEMHM,
+ RCURVELINE,
+ RLINECURVE,
+ VVCURVETO,
+ HHCURVETO,
+ SHORTINT,
+ CALLGSUBR,
+ VHCURVETO,
+ HVCURVETO,
+ AND,
+ OR,
+ NOT,
+ ABS,
+ ADD,
+ SUB,
+ DIV,
+ NEG,
+ EQ,
+ DROP,
+ PUT,
+ GET,
+ IFELSE,
+ RANDOM,
+ MUL,
+ SQRT,
+ DUP,
+ EXCH,
+ INDEX,
+ ROLL,
+ HFLEX,
+ FLEX,
+ HFLEX1,
+ FLEX1;
}
}
Modified:
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/Type1CharStringParser.java
URL:
http://svn.apache.org/viewvc/pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/Type1CharStringParser.java?rev=1916209&r1=1916208&r2=1916209&view=diff
==============================================================================
---
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/Type1CharStringParser.java
(original)
+++
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/Type1CharStringParser.java
Sun Mar 10 10:41:32 2024
@@ -160,12 +160,12 @@ public class Type1CharStringParser
sequence.remove(sequence.size() - 1);
// end flex
sequence.add(0);
- sequence.add(CharStringCommand.COMMAND_CALLOTHERSUBR);
+ sequence.add(CharStringCommand.CALLOTHERSUBR);
break;
case 1:
// begin flex
sequence.add(1);
- sequence.add(CharStringCommand.COMMAND_CALLOTHERSUBR);
+ sequence.add(CharStringCommand.CALLOTHERSUBR);
break;
case 3:
// allows hint replacement
Modified:
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/Type2CharString.java
URL:
http://svn.apache.org/viewvc/pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/Type2CharString.java?rev=1916209&r1=1916208&r2=1916209&view=diff
==============================================================================
---
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/Type2CharString.java
(original)
+++
pdfbox/trunk/fontbox/src/main/java/org/apache/fontbox/cff/Type2CharString.java
Sun Mar 10 10:41:32 2024
@@ -156,14 +156,14 @@ public class Type2CharString extends Typ
numbers.get(3), 0);
List<Number> second = Arrays.asList(numbers.get(4), 0,
numbers.get(5),
-(numbers.get(2).floatValue()), numbers.get(6), 0);
- addCommandList(Arrays.asList(first, second),
CharStringCommand.COMMAND_RRCURVETO);
+ addCommandList(Arrays.asList(first, second),
CharStringCommand.RRCURVETO);
}
break;
case FLEX:
{
List<Number> first = numbers.subList(0, 6);
List<Number> second = numbers.subList(6, 12);
- addCommandList(Arrays.asList(first, second),
CharStringCommand.COMMAND_RRCURVETO);
+ addCommandList(Arrays.asList(first, second),
CharStringCommand.RRCURVETO);
break;
}
case HFLEX1:
@@ -173,7 +173,7 @@ public class Type2CharString extends Typ
numbers.get(3), numbers.get(4), 0);
List<Number> second = Arrays.asList(numbers.get(5), 0,
numbers.get(6), numbers.get(7),
numbers.get(8), 0);
- addCommandList(Arrays.asList(first, second),
CharStringCommand.COMMAND_RRCURVETO);
+ addCommandList(Arrays.asList(first, second),
CharStringCommand.RRCURVETO);
}
break;
case FLEX1:
@@ -195,25 +195,25 @@ public class Type2CharString extends Typ
(dxIsBigger ? numbers.get(10) : -dx),
(dxIsBigger ? -dy : numbers.get(10)));
addCommandList(Arrays.asList(first, second),
- CharStringCommand.COMMAND_RRCURVETO);
+ CharStringCommand.RRCURVETO);
break;
}
case RCURVELINE:
if (numbers.size() >= 2)
{
addCommandList(split(numbers.subList(0, numbers.size() - 2),
6),
- CharStringCommand.COMMAND_RRCURVETO);
+ CharStringCommand.RRCURVETO);
addCommand(numbers.subList(numbers.size() - 2, numbers.size()),
- CharStringCommand.COMMAND_RLINETO);
+ CharStringCommand.RLINETO);
}
break;
case RLINECURVE:
if (numbers.size() >= 6)
{
addCommandList(split(numbers.subList(0, numbers.size() - 6),
2),
- CharStringCommand.COMMAND_RLINETO);
+ CharStringCommand.RLINETO);
addCommand(numbers.subList(numbers.size() - 6, numbers.size()),
- CharStringCommand.COMMAND_RRCURVETO);
+ CharStringCommand.RRCURVETO);
}
break;
case HHCURVETO:
@@ -234,12 +234,12 @@ public class Type2CharString extends Typ
if (flag)
{
addCommand(Arrays.asList(0, numbers.get(0).floatValue() +
nominalWidthX),
- CharStringCommand.COMMAND_HSBW);
+ CharStringCommand.HSBW);
numbers = numbers.subList(1, numbers.size());
}
else
{
- addCommand(Arrays.asList(0, defWidthX),
CharStringCommand.COMMAND_HSBW);
+ addCommand(Arrays.asList(0, defWidthX),
CharStringCommand.HSBW);
}
}
return numbers;
@@ -269,7 +269,7 @@ public class Type2CharString extends Typ
: null;
if (command != null && command.getType1KeyWord() !=
Type1KeyWord.CLOSEPATH)
{
- addCommand(Collections.emptyList(),
CharStringCommand.COMMAND_CLOSEPATH);
+ addCommand(Collections.emptyList(), CharStringCommand.CLOSEPATH);
}
}
@@ -277,8 +277,8 @@ public class Type2CharString extends Typ
{
while (!numbers.isEmpty())
{
- addCommand(numbers.subList(0, 1), horizontal ?
CharStringCommand.COMMAND_HLINETO
- : CharStringCommand.COMMAND_VLINETO);
+ addCommand(numbers.subList(0, 1), horizontal ?
CharStringCommand.HLINETO
+ : CharStringCommand.VLINETO);
numbers = numbers.subList(1, numbers.size());
horizontal = !horizontal;
}
@@ -294,14 +294,14 @@ public class Type2CharString extends Typ
addCommand(Arrays.asList(numbers.get(0), 0,
numbers.get(1), numbers.get(2), last ? numbers.get(4)
: 0, numbers.get(3)),
- CharStringCommand.COMMAND_RRCURVETO);
+ CharStringCommand.RRCURVETO);
}
else
{
addCommand(Arrays.asList(0, numbers.get(0),
numbers.get(1), numbers.get(2), numbers.get(3),
last ? numbers.get(4) : 0),
- CharStringCommand.COMMAND_RRCURVETO);
+ CharStringCommand.RRCURVETO);
}
numbers = numbers.subList(last ? 5 : 4, numbers.size());
horizontal = !horizontal;
@@ -320,14 +320,14 @@ public class Type2CharString extends Typ
first ? numbers.get(0) : 0, numbers
.get(first ? 2 : 1),
numbers.get(first ? 3 : 2), numbers.get(first ? 4 : 3),
- 0), CharStringCommand.COMMAND_RRCURVETO);
+ 0), CharStringCommand.RRCURVETO);
}
else
{
addCommand(Arrays.asList(first ? numbers.get(0) : 0,
numbers.get(first ? 1 : 0), numbers
.get(first ? 2 : 1), numbers.get(first ? 3 : 2),
0, numbers.get(first ? 4 : 3)),
- CharStringCommand.COMMAND_RRCURVETO);
+ CharStringCommand.RRCURVETO);
}
numbers = numbers.subList(first ? 5 : 4, numbers.size());
}
Modified:
pdfbox/trunk/fontbox/src/test/java/org/apache/fontbox/cff/CharStringCommandTest.java
URL:
http://svn.apache.org/viewvc/pdfbox/trunk/fontbox/src/test/java/org/apache/fontbox/cff/CharStringCommandTest.java?rev=1916209&r1=1916208&r2=1916209&view=diff
==============================================================================
---
pdfbox/trunk/fontbox/src/test/java/org/apache/fontbox/cff/CharStringCommandTest.java
(original)
+++
pdfbox/trunk/fontbox/src/test/java/org/apache/fontbox/cff/CharStringCommandTest.java
Sun Mar 10 10:41:32 2024
@@ -20,7 +20,6 @@ package org.apache.fontbox.cff;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
-import org.apache.fontbox.cff.CharStringCommand.Key;
import org.apache.fontbox.cff.CharStringCommand.Type1KeyWord;
import org.apache.fontbox.cff.CharStringCommand.Type2KeyWord;
import org.junit.jupiter.api.Test;
@@ -29,13 +28,13 @@ class CharStringCommandTest
{
@Test
- void testKey()
+ void testValue()
{
- assertEquals(Key.HSTEM, Key.valueOfKey(1));
- assertEquals(Key.ESCAPE, Key.valueOfKey(12));
- assertEquals(Key.DOTSECTION, Key.valueOfKey(12, 0));
- assertEquals(Key.AND, Key.valueOfKey(12, 3));
- assertEquals(Key.HSBW, Key.valueOfKey(13));
+ assertEquals(CharStringCommand.HSTEM.getValue(), 1);
+ assertEquals(CharStringCommand.ESCAPE.getValue(), 12);
+ assertEquals(CharStringCommand.DOTSECTION.getValue(), (12 << 4) + 0);
+ assertEquals(CharStringCommand.AND.getValue(), (12 << 4) + 3);
+ assertEquals(CharStringCommand.HSBW.getValue(), 13);
}
@Test
