Spaces:
Running
Running
| """psCharStrings.py -- module implementing various kinds of CharStrings: | |
| CFF dictionary data and Type1/Type2 CharStrings. | |
| """ | |
| from fontTools.misc.fixedTools import ( | |
| fixedToFloat, | |
| floatToFixed, | |
| floatToFixedToStr, | |
| strToFixedToFloat, | |
| ) | |
| from fontTools.misc.textTools import bytechr, byteord, bytesjoin, strjoin | |
| from fontTools.pens.boundsPen import BoundsPen | |
| import struct | |
| import logging | |
| log = logging.getLogger(__name__) | |
| def read_operator(self, b0, data, index): | |
| if b0 == 12: | |
| op = (b0, byteord(data[index])) | |
| index = index + 1 | |
| else: | |
| op = b0 | |
| try: | |
| operator = self.operators[op] | |
| except KeyError: | |
| return None, index | |
| value = self.handle_operator(operator) | |
| return value, index | |
| def read_byte(self, b0, data, index): | |
| return b0 - 139, index | |
| def read_smallInt1(self, b0, data, index): | |
| b1 = byteord(data[index]) | |
| return (b0 - 247) * 256 + b1 + 108, index + 1 | |
| def read_smallInt2(self, b0, data, index): | |
| b1 = byteord(data[index]) | |
| return -(b0 - 251) * 256 - b1 - 108, index + 1 | |
| def read_shortInt(self, b0, data, index): | |
| (value,) = struct.unpack(">h", data[index : index + 2]) | |
| return value, index + 2 | |
| def read_longInt(self, b0, data, index): | |
| (value,) = struct.unpack(">l", data[index : index + 4]) | |
| return value, index + 4 | |
| def read_fixed1616(self, b0, data, index): | |
| (value,) = struct.unpack(">l", data[index : index + 4]) | |
| return fixedToFloat(value, precisionBits=16), index + 4 | |
| def read_reserved(self, b0, data, index): | |
| assert NotImplementedError | |
| return NotImplemented, index | |
| def read_realNumber(self, b0, data, index): | |
| number = "" | |
| while True: | |
| b = byteord(data[index]) | |
| index = index + 1 | |
| nibble0 = (b & 0xF0) >> 4 | |
| nibble1 = b & 0x0F | |
| if nibble0 == 0xF: | |
| break | |
| number = number + realNibbles[nibble0] | |
| if nibble1 == 0xF: | |
| break | |
| number = number + realNibbles[nibble1] | |
| return float(number), index | |
| t1OperandEncoding = [None] * 256 | |
| t1OperandEncoding[0:32] = (32) * [read_operator] | |
| t1OperandEncoding[32:247] = (247 - 32) * [read_byte] | |
| t1OperandEncoding[247:251] = (251 - 247) * [read_smallInt1] | |
| t1OperandEncoding[251:255] = (255 - 251) * [read_smallInt2] | |
| t1OperandEncoding[255] = read_longInt | |
| assert len(t1OperandEncoding) == 256 | |
| t2OperandEncoding = t1OperandEncoding[:] | |
| t2OperandEncoding[28] = read_shortInt | |
| t2OperandEncoding[255] = read_fixed1616 | |
| cffDictOperandEncoding = t2OperandEncoding[:] | |
| cffDictOperandEncoding[29] = read_longInt | |
| cffDictOperandEncoding[30] = read_realNumber | |
| cffDictOperandEncoding[255] = read_reserved | |
| realNibbles = [ | |
| "0", | |
| "1", | |
| "2", | |
| "3", | |
| "4", | |
| "5", | |
| "6", | |
| "7", | |
| "8", | |
| "9", | |
| ".", | |
| "E", | |
| "E-", | |
| None, | |
| "-", | |
| ] | |
| realNibblesDict = {v: i for i, v in enumerate(realNibbles)} | |
| maxOpStack = 193 | |
| def buildOperatorDict(operatorList): | |
| oper = {} | |
| opc = {} | |
| for item in operatorList: | |
| if len(item) == 2: | |
| oper[item[0]] = item[1] | |
| else: | |
| oper[item[0]] = item[1:] | |
| if isinstance(item[0], tuple): | |
| opc[item[1]] = item[0] | |
| else: | |
| opc[item[1]] = (item[0],) | |
| return oper, opc | |
| t2Operators = [ | |
| # opcode name | |
| (1, "hstem"), | |
| (3, "vstem"), | |
| (4, "vmoveto"), | |
| (5, "rlineto"), | |
| (6, "hlineto"), | |
| (7, "vlineto"), | |
| (8, "rrcurveto"), | |
| (10, "callsubr"), | |
| (11, "return"), | |
| (14, "endchar"), | |
| (15, "vsindex"), | |
| (16, "blend"), | |
| (18, "hstemhm"), | |
| (19, "hintmask"), | |
| (20, "cntrmask"), | |
| (21, "rmoveto"), | |
| (22, "hmoveto"), | |
| (23, "vstemhm"), | |
| (24, "rcurveline"), | |
| (25, "rlinecurve"), | |
| (26, "vvcurveto"), | |
| (27, "hhcurveto"), | |
| # (28, 'shortint'), # not really an operator | |
| (29, "callgsubr"), | |
| (30, "vhcurveto"), | |
| (31, "hvcurveto"), | |
| ((12, 0), "ignore"), # dotsection. Yes, there a few very early OTF/CFF | |
| # fonts with this deprecated operator. Just ignore it. | |
| ((12, 3), "and"), | |
| ((12, 4), "or"), | |
| ((12, 5), "not"), | |
| ((12, 8), "store"), | |
| ((12, 9), "abs"), | |
| ((12, 10), "add"), | |
| ((12, 11), "sub"), | |
| ((12, 12), "div"), | |
| ((12, 13), "load"), | |
| ((12, 14), "neg"), | |
| ((12, 15), "eq"), | |
| ((12, 18), "drop"), | |
| ((12, 20), "put"), | |
| ((12, 21), "get"), | |
| ((12, 22), "ifelse"), | |
| ((12, 23), "random"), | |
| ((12, 24), "mul"), | |
| ((12, 26), "sqrt"), | |
| ((12, 27), "dup"), | |
| ((12, 28), "exch"), | |
| ((12, 29), "index"), | |
| ((12, 30), "roll"), | |
| ((12, 34), "hflex"), | |
| ((12, 35), "flex"), | |
| ((12, 36), "hflex1"), | |
| ((12, 37), "flex1"), | |
| ] | |
| def getIntEncoder(format): | |
| if format == "cff": | |
| twoByteOp = bytechr(28) | |
| fourByteOp = bytechr(29) | |
| elif format == "t1": | |
| twoByteOp = None | |
| fourByteOp = bytechr(255) | |
| else: | |
| assert format == "t2" | |
| twoByteOp = bytechr(28) | |
| fourByteOp = None | |
| def encodeInt( | |
| value, | |
| fourByteOp=fourByteOp, | |
| bytechr=bytechr, | |
| pack=struct.pack, | |
| unpack=struct.unpack, | |
| twoByteOp=twoByteOp, | |
| ): | |
| if -107 <= value <= 107: | |
| code = bytechr(value + 139) | |
| elif 108 <= value <= 1131: | |
| value = value - 108 | |
| code = bytechr((value >> 8) + 247) + bytechr(value & 0xFF) | |
| elif -1131 <= value <= -108: | |
| value = -value - 108 | |
| code = bytechr((value >> 8) + 251) + bytechr(value & 0xFF) | |
| elif twoByteOp is not None and -32768 <= value <= 32767: | |
| code = twoByteOp + pack(">h", value) | |
| elif fourByteOp is None: | |
| # Backwards compatible hack: due to a previous bug in FontTools, | |
| # 16.16 fixed numbers were written out as 4-byte ints. When | |
| # these numbers were small, they were wrongly written back as | |
| # small ints instead of 4-byte ints, breaking round-tripping. | |
| # This here workaround doesn't do it any better, since we can't | |
| # distinguish anymore between small ints that were supposed to | |
| # be small fixed numbers and small ints that were just small | |
| # ints. Hence the warning. | |
| log.warning( | |
| "4-byte T2 number got passed to the " | |
| "IntType handler. This should happen only when reading in " | |
| "old XML files.\n" | |
| ) | |
| code = bytechr(255) + pack(">l", value) | |
| else: | |
| code = fourByteOp + pack(">l", value) | |
| return code | |
| return encodeInt | |
| encodeIntCFF = getIntEncoder("cff") | |
| encodeIntT1 = getIntEncoder("t1") | |
| encodeIntT2 = getIntEncoder("t2") | |
| def encodeFixed(f, pack=struct.pack): | |
| """For T2 only""" | |
| value = floatToFixed(f, precisionBits=16) | |
| if value & 0xFFFF == 0: # check if the fractional part is zero | |
| return encodeIntT2(value >> 16) # encode only the integer part | |
| else: | |
| return b"\xff" + pack(">l", value) # encode the entire fixed point value | |
| realZeroBytes = bytechr(30) + bytechr(0xF) | |
| def encodeFloat(f): | |
| # For CFF only, used in cffLib | |
| if f == 0.0: # 0.0 == +0.0 == -0.0 | |
| return realZeroBytes | |
| # Note: 14 decimal digits seems to be the limitation for CFF real numbers | |
| # in macOS. However, we use 8 here to match the implementation of AFDKO. | |
| s = "%.8G" % f | |
| if s[:2] == "0.": | |
| s = s[1:] | |
| elif s[:3] == "-0.": | |
| s = "-" + s[2:] | |
| elif s.endswith("000"): | |
| significantDigits = s.rstrip("0") | |
| s = "%sE%d" % (significantDigits, len(s) - len(significantDigits)) | |
| else: | |
| dotIndex = s.find(".") | |
| eIndex = s.find("E") | |
| if dotIndex != -1 and eIndex != -1: | |
| integerPart = s[:dotIndex] | |
| fractionalPart = s[dotIndex + 1 : eIndex] | |
| exponent = int(s[eIndex + 1 :]) | |
| newExponent = exponent - len(fractionalPart) | |
| if newExponent == 1: | |
| s = "%s%s0" % (integerPart, fractionalPart) | |
| else: | |
| s = "%s%sE%d" % (integerPart, fractionalPart, newExponent) | |
| if s.startswith((".0", "-.0")): | |
| sign, s = s.split(".", 1) | |
| s = "%s%sE-%d" % (sign, s.lstrip("0"), len(s)) | |
| nibbles = [] | |
| while s: | |
| c = s[0] | |
| s = s[1:] | |
| if c == "E": | |
| c2 = s[:1] | |
| if c2 == "-": | |
| s = s[1:] | |
| c = "E-" | |
| elif c2 == "+": | |
| s = s[1:] | |
| if s.startswith("0"): | |
| s = s[1:] | |
| nibbles.append(realNibblesDict[c]) | |
| nibbles.append(0xF) | |
| if len(nibbles) % 2: | |
| nibbles.append(0xF) | |
| d = bytechr(30) | |
| for i in range(0, len(nibbles), 2): | |
| d = d + bytechr(nibbles[i] << 4 | nibbles[i + 1]) | |
| return d | |
| class CharStringCompileError(Exception): | |
| pass | |
| class SimpleT2Decompiler(object): | |
| def __init__(self, localSubrs, globalSubrs, private=None, blender=None): | |
| self.localSubrs = localSubrs | |
| self.localBias = calcSubrBias(localSubrs) | |
| self.globalSubrs = globalSubrs | |
| self.globalBias = calcSubrBias(globalSubrs) | |
| self.private = private | |
| self.blender = blender | |
| self.reset() | |
| def reset(self): | |
| self.callingStack = [] | |
| self.operandStack = [] | |
| self.hintCount = 0 | |
| self.hintMaskBytes = 0 | |
| self.numRegions = 0 | |
| self.vsIndex = 0 | |
| def execute(self, charString): | |
| self.callingStack.append(charString) | |
| needsDecompilation = charString.needsDecompilation() | |
| if needsDecompilation: | |
| program = [] | |
| pushToProgram = program.append | |
| else: | |
| pushToProgram = lambda x: None | |
| pushToStack = self.operandStack.append | |
| index = 0 | |
| while True: | |
| token, isOperator, index = charString.getToken(index) | |
| if token is None: | |
| break # we're done! | |
| pushToProgram(token) | |
| if isOperator: | |
| handlerName = "op_" + token | |
| handler = getattr(self, handlerName, None) | |
| if handler is not None: | |
| rv = handler(index) | |
| if rv: | |
| hintMaskBytes, index = rv | |
| pushToProgram(hintMaskBytes) | |
| else: | |
| self.popall() | |
| else: | |
| pushToStack(token) | |
| if needsDecompilation: | |
| charString.setProgram(program) | |
| del self.callingStack[-1] | |
| def pop(self): | |
| value = self.operandStack[-1] | |
| del self.operandStack[-1] | |
| return value | |
| def popall(self): | |
| stack = self.operandStack[:] | |
| self.operandStack[:] = [] | |
| return stack | |
| def push(self, value): | |
| self.operandStack.append(value) | |
| def op_return(self, index): | |
| if self.operandStack: | |
| pass | |
| def op_endchar(self, index): | |
| pass | |
| def op_ignore(self, index): | |
| pass | |
| def op_callsubr(self, index): | |
| subrIndex = self.pop() | |
| subr = self.localSubrs[subrIndex + self.localBias] | |
| self.execute(subr) | |
| def op_callgsubr(self, index): | |
| subrIndex = self.pop() | |
| subr = self.globalSubrs[subrIndex + self.globalBias] | |
| self.execute(subr) | |
| def op_hstem(self, index): | |
| self.countHints() | |
| def op_vstem(self, index): | |
| self.countHints() | |
| def op_hstemhm(self, index): | |
| self.countHints() | |
| def op_vstemhm(self, index): | |
| self.countHints() | |
| def op_hintmask(self, index): | |
| if not self.hintMaskBytes: | |
| self.countHints() | |
| self.hintMaskBytes = (self.hintCount + 7) // 8 | |
| hintMaskBytes, index = self.callingStack[-1].getBytes(index, self.hintMaskBytes) | |
| return hintMaskBytes, index | |
| op_cntrmask = op_hintmask | |
| def countHints(self): | |
| args = self.popall() | |
| self.hintCount = self.hintCount + len(args) // 2 | |
| # misc | |
| def op_and(self, index): | |
| raise NotImplementedError | |
| def op_or(self, index): | |
| raise NotImplementedError | |
| def op_not(self, index): | |
| raise NotImplementedError | |
| def op_store(self, index): | |
| raise NotImplementedError | |
| def op_abs(self, index): | |
| raise NotImplementedError | |
| def op_add(self, index): | |
| raise NotImplementedError | |
| def op_sub(self, index): | |
| raise NotImplementedError | |
| def op_div(self, index): | |
| raise NotImplementedError | |
| def op_load(self, index): | |
| raise NotImplementedError | |
| def op_neg(self, index): | |
| raise NotImplementedError | |
| def op_eq(self, index): | |
| raise NotImplementedError | |
| def op_drop(self, index): | |
| raise NotImplementedError | |
| def op_put(self, index): | |
| raise NotImplementedError | |
| def op_get(self, index): | |
| raise NotImplementedError | |
| def op_ifelse(self, index): | |
| raise NotImplementedError | |
| def op_random(self, index): | |
| raise NotImplementedError | |
| def op_mul(self, index): | |
| raise NotImplementedError | |
| def op_sqrt(self, index): | |
| raise NotImplementedError | |
| def op_dup(self, index): | |
| raise NotImplementedError | |
| def op_exch(self, index): | |
| raise NotImplementedError | |
| def op_index(self, index): | |
| raise NotImplementedError | |
| def op_roll(self, index): | |
| raise NotImplementedError | |
| def op_blend(self, index): | |
| if self.numRegions == 0: | |
| self.numRegions = self.private.getNumRegions() | |
| numBlends = self.pop() | |
| numOps = numBlends * (self.numRegions + 1) | |
| if self.blender is None: | |
| del self.operandStack[ | |
| -(numOps - numBlends) : | |
| ] # Leave the default operands on the stack. | |
| else: | |
| argi = len(self.operandStack) - numOps | |
| end_args = tuplei = argi + numBlends | |
| while argi < end_args: | |
| next_ti = tuplei + self.numRegions | |
| deltas = self.operandStack[tuplei:next_ti] | |
| delta = self.blender(self.vsIndex, deltas) | |
| self.operandStack[argi] += delta | |
| tuplei = next_ti | |
| argi += 1 | |
| self.operandStack[end_args:] = [] | |
| def op_vsindex(self, index): | |
| vi = self.pop() | |
| self.vsIndex = vi | |
| self.numRegions = self.private.getNumRegions(vi) | |
| t1Operators = [ | |
| # opcode name | |
| (1, "hstem"), | |
| (3, "vstem"), | |
| (4, "vmoveto"), | |
| (5, "rlineto"), | |
| (6, "hlineto"), | |
| (7, "vlineto"), | |
| (8, "rrcurveto"), | |
| (9, "closepath"), | |
| (10, "callsubr"), | |
| (11, "return"), | |
| (13, "hsbw"), | |
| (14, "endchar"), | |
| (21, "rmoveto"), | |
| (22, "hmoveto"), | |
| (30, "vhcurveto"), | |
| (31, "hvcurveto"), | |
| ((12, 0), "dotsection"), | |
| ((12, 1), "vstem3"), | |
| ((12, 2), "hstem3"), | |
| ((12, 6), "seac"), | |
| ((12, 7), "sbw"), | |
| ((12, 12), "div"), | |
| ((12, 16), "callothersubr"), | |
| ((12, 17), "pop"), | |
| ((12, 33), "setcurrentpoint"), | |
| ] | |
| class T2WidthExtractor(SimpleT2Decompiler): | |
| def __init__( | |
| self, | |
| localSubrs, | |
| globalSubrs, | |
| nominalWidthX, | |
| defaultWidthX, | |
| private=None, | |
| blender=None, | |
| ): | |
| SimpleT2Decompiler.__init__(self, localSubrs, globalSubrs, private, blender) | |
| self.nominalWidthX = nominalWidthX | |
| self.defaultWidthX = defaultWidthX | |
| def reset(self): | |
| SimpleT2Decompiler.reset(self) | |
| self.gotWidth = 0 | |
| self.width = 0 | |
| def popallWidth(self, evenOdd=0): | |
| args = self.popall() | |
| if not self.gotWidth: | |
| if evenOdd ^ (len(args) % 2): | |
| # For CFF2 charstrings, this should never happen | |
| assert ( | |
| self.defaultWidthX is not None | |
| ), "CFF2 CharStrings must not have an initial width value" | |
| self.width = self.nominalWidthX + args[0] | |
| args = args[1:] | |
| else: | |
| self.width = self.defaultWidthX | |
| self.gotWidth = 1 | |
| return args | |
| def countHints(self): | |
| args = self.popallWidth() | |
| self.hintCount = self.hintCount + len(args) // 2 | |
| def op_rmoveto(self, index): | |
| self.popallWidth() | |
| def op_hmoveto(self, index): | |
| self.popallWidth(1) | |
| def op_vmoveto(self, index): | |
| self.popallWidth(1) | |
| def op_endchar(self, index): | |
| self.popallWidth() | |
| class T2OutlineExtractor(T2WidthExtractor): | |
| def __init__( | |
| self, | |
| pen, | |
| localSubrs, | |
| globalSubrs, | |
| nominalWidthX, | |
| defaultWidthX, | |
| private=None, | |
| blender=None, | |
| ): | |
| T2WidthExtractor.__init__( | |
| self, | |
| localSubrs, | |
| globalSubrs, | |
| nominalWidthX, | |
| defaultWidthX, | |
| private, | |
| blender, | |
| ) | |
| self.pen = pen | |
| self.subrLevel = 0 | |
| def reset(self): | |
| T2WidthExtractor.reset(self) | |
| self.currentPoint = (0, 0) | |
| self.sawMoveTo = 0 | |
| self.subrLevel = 0 | |
| def execute(self, charString): | |
| self.subrLevel += 1 | |
| super().execute(charString) | |
| self.subrLevel -= 1 | |
| if self.subrLevel == 0: | |
| self.endPath() | |
| def _nextPoint(self, point): | |
| x, y = self.currentPoint | |
| point = x + point[0], y + point[1] | |
| self.currentPoint = point | |
| return point | |
| def rMoveTo(self, point): | |
| self.pen.moveTo(self._nextPoint(point)) | |
| self.sawMoveTo = 1 | |
| def rLineTo(self, point): | |
| if not self.sawMoveTo: | |
| self.rMoveTo((0, 0)) | |
| self.pen.lineTo(self._nextPoint(point)) | |
| def rCurveTo(self, pt1, pt2, pt3): | |
| if not self.sawMoveTo: | |
| self.rMoveTo((0, 0)) | |
| nextPoint = self._nextPoint | |
| self.pen.curveTo(nextPoint(pt1), nextPoint(pt2), nextPoint(pt3)) | |
| def closePath(self): | |
| if self.sawMoveTo: | |
| self.pen.closePath() | |
| self.sawMoveTo = 0 | |
| def endPath(self): | |
| # In T2 there are no open paths, so always do a closePath when | |
| # finishing a sub path. We avoid spurious calls to closePath() | |
| # because its a real T1 op we're emulating in T2 whereas | |
| # endPath() is just a means to that emulation | |
| if self.sawMoveTo: | |
| self.closePath() | |
| # | |
| # hint operators | |
| # | |
| # def op_hstem(self, index): | |
| # self.countHints() | |
| # def op_vstem(self, index): | |
| # self.countHints() | |
| # def op_hstemhm(self, index): | |
| # self.countHints() | |
| # def op_vstemhm(self, index): | |
| # self.countHints() | |
| # def op_hintmask(self, index): | |
| # self.countHints() | |
| # def op_cntrmask(self, index): | |
| # self.countHints() | |
| # | |
| # path constructors, moveto | |
| # | |
| def op_rmoveto(self, index): | |
| self.endPath() | |
| self.rMoveTo(self.popallWidth()) | |
| def op_hmoveto(self, index): | |
| self.endPath() | |
| self.rMoveTo((self.popallWidth(1)[0], 0)) | |
| def op_vmoveto(self, index): | |
| self.endPath() | |
| self.rMoveTo((0, self.popallWidth(1)[0])) | |
| def op_endchar(self, index): | |
| self.endPath() | |
| args = self.popallWidth() | |
| if args: | |
| from fontTools.encodings.StandardEncoding import StandardEncoding | |
| # endchar can do seac accent bulding; The T2 spec says it's deprecated, | |
| # but recent software that shall remain nameless does output it. | |
| adx, ady, bchar, achar = args | |
| baseGlyph = StandardEncoding[bchar] | |
| self.pen.addComponent(baseGlyph, (1, 0, 0, 1, 0, 0)) | |
| accentGlyph = StandardEncoding[achar] | |
| self.pen.addComponent(accentGlyph, (1, 0, 0, 1, adx, ady)) | |
| # | |
| # path constructors, lines | |
| # | |
| def op_rlineto(self, index): | |
| args = self.popall() | |
| for i in range(0, len(args), 2): | |
| point = args[i : i + 2] | |
| self.rLineTo(point) | |
| def op_hlineto(self, index): | |
| self.alternatingLineto(1) | |
| def op_vlineto(self, index): | |
| self.alternatingLineto(0) | |
| # | |
| # path constructors, curves | |
| # | |
| def op_rrcurveto(self, index): | |
| """{dxa dya dxb dyb dxc dyc}+ rrcurveto""" | |
| args = self.popall() | |
| for i in range(0, len(args), 6): | |
| ( | |
| dxa, | |
| dya, | |
| dxb, | |
| dyb, | |
| dxc, | |
| dyc, | |
| ) = args[i : i + 6] | |
| self.rCurveTo((dxa, dya), (dxb, dyb), (dxc, dyc)) | |
| def op_rcurveline(self, index): | |
| """{dxa dya dxb dyb dxc dyc}+ dxd dyd rcurveline""" | |
| args = self.popall() | |
| for i in range(0, len(args) - 2, 6): | |
| dxb, dyb, dxc, dyc, dxd, dyd = args[i : i + 6] | |
| self.rCurveTo((dxb, dyb), (dxc, dyc), (dxd, dyd)) | |
| self.rLineTo(args[-2:]) | |
| def op_rlinecurve(self, index): | |
| """{dxa dya}+ dxb dyb dxc dyc dxd dyd rlinecurve""" | |
| args = self.popall() | |
| lineArgs = args[:-6] | |
| for i in range(0, len(lineArgs), 2): | |
| self.rLineTo(lineArgs[i : i + 2]) | |
| dxb, dyb, dxc, dyc, dxd, dyd = args[-6:] | |
| self.rCurveTo((dxb, dyb), (dxc, dyc), (dxd, dyd)) | |
| def op_vvcurveto(self, index): | |
| "dx1? {dya dxb dyb dyc}+ vvcurveto" | |
| args = self.popall() | |
| if len(args) % 2: | |
| dx1 = args[0] | |
| args = args[1:] | |
| else: | |
| dx1 = 0 | |
| for i in range(0, len(args), 4): | |
| dya, dxb, dyb, dyc = args[i : i + 4] | |
| self.rCurveTo((dx1, dya), (dxb, dyb), (0, dyc)) | |
| dx1 = 0 | |
| def op_hhcurveto(self, index): | |
| """dy1? {dxa dxb dyb dxc}+ hhcurveto""" | |
| args = self.popall() | |
| if len(args) % 2: | |
| dy1 = args[0] | |
| args = args[1:] | |
| else: | |
| dy1 = 0 | |
| for i in range(0, len(args), 4): | |
| dxa, dxb, dyb, dxc = args[i : i + 4] | |
| self.rCurveTo((dxa, dy1), (dxb, dyb), (dxc, 0)) | |
| dy1 = 0 | |
| def op_vhcurveto(self, index): | |
| """dy1 dx2 dy2 dx3 {dxa dxb dyb dyc dyd dxe dye dxf}* dyf? vhcurveto (30) | |
| {dya dxb dyb dxc dxd dxe dye dyf}+ dxf? vhcurveto | |
| """ | |
| args = self.popall() | |
| while args: | |
| args = self.vcurveto(args) | |
| if args: | |
| args = self.hcurveto(args) | |
| def op_hvcurveto(self, index): | |
| """dx1 dx2 dy2 dy3 {dya dxb dyb dxc dxd dxe dye dyf}* dxf? | |
| {dxa dxb dyb dyc dyd dxe dye dxf}+ dyf? | |
| """ | |
| args = self.popall() | |
| while args: | |
| args = self.hcurveto(args) | |
| if args: | |
| args = self.vcurveto(args) | |
| # | |
| # path constructors, flex | |
| # | |
| def op_hflex(self, index): | |
| dx1, dx2, dy2, dx3, dx4, dx5, dx6 = self.popall() | |
| dy1 = dy3 = dy4 = dy6 = 0 | |
| dy5 = -dy2 | |
| self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3)) | |
| self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6)) | |
| def op_flex(self, index): | |
| dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4, dx5, dy5, dx6, dy6, fd = self.popall() | |
| self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3)) | |
| self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6)) | |
| def op_hflex1(self, index): | |
| dx1, dy1, dx2, dy2, dx3, dx4, dx5, dy5, dx6 = self.popall() | |
| dy3 = dy4 = 0 | |
| dy6 = -(dy1 + dy2 + dy3 + dy4 + dy5) | |
| self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3)) | |
| self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6)) | |
| def op_flex1(self, index): | |
| dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4, dx5, dy5, d6 = self.popall() | |
| dx = dx1 + dx2 + dx3 + dx4 + dx5 | |
| dy = dy1 + dy2 + dy3 + dy4 + dy5 | |
| if abs(dx) > abs(dy): | |
| dx6 = d6 | |
| dy6 = -dy | |
| else: | |
| dx6 = -dx | |
| dy6 = d6 | |
| self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3)) | |
| self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6)) | |
| # misc | |
| def op_and(self, index): | |
| raise NotImplementedError | |
| def op_or(self, index): | |
| raise NotImplementedError | |
| def op_not(self, index): | |
| raise NotImplementedError | |
| def op_store(self, index): | |
| raise NotImplementedError | |
| def op_abs(self, index): | |
| raise NotImplementedError | |
| def op_add(self, index): | |
| raise NotImplementedError | |
| def op_sub(self, index): | |
| raise NotImplementedError | |
| def op_div(self, index): | |
| num2 = self.pop() | |
| num1 = self.pop() | |
| d1 = num1 // num2 | |
| d2 = num1 / num2 | |
| if d1 == d2: | |
| self.push(d1) | |
| else: | |
| self.push(d2) | |
| def op_load(self, index): | |
| raise NotImplementedError | |
| def op_neg(self, index): | |
| raise NotImplementedError | |
| def op_eq(self, index): | |
| raise NotImplementedError | |
| def op_drop(self, index): | |
| raise NotImplementedError | |
| def op_put(self, index): | |
| raise NotImplementedError | |
| def op_get(self, index): | |
| raise NotImplementedError | |
| def op_ifelse(self, index): | |
| raise NotImplementedError | |
| def op_random(self, index): | |
| raise NotImplementedError | |
| def op_mul(self, index): | |
| raise NotImplementedError | |
| def op_sqrt(self, index): | |
| raise NotImplementedError | |
| def op_dup(self, index): | |
| raise NotImplementedError | |
| def op_exch(self, index): | |
| raise NotImplementedError | |
| def op_index(self, index): | |
| raise NotImplementedError | |
| def op_roll(self, index): | |
| raise NotImplementedError | |
| # | |
| # miscellaneous helpers | |
| # | |
| def alternatingLineto(self, isHorizontal): | |
| args = self.popall() | |
| for arg in args: | |
| if isHorizontal: | |
| point = (arg, 0) | |
| else: | |
| point = (0, arg) | |
| self.rLineTo(point) | |
| isHorizontal = not isHorizontal | |
| def vcurveto(self, args): | |
| dya, dxb, dyb, dxc = args[:4] | |
| args = args[4:] | |
| if len(args) == 1: | |
| dyc = args[0] | |
| args = [] | |
| else: | |
| dyc = 0 | |
| self.rCurveTo((0, dya), (dxb, dyb), (dxc, dyc)) | |
| return args | |
| def hcurveto(self, args): | |
| dxa, dxb, dyb, dyc = args[:4] | |
| args = args[4:] | |
| if len(args) == 1: | |
| dxc = args[0] | |
| args = [] | |
| else: | |
| dxc = 0 | |
| self.rCurveTo((dxa, 0), (dxb, dyb), (dxc, dyc)) | |
| return args | |
| class T1OutlineExtractor(T2OutlineExtractor): | |
| def __init__(self, pen, subrs): | |
| self.pen = pen | |
| self.subrs = subrs | |
| self.reset() | |
| def reset(self): | |
| self.flexing = 0 | |
| self.width = 0 | |
| self.sbx = 0 | |
| T2OutlineExtractor.reset(self) | |
| def endPath(self): | |
| if self.sawMoveTo: | |
| self.pen.endPath() | |
| self.sawMoveTo = 0 | |
| def popallWidth(self, evenOdd=0): | |
| return self.popall() | |
| def exch(self): | |
| stack = self.operandStack | |
| stack[-1], stack[-2] = stack[-2], stack[-1] | |
| # | |
| # path constructors | |
| # | |
| def op_rmoveto(self, index): | |
| if self.flexing: | |
| return | |
| self.endPath() | |
| self.rMoveTo(self.popall()) | |
| def op_hmoveto(self, index): | |
| if self.flexing: | |
| # We must add a parameter to the stack if we are flexing | |
| self.push(0) | |
| return | |
| self.endPath() | |
| self.rMoveTo((self.popall()[0], 0)) | |
| def op_vmoveto(self, index): | |
| if self.flexing: | |
| # We must add a parameter to the stack if we are flexing | |
| self.push(0) | |
| self.exch() | |
| return | |
| self.endPath() | |
| self.rMoveTo((0, self.popall()[0])) | |
| def op_closepath(self, index): | |
| self.closePath() | |
| def op_setcurrentpoint(self, index): | |
| args = self.popall() | |
| x, y = args | |
| self.currentPoint = x, y | |
| def op_endchar(self, index): | |
| self.endPath() | |
| def op_hsbw(self, index): | |
| sbx, wx = self.popall() | |
| self.width = wx | |
| self.sbx = sbx | |
| self.currentPoint = sbx, self.currentPoint[1] | |
| def op_sbw(self, index): | |
| self.popall() # XXX | |
| # | |
| def op_callsubr(self, index): | |
| subrIndex = self.pop() | |
| subr = self.subrs[subrIndex] | |
| self.execute(subr) | |
| def op_callothersubr(self, index): | |
| subrIndex = self.pop() | |
| nArgs = self.pop() | |
| # print nArgs, subrIndex, "callothersubr" | |
| if subrIndex == 0 and nArgs == 3: | |
| self.doFlex() | |
| self.flexing = 0 | |
| elif subrIndex == 1 and nArgs == 0: | |
| self.flexing = 1 | |
| # ignore... | |
| def op_pop(self, index): | |
| pass # ignore... | |
| def doFlex(self): | |
| finaly = self.pop() | |
| finalx = self.pop() | |
| self.pop() # flex height is unused | |
| p3y = self.pop() | |
| p3x = self.pop() | |
| bcp4y = self.pop() | |
| bcp4x = self.pop() | |
| bcp3y = self.pop() | |
| bcp3x = self.pop() | |
| p2y = self.pop() | |
| p2x = self.pop() | |
| bcp2y = self.pop() | |
| bcp2x = self.pop() | |
| bcp1y = self.pop() | |
| bcp1x = self.pop() | |
| rpy = self.pop() | |
| rpx = self.pop() | |
| # call rrcurveto | |
| self.push(bcp1x + rpx) | |
| self.push(bcp1y + rpy) | |
| self.push(bcp2x) | |
| self.push(bcp2y) | |
| self.push(p2x) | |
| self.push(p2y) | |
| self.op_rrcurveto(None) | |
| # call rrcurveto | |
| self.push(bcp3x) | |
| self.push(bcp3y) | |
| self.push(bcp4x) | |
| self.push(bcp4y) | |
| self.push(p3x) | |
| self.push(p3y) | |
| self.op_rrcurveto(None) | |
| # Push back final coords so subr 0 can find them | |
| self.push(finalx) | |
| self.push(finaly) | |
| def op_dotsection(self, index): | |
| self.popall() # XXX | |
| def op_hstem3(self, index): | |
| self.popall() # XXX | |
| def op_seac(self, index): | |
| "asb adx ady bchar achar seac" | |
| from fontTools.encodings.StandardEncoding import StandardEncoding | |
| asb, adx, ady, bchar, achar = self.popall() | |
| baseGlyph = StandardEncoding[bchar] | |
| self.pen.addComponent(baseGlyph, (1, 0, 0, 1, 0, 0)) | |
| accentGlyph = StandardEncoding[achar] | |
| adx = adx + self.sbx - asb # seac weirdness | |
| self.pen.addComponent(accentGlyph, (1, 0, 0, 1, adx, ady)) | |
| def op_vstem3(self, index): | |
| self.popall() # XXX | |
| class T2CharString(object): | |
| operandEncoding = t2OperandEncoding | |
| operators, opcodes = buildOperatorDict(t2Operators) | |
| decompilerClass = SimpleT2Decompiler | |
| outlineExtractor = T2OutlineExtractor | |
| def __init__(self, bytecode=None, program=None, private=None, globalSubrs=None): | |
| if program is None: | |
| program = [] | |
| self.bytecode = bytecode | |
| self.program = program | |
| self.private = private | |
| self.globalSubrs = globalSubrs if globalSubrs is not None else [] | |
| self._cur_vsindex = None | |
| def getNumRegions(self, vsindex=None): | |
| pd = self.private | |
| assert pd is not None | |
| if vsindex is not None: | |
| self._cur_vsindex = vsindex | |
| elif self._cur_vsindex is None: | |
| self._cur_vsindex = pd.vsindex if hasattr(pd, "vsindex") else 0 | |
| return pd.getNumRegions(self._cur_vsindex) | |
| def __repr__(self): | |
| if self.bytecode is None: | |
| return "<%s (source) at %x>" % (self.__class__.__name__, id(self)) | |
| else: | |
| return "<%s (bytecode) at %x>" % (self.__class__.__name__, id(self)) | |
| def getIntEncoder(self): | |
| return encodeIntT2 | |
| def getFixedEncoder(self): | |
| return encodeFixed | |
| def decompile(self): | |
| if not self.needsDecompilation(): | |
| return | |
| subrs = getattr(self.private, "Subrs", []) | |
| decompiler = self.decompilerClass(subrs, self.globalSubrs, self.private) | |
| decompiler.execute(self) | |
| def draw(self, pen, blender=None): | |
| subrs = getattr(self.private, "Subrs", []) | |
| extractor = self.outlineExtractor( | |
| pen, | |
| subrs, | |
| self.globalSubrs, | |
| self.private.nominalWidthX, | |
| self.private.defaultWidthX, | |
| self.private, | |
| blender, | |
| ) | |
| extractor.execute(self) | |
| self.width = extractor.width | |
| def calcBounds(self, glyphSet): | |
| boundsPen = BoundsPen(glyphSet) | |
| self.draw(boundsPen) | |
| return boundsPen.bounds | |
| def compile(self, isCFF2=False): | |
| if self.bytecode is not None: | |
| return | |
| opcodes = self.opcodes | |
| program = self.program | |
| if isCFF2: | |
| # If present, remove return and endchar operators. | |
| if program and program[-1] in ("return", "endchar"): | |
| program = program[:-1] | |
| elif program and not isinstance(program[-1], str): | |
| raise CharStringCompileError( | |
| "T2CharString or Subr has items on the stack after last operator." | |
| ) | |
| bytecode = [] | |
| encodeInt = self.getIntEncoder() | |
| encodeFixed = self.getFixedEncoder() | |
| i = 0 | |
| end = len(program) | |
| while i < end: | |
| token = program[i] | |
| i = i + 1 | |
| if isinstance(token, str): | |
| try: | |
| bytecode.extend(bytechr(b) for b in opcodes[token]) | |
| except KeyError: | |
| raise CharStringCompileError("illegal operator: %s" % token) | |
| if token in ("hintmask", "cntrmask"): | |
| bytecode.append(program[i]) # hint mask | |
| i = i + 1 | |
| elif isinstance(token, int): | |
| bytecode.append(encodeInt(token)) | |
| elif isinstance(token, float): | |
| bytecode.append(encodeFixed(token)) | |
| else: | |
| assert 0, "unsupported type: %s" % type(token) | |
| try: | |
| bytecode = bytesjoin(bytecode) | |
| except TypeError: | |
| log.error(bytecode) | |
| raise | |
| self.setBytecode(bytecode) | |
| def needsDecompilation(self): | |
| return self.bytecode is not None | |
| def setProgram(self, program): | |
| self.program = program | |
| self.bytecode = None | |
| def setBytecode(self, bytecode): | |
| self.bytecode = bytecode | |
| self.program = None | |
| def getToken(self, index, len=len, byteord=byteord, isinstance=isinstance): | |
| if self.bytecode is not None: | |
| if index >= len(self.bytecode): | |
| return None, 0, 0 | |
| b0 = byteord(self.bytecode[index]) | |
| index = index + 1 | |
| handler = self.operandEncoding[b0] | |
| token, index = handler(self, b0, self.bytecode, index) | |
| else: | |
| if index >= len(self.program): | |
| return None, 0, 0 | |
| token = self.program[index] | |
| index = index + 1 | |
| isOperator = isinstance(token, str) | |
| return token, isOperator, index | |
| def getBytes(self, index, nBytes): | |
| if self.bytecode is not None: | |
| newIndex = index + nBytes | |
| bytes = self.bytecode[index:newIndex] | |
| index = newIndex | |
| else: | |
| bytes = self.program[index] | |
| index = index + 1 | |
| assert len(bytes) == nBytes | |
| return bytes, index | |
| def handle_operator(self, operator): | |
| return operator | |
| def toXML(self, xmlWriter, ttFont=None): | |
| from fontTools.misc.textTools import num2binary | |
| if self.bytecode is not None: | |
| xmlWriter.dumphex(self.bytecode) | |
| else: | |
| index = 0 | |
| args = [] | |
| while True: | |
| token, isOperator, index = self.getToken(index) | |
| if token is None: | |
| break | |
| if isOperator: | |
| if token in ("hintmask", "cntrmask"): | |
| hintMask, isOperator, index = self.getToken(index) | |
| bits = [] | |
| for byte in hintMask: | |
| bits.append(num2binary(byteord(byte), 8)) | |
| hintMask = strjoin(bits) | |
| line = " ".join(args + [token, hintMask]) | |
| else: | |
| line = " ".join(args + [token]) | |
| xmlWriter.write(line) | |
| xmlWriter.newline() | |
| args = [] | |
| else: | |
| if isinstance(token, float): | |
| token = floatToFixedToStr(token, precisionBits=16) | |
| else: | |
| token = str(token) | |
| args.append(token) | |
| if args: | |
| # NOTE: only CFF2 charstrings/subrs can have numeric arguments on | |
| # the stack after the last operator. Compiling this would fail if | |
| # this is part of CFF 1.0 table. | |
| line = " ".join(args) | |
| xmlWriter.write(line) | |
| def fromXML(self, name, attrs, content): | |
| from fontTools.misc.textTools import binary2num, readHex | |
| if attrs.get("raw"): | |
| self.setBytecode(readHex(content)) | |
| return | |
| content = strjoin(content) | |
| content = content.split() | |
| program = [] | |
| end = len(content) | |
| i = 0 | |
| while i < end: | |
| token = content[i] | |
| i = i + 1 | |
| try: | |
| token = int(token) | |
| except ValueError: | |
| try: | |
| token = strToFixedToFloat(token, precisionBits=16) | |
| except ValueError: | |
| program.append(token) | |
| if token in ("hintmask", "cntrmask"): | |
| mask = content[i] | |
| maskBytes = b"" | |
| for j in range(0, len(mask), 8): | |
| maskBytes = maskBytes + bytechr(binary2num(mask[j : j + 8])) | |
| program.append(maskBytes) | |
| i = i + 1 | |
| else: | |
| program.append(token) | |
| else: | |
| program.append(token) | |
| self.setProgram(program) | |
| class T1CharString(T2CharString): | |
| operandEncoding = t1OperandEncoding | |
| operators, opcodes = buildOperatorDict(t1Operators) | |
| def __init__(self, bytecode=None, program=None, subrs=None): | |
| super().__init__(bytecode, program) | |
| self.subrs = subrs | |
| def getIntEncoder(self): | |
| return encodeIntT1 | |
| def getFixedEncoder(self): | |
| def encodeFixed(value): | |
| raise TypeError("Type 1 charstrings don't support floating point operands") | |
| def decompile(self): | |
| if self.bytecode is None: | |
| return | |
| program = [] | |
| index = 0 | |
| while True: | |
| token, isOperator, index = self.getToken(index) | |
| if token is None: | |
| break | |
| program.append(token) | |
| self.setProgram(program) | |
| def draw(self, pen): | |
| extractor = T1OutlineExtractor(pen, self.subrs) | |
| extractor.execute(self) | |
| self.width = extractor.width | |
| class DictDecompiler(object): | |
| operandEncoding = cffDictOperandEncoding | |
| def __init__(self, strings, parent=None): | |
| self.stack = [] | |
| self.strings = strings | |
| self.dict = {} | |
| self.parent = parent | |
| def getDict(self): | |
| assert len(self.stack) == 0, "non-empty stack" | |
| return self.dict | |
| def decompile(self, data): | |
| index = 0 | |
| lenData = len(data) | |
| push = self.stack.append | |
| while index < lenData: | |
| b0 = byteord(data[index]) | |
| index = index + 1 | |
| handler = self.operandEncoding[b0] | |
| value, index = handler(self, b0, data, index) | |
| if value is not None: | |
| push(value) | |
| def pop(self): | |
| value = self.stack[-1] | |
| del self.stack[-1] | |
| return value | |
| def popall(self): | |
| args = self.stack[:] | |
| del self.stack[:] | |
| return args | |
| def handle_operator(self, operator): | |
| operator, argType = operator | |
| if isinstance(argType, tuple): | |
| value = () | |
| for i in range(len(argType) - 1, -1, -1): | |
| arg = argType[i] | |
| arghandler = getattr(self, "arg_" + arg) | |
| value = (arghandler(operator),) + value | |
| else: | |
| arghandler = getattr(self, "arg_" + argType) | |
| value = arghandler(operator) | |
| if operator == "blend": | |
| self.stack.extend(value) | |
| else: | |
| self.dict[operator] = value | |
| def arg_number(self, name): | |
| if isinstance(self.stack[0], list): | |
| out = self.arg_blend_number(self.stack) | |
| else: | |
| out = self.pop() | |
| return out | |
| def arg_blend_number(self, name): | |
| out = [] | |
| blendArgs = self.pop() | |
| numMasters = len(blendArgs) | |
| out.append(blendArgs) | |
| out.append("blend") | |
| dummy = self.popall() | |
| return blendArgs | |
| def arg_SID(self, name): | |
| return self.strings[self.pop()] | |
| def arg_array(self, name): | |
| return self.popall() | |
| def arg_blendList(self, name): | |
| """ | |
| There may be non-blend args at the top of the stack. We first calculate | |
| where the blend args start in the stack. These are the last | |
| numMasters*numBlends) +1 args. | |
| The blend args starts with numMasters relative coordinate values, the BlueValues in the list from the default master font. This is followed by | |
| numBlends list of values. Each of value in one of these lists is the | |
| Variable Font delta for the matching region. | |
| We re-arrange this to be a list of numMaster entries. Each entry starts with the corresponding default font relative value, and is followed by | |
| the delta values. We then convert the default values, the first item in each entry, to an absolute value. | |
| """ | |
| vsindex = self.dict.get("vsindex", 0) | |
| numMasters = ( | |
| self.parent.getNumRegions(vsindex) + 1 | |
| ) # only a PrivateDict has blended ops. | |
| numBlends = self.pop() | |
| args = self.popall() | |
| numArgs = len(args) | |
| # The spec says that there should be no non-blended Blue Values,. | |
| assert numArgs == numMasters * numBlends | |
| value = [None] * numBlends | |
| numDeltas = numMasters - 1 | |
| i = 0 | |
| prevVal = 0 | |
| while i < numBlends: | |
| newVal = args[i] + prevVal | |
| prevVal = newVal | |
| masterOffset = numBlends + (i * numDeltas) | |
| blendList = [newVal] + args[masterOffset : masterOffset + numDeltas] | |
| value[i] = blendList | |
| i += 1 | |
| return value | |
| def arg_delta(self, name): | |
| valueList = self.popall() | |
| out = [] | |
| if valueList and isinstance(valueList[0], list): | |
| # arg_blendList() has already converted these to absolute values. | |
| out = valueList | |
| else: | |
| current = 0 | |
| for v in valueList: | |
| current = current + v | |
| out.append(current) | |
| return out | |
| def calcSubrBias(subrs): | |
| nSubrs = len(subrs) | |
| if nSubrs < 1240: | |
| bias = 107 | |
| elif nSubrs < 33900: | |
| bias = 1131 | |
| else: | |
| bias = 32768 | |
| return bias | |