chatExcel

"""Module for reading TFM (TeX Font Metrics) files. The TFM format is described in the TFtoPL WEB source code, whose typeset form can be found on `CTAN <http://mirrors.ctan.org/info/knuth-pdf/texware/tftopl.pdf>`_. >>> from fontTools.tfmLib import TFM >>> tfm = TFM("Tests/tfmLib/data/cmr10.tfm") >>> >>> # Accessing an attribute gets you metadata. >>> tfm.checksum 1274110073 >>> tfm.designsize 10.0 >>> tfm.codingscheme 'TeX text' >>> tfm.family 'CMR' >>> tfm.seven_bit_safe_flag False >>> tfm.face 234 >>> tfm.extraheader {} >>> tfm.fontdimens {'SLANT': 0.0, 'SPACE': 0.33333396911621094, 'STRETCH': 0.16666698455810547, 'SHRINK': 0.11111164093017578, 'XHEIGHT': 0.4305553436279297, 'QUAD': 1.0000028610229492, 'EXTRASPACE': 0.11111164093017578} >>> # Accessing a character gets you its metrics. >>> # “width” is always available, other metrics are available only when >>> # applicable. All values are relative to “designsize”. >>> tfm.chars[ord("g")] {'width': 0.5000019073486328, 'height': 0.4305553436279297, 'depth': 0.1944446563720703, 'italic': 0.013888359069824219} >>> # Kerning and ligature can be accessed as well. >>> tfm.kerning[ord("c")] {104: -0.02777862548828125, 107: -0.02777862548828125} >>> tfm.ligatures[ord("f")] {105: ('LIG', 12), 102: ('LIG', 11), 108: ('LIG', 13)} """ from types import SimpleNamespace from fontTools.misc.sstruct import calcsize, unpack, unpack2 SIZES_FORMAT = """ > lf: h # length of the entire file, in words lh: h # length of the header data, in words bc: h # smallest character code in the font ec: h # largest character code in the font nw: h # number of words in the width table nh: h # number of words in the height table nd: h # number of words in the depth table ni: h # number of words in the italic correction table nl: h # number of words in the ligature/kern table nk: h # number of words in the kern table ne: h # number of words in the extensible character table np: h # number of font parameter words """ SIZES_SIZE = calcsize(SIZES_FORMAT) FIXED_FORMAT = "12.20F" HEADER_FORMAT1 = f""" > checksum: L designsize: {FIXED_FORMAT} """ HEADER_FORMAT2 = f""" {HEADER_FORMAT1} codingscheme: 40p """ HEADER_FORMAT3 = f""" {HEADER_FORMAT2} family: 20p """ HEADER_FORMAT4 = f""" {HEADER_FORMAT3} seven_bit_safe_flag: ? ignored: x ignored: x face: B """ HEADER_SIZE1 = calcsize(HEADER_FORMAT1) HEADER_SIZE2 = calcsize(HEADER_FORMAT2) HEADER_SIZE3 = calcsize(HEADER_FORMAT3) HEADER_SIZE4 = calcsize(HEADER_FORMAT4) LIG_KERN_COMMAND = """ > skip_byte: B next_char: B op_byte: B remainder: B """ BASE_PARAMS = [ "SLANT", "SPACE", "STRETCH", "SHRINK", "XHEIGHT", "QUAD", "EXTRASPACE", ] MATHSY_PARAMS = [ "NUM1", "NUM2", "NUM3", "DENOM1", "DENOM2", "SUP1", "SUP2", "SUP3", "SUB1", "SUB2", "SUPDROP", "SUBDROP", "DELIM1", "DELIM2", "AXISHEIGHT", ] MATHEX_PARAMS = [ "DEFAULTRULETHICKNESS", "BIGOPSPACING1", "BIGOPSPACING2", "BIGOPSPACING3", "BIGOPSPACING4", "BIGOPSPACING5", ] VANILLA = 0 MATHSY = 1 MATHEX = 2 UNREACHABLE = 0 PASSTHROUGH = 1 ACCESSABLE = 2 NO_TAG = 0 LIG_TAG = 1 LIST_TAG = 2 EXT_TAG = 3 STOP_FLAG = 128 KERN_FLAG = 128 class TFMException(Exception): def __init__(self, message): super().__init__(message) class TFM: def __init__(self, file): self._read(file) def __repr__(self): return ( f"<TFM" f" for {self.family}" f" in {self.codingscheme}" f" at {self.designsize:g}pt>" ) def _read(self, file): if hasattr(file, "read"): data = file.read() else: with open(file, "rb") as fp: data = fp.read() self._data = data if len(data) < SIZES_SIZE: raise TFMException("Too short input file") sizes = SimpleNamespace() unpack2(SIZES_FORMAT, data, sizes) # Do some file structure sanity checks. # TeX and TFtoPL do additional functional checks and might even correct # “errors” in the input file, but we instead try to output the file as # it is as long as it is parsable, even if the data make no sense. if sizes.lf < 0: raise TFMException("The file claims to have negative or zero length!") if len(data) < sizes.lf * 4: raise TFMException("The file has fewer bytes than it claims!") for name, length in vars(sizes).items(): if length < 0: raise TFMException("The subfile size: '{name}' is negative!") if sizes.lh < 2: raise TFMException(f"The header length is only {sizes.lh}!") if sizes.bc > sizes.ec + 1 or sizes.ec > 255: raise TFMException( f"The character code range {sizes.bc}..{sizes.ec} is illegal!" ) if sizes.nw == 0 or sizes.nh == 0 or sizes.nd == 0 or sizes.ni == 0: raise TFMException("Incomplete subfiles for character dimensions!") if sizes.ne > 256: raise TFMException(f"There are {ne} extensible recipes!") if sizes.lf != ( 6 + sizes.lh + (sizes.ec - sizes.bc + 1) + sizes.nw + sizes.nh + sizes.nd + sizes.ni + sizes.nl + sizes.nk + sizes.ne + sizes.np ): raise TFMException("Subfile sizes don’t add up to the stated total") # Subfile offsets, used in the helper function below. These all are # 32-bit word offsets not 8-bit byte offsets. char_base = 6 + sizes.lh - sizes.bc width_base = char_base + sizes.ec + 1 height_base = width_base + sizes.nw depth_base = height_base + sizes.nh italic_base = depth_base + sizes.nd lig_kern_base = italic_base + sizes.ni kern_base = lig_kern_base + sizes.nl exten_base = kern_base + sizes.nk param_base = exten_base + sizes.ne # Helper functions for accessing individual data. If this looks # nonidiomatic Python, I blame the effect of reading the literate WEB # documentation of TFtoPL. def char_info(c): return 4 * (char_base + c) def width_index(c): return data[char_info(c)] def noneexistent(c): return c < sizes.bc or c > sizes.ec or width_index(c) == 0 def height_index(c): return data[char_info(c) + 1] // 16 def depth_index(c): return data[char_info(c) + 1] % 16 def italic_index(c): return data[char_info(c) + 2] // 4 def tag(c): return data[char_info(c) + 2] % 4 def remainder(c): return data[char_info(c) + 3] def width(c): r = 4 * (width_base + width_index(c)) return read_fixed(r, "v")["v"] def height(c): r = 4 * (height_base + height_index(c)) return read_fixed(r, "v")["v"] def depth(c): r = 4 * (depth_base + depth_index(c)) return read_fixed(r, "v")["v"] def italic(c): r = 4 * (italic_base + italic_index(c)) return read_fixed(r, "v")["v"] def exten(c): return 4 * (exten_base + remainder(c)) def lig_step(i): return 4 * (lig_kern_base + i) def lig_kern_command(i): command = SimpleNamespace() unpack2(LIG_KERN_COMMAND, data[i:], command) return command def kern(i): r = 4 * (kern_base + i) return read_fixed(r, "v")["v"] def param(i): return 4 * (param_base + i) def read_fixed(index, key, obj=None): ret = unpack2(f">;{key}:{FIXED_FORMAT}", data[index:], obj) return ret[0] # Set all attributes to empty values regardless of the header size. unpack(HEADER_FORMAT4, [0] * HEADER_SIZE4, self) offset = 24 length = sizes.lh * 4 self.extraheader = {} if length >= HEADER_SIZE4: rest = unpack2(HEADER_FORMAT4, data[offset:], self)[1] if self.face < 18: s = self.face % 2 b = self.face // 2 self.face = "MBL"[b % 3] + "RI"[s] + "RCE"[b // 3] for i in range(sizes.lh - HEADER_SIZE4 // 4): rest = unpack2(f">;HEADER{i + 18}:l", rest, self.extraheader)[1] elif length >= HEADER_SIZE3: unpack2(HEADER_FORMAT3, data[offset:], self) elif length >= HEADER_SIZE2: unpack2(HEADER_FORMAT2, data[offset:], self) elif length >= HEADER_SIZE1: unpack2(HEADER_FORMAT1, data[offset:], self) self.fonttype = VANILLA scheme = self.codingscheme.upper() if scheme.startswith("TEX MATH SY"): self.fonttype = MATHSY elif scheme.startswith("TEX MATH EX"): self.fonttype = MATHEX self.fontdimens = {} for i in range(sizes.np): name = f"PARAMETER{i+1}" if i <= 6: name = BASE_PARAMS[i] elif self.fonttype == MATHSY and i <= 21: name = MATHSY_PARAMS[i - 7] elif self.fonttype == MATHEX and i <= 12: name = MATHEX_PARAMS[i - 7] read_fixed(param(i), name, self.fontdimens) lig_kern_map = {} self.right_boundary_char = None self.left_boundary_char = None if sizes.nl > 0: cmd = lig_kern_command(lig_step(0)) if cmd.skip_byte == 255: self.right_boundary_char = cmd.next_char cmd = lig_kern_command(lig_step((sizes.nl - 1))) if cmd.skip_byte == 255: self.left_boundary_char = 256 r = 256 * cmd.op_byte + cmd.remainder lig_kern_map[self.left_boundary_char] = r self.chars = {} for c in range(sizes.bc, sizes.ec + 1): if width_index(c) > 0: self.chars[c] = info = {} info["width"] = width(c) if height_index(c) > 0: info["height"] = height(c) if depth_index(c) > 0: info["depth"] = depth(c) if italic_index(c) > 0: info["italic"] = italic(c) char_tag = tag(c) if char_tag == NO_TAG: pass elif char_tag == LIG_TAG: lig_kern_map[c] = remainder(c) elif char_tag == LIST_TAG: info["nextlarger"] = remainder(c) elif char_tag == EXT_TAG: info["varchar"] = varchar = {} for i in range(4): part = data[exten(c) + i] if i == 3 or part > 0: name = "rep" if i == 0: name = "top" elif i == 1: name = "mid" elif i == 2: name = "bot" if noneexistent(part): varchar[name] = c else: varchar[name] = part self.ligatures = {} self.kerning = {} for c, i in sorted(lig_kern_map.items()): cmd = lig_kern_command(lig_step(i)) if cmd.skip_byte > STOP_FLAG: i = 256 * cmd.op_byte + cmd.remainder while i < sizes.nl: cmd = lig_kern_command(lig_step(i)) if cmd.skip_byte > STOP_FLAG: pass else: if cmd.op_byte >= KERN_FLAG: r = 256 * (cmd.op_byte - KERN_FLAG) + cmd.remainder self.kerning.setdefault(c, {})[cmd.next_char] = kern(r) else: r = cmd.op_byte if r == 4 or (r > 7 and r != 11): # Ligature step with nonstandard code, we output # the code verbatim. lig = r else: lig = "" if r % 4 > 1: lig += "/" lig += "LIG" if r % 2 != 0: lig += "/" while r > 3: lig += ">" r -= 4 self.ligatures.setdefault(c, {})[cmd.next_char] = ( lig, cmd.remainder, ) if cmd.skip_byte >= STOP_FLAG: break i += cmd.skip_byte + 1 if __name__ == "__main__": import sys tfm = TFM(sys.argv[1]) print( "\n".join( x for x in [ f"tfm.checksum={tfm.checksum}", f"tfm.designsize={tfm.designsize}", f"tfm.codingscheme={tfm.codingscheme}", f"tfm.fonttype={tfm.fonttype}", f"tfm.family={tfm.family}", f"tfm.seven_bit_safe_flag={tfm.seven_bit_safe_flag}", f"tfm.face={tfm.face}", f"tfm.extraheader={tfm.extraheader}", f"tfm.fontdimens={tfm.fontdimens}", f"tfm.right_boundary_char={tfm.right_boundary_char}", f"tfm.left_boundary_char={tfm.left_boundary_char}", f"tfm.kerning={tfm.kerning}", f"tfm.ligatures={tfm.ligatures}", f"tfm.chars={tfm.chars}", ] ) ) print(tfm)