# -*- coding: utf-8 -*- """ Deroff.py, ported to Python from the venerable deroff.c """ import sys, re, string IS_PY3 = sys.version_info[0] >= 3 class Deroffer: g_specs_specletter = { # Output composed latin1 letters "-D": "\320", "Sd": "\360", "Tp": "\376", "TP": "\336", "AE": "\306", "ae": "\346", "OE": "OE", "oe": "oe", ":a": "\344", ":A": "\304", ":e": "\353", ":E": "\313", ":i": "\357", ":I": "\317", ":o": "\366", ":O": "\326", ":u": "\374", ":U": "\334", ":y": "\377", "ss": "\337", "'A": "\301", "'E": "\311", "'I": "\315", "'O": "\323", "'U": "\332", "'Y": "\335", "'a": "\341", "'e": "\351", "'i": "\355", "'o": "\363", "'u": "\372", "'y": "\375", "^A": "\302", "^E": "\312", "^I": "\316", "^O": "\324", "^U": "\333", "^a": "\342", "^e": "\352", "^i": "\356", "^o": "\364", "^u": "\373", "`A": "\300", "`E": "\310", "`I": "\314", "`O": "\322", "`U": "\331", "`a": "\340", "`e": "\350", "`i": "\354", "`o": "\362", "`u": "\371", "~A": "\303", "~N": "\321", "~O": "\325", "~a": "\343", "~n": "\361", "~o": "\365", ",C": "\307", ",c": "\347", "/l": "/l", "/L": "/L", "/o": "\370", "/O": "\330", "oA": "\305", "oa": "\345", # Ligatures "fi": "fi", "ff": "ff", "fl": "fl", "Fi": "ffi", "Ff": "fff", "Fl": "ffl", } g_specs = { "mi": "-", "en": "-", "hy": "-", "em": "--", "lq": "“", "rq": "”", "Bq": ",,", "oq": "`", "cq": "'", "aq": "'", "dq": '"', "or": "|", "at": "@", "sh": "#", "Eu": "\244", "eu": "\244", "Do": "$", "ct": "\242", "Fo": "\253", "Fc": "\273", "fo": "<", "fc": ">", "r!": "\241", "r?": "\277", "Of": "\252", "Om": "\272", "pc": "\267", "S1": "\271", "S2": "\262", "S3": "\263", "<-": "<-", "->": "->", "<>": "<->", "ua": "^", "da": "v", "lA": "<=", "rA": "=>", "hA": "<=>", "uA": "^^", "dA": "vv", "ba": "|", "bb": "|", "br": "|", "bv": "|", "ru": "_", "ul": "_", "ci": "O", "bu": "o", "co": "\251", "rg": "\256", "tm": "(TM)", "dd": "||", "dg": "|", "ps": "\266", "sc": "\247", "de": "\260", "%0": "0/00", "14": "\274", "12": "\275", "34": "\276", "f/": "/", "sl": "/", "rs": "\\", "sq": "[]", "fm": "'", "ha": "^", "ti": "~", "lB": "[", "rB": "]", "lC": "{", "rC": "}", "la": "<", "ra": ">", "lh": "<=", "rh": "=>", "tf": "therefore", "~~": "~~", "~=": "~=", "!=": "!=", "**": "*", "+-": "\261", "<=": "<=", "==": "==", "=~": "=~", ">=": ">=", "AN": "\\/", "OR": "/\\", "no": "\254", "te": "there exists", "fa": "for all", "Ah": "aleph", "Im": "imaginary", "Re": "real", "if": "infinity", "md": "\267", "mo": "member of", "mu": "\327", "nm": "not member of", "pl": "+", "eq": "=", "pt": "oc", "pp": "perpendicular", "sb": "(=", "sp": "=)", "ib": "(-", "ip": "-)", "ap": "~", "is": "I", "sr": "root", "pd": "d", "c*": "(x)", "c+": "(+)", "ca": "cap", "cu": "U", "di": "\367", "gr": "V", "es": "{}", "CR": "_|", "st": "such that", "/_": "/_", "lz": "<>", "an": "-", # Output Greek "*A": "Alpha", "*B": "Beta", "*C": "Xi", "*D": "Delta", "*E": "Epsilon", "*F": "Phi", "*G": "Gamma", "*H": "Theta", "*I": "Iota", "*K": "Kappa", "*L": "Lambda", "*M": "Mu", "*N": "Nu", "*O": "Omicron", "*P": "Pi", "*Q": "Psi", "*R": "Rho", "*S": "Sigma", "*T": "Tau", "*U": "Upsilon", "*W": "Omega", "*X": "Chi", "*Y": "Eta", "*Z": "Zeta", "*a": "alpha", "*b": "beta", "*c": "xi", "*d": "delta", "*e": "epsilon", "*f": "phi", "+f": "phi", "*g": "gamma", "*h": "theta", "+h": "theta", "*i": "iota", "*k": "kappa", "*l": "lambda", "*m": "\265", "*n": "nu", "*o": "omicron", "*p": "pi", "+p": "omega", "*q": "psi", "*r": "rho", "*s": "sigma", "*t": "tau", "*u": "upsilon", "*w": "omega", "*x": "chi", "*y": "eta", "*z": "zeta", "ts": "sigma", } g_re_word = re.compile(r"[a-zA-Z_]+") # equivalent to the word() method g_re_number = re.compile(r"[+-]?\d+") # equivalent to the number() method g_re_esc_char = re.compile( r"""([a-zA-Z_]) | # Word ([+-]?\d) | # Number \\ # Backslash (for escape seq) """, re.VERBOSE, ) g_re_not_backslash_or_whitespace = re.compile( r"[^ \t\n\r\f\v\\]+" ) # Match a sequence of not backslash or whitespace g_re_newline_collapse = re.compile(r"\n{3,}") g_re_font = re.compile( r"""\\f( # Starts with backslash f (\(\S{2}) | # Open paren, then two printable chars (\[\S*?\]) | # Open bracket, zero or more printable characters, then close bracket \S) # Any printable character """, re.VERBOSE, ) # This gets filled in in __init__ below g_macro_dict = False def __init__(self): self.reg_table = {} self.tr_from = "" self.tr_to = "" self.tr = "" self.nls = 2 self.specletter = False self.refer = False self.macro = 0 self.nobody = False self.inlist = False self.inheader = False self.pic = False self.tbl = False self.tblstate = 0 self.tblTab = "" self.eqn = False self.skipheaders = False self.skiplists = False self.ignore_sonx = False self.output = [] self.name = "" self.OPTIONS = 0 self.FORMAT = 1 self.DATA = 2 # words is uninteresting and should be treated as false if not Deroffer.g_macro_dict: Deroffer.g_macro_dict = { "SH": Deroffer.macro_sh, "SS": Deroffer.macro_ss_ip, "IP": Deroffer.macro_ss_ip, "H ": Deroffer.macro_ss_ip, "I ": Deroffer.macro_i_ir, "IR": Deroffer.macro_i_ir, "IB": Deroffer.macro_i_ir, "B ": Deroffer.macro_i_ir, "BR": Deroffer.macro_i_ir, "BI": Deroffer.macro_i_ir, "R ": Deroffer.macro_i_ir, "RB": Deroffer.macro_i_ir, "RI": Deroffer.macro_i_ir, "AB": Deroffer.macro_i_ir, "Nm": Deroffer.macro_Nm, "] ": Deroffer.macro_close_bracket, "PS": Deroffer.macro_ps, "PE": Deroffer.macro_pe, "TS": Deroffer.macro_ts, "T&": Deroffer.macro_t_and, "TE": Deroffer.macro_te, "EQ": Deroffer.macro_eq, "EN": Deroffer.macro_en, "R1": Deroffer.macro_r1, "R2": Deroffer.macro_r2, "de": Deroffer.macro_de, "BL": Deroffer.macro_bl_vl, "VL": Deroffer.macro_bl_vl, "AL": Deroffer.macro_bl_vl, "LB": Deroffer.macro_bl_vl, "RL": Deroffer.macro_bl_vl, "ML": Deroffer.macro_bl_vl, "DL": Deroffer.macro_bl_vl, "BV": Deroffer.macro_bv, "LE": Deroffer.macro_le, "LP": Deroffer.macro_lp_pp, "PP": Deroffer.macro_lp_pp, "P\n": Deroffer.macro_lp_pp, "ds": Deroffer.macro_ds, "so": Deroffer.macro_so_nx, "nx": Deroffer.macro_so_nx, "tr": Deroffer.macro_tr, "sp": Deroffer.macro_sp, } def flush_output(self, where): if where: where.write(self.get_output()) self.output[:] = [] def get_output(self): res = "".join(self.output) clean_res = Deroffer.g_re_newline_collapse.sub("\n", res) return clean_res def putchar(self, c): self.output.append(c) return c # This gets swapped in in place of condputs the first time tr gets modified def condputs_tr(self, str): special = ( self.pic or self.eqn or self.refer or self.macro or (self.skiplists and self.inlist) or (self.skipheaders and self.inheader) ) if not special: self.output.append(str.translate(self.tr)) def condputs(self, str): special = ( self.pic or self.eqn or self.refer or self.macro or (self.skiplists and self.inlist) or (self.skipheaders and self.inheader) ) if not special: self.output.append(str) def str_at(self, idx): return self.s[idx : idx + 1] def skip_char(self, amt=1): self.s = self.s[amt:] def skip_leading_whitespace(self): self.s = self.s.lstrip() def is_white(self, idx): # Note this returns false for empty strings (idx >= len(self.s)) return self.s[idx : idx + 1].isspace() def str_eq(offset, other, len): return self.s[offset : offset + len] == other[:len] def prch(self, idx): # Note that this return False for the empty string (idx >= len(self.s)) ch = self.s[idx : idx + 1] return ch not in " \t\n" def font(self): match = Deroffer.g_re_font.match(self.s) if not match: return False self.skip_char(match.end()) return True def font2(self): if self.s[0:2] == "\\f": c = self.str_at(2) if c == "(" and self.prch(3) and self.prch(4): self.skip_char(5) return True elif c == "[": self.skip_char(2) while self.prch(0) and self.str_at(0) != "]": self.skip_char() if self.str_at(0) == "]": self.skip_char() elif self.prch(2): self.skip_char(3) return True return False def comment(self): # Here we require that the string start with \" while self.str_at(0) and self.str_at(0) != "\n": self.skip_char() return True def numreq(self): # We require that the string starts with backslash if self.str_at(1) in "hvwud" and self.str_at(2) == "'": self.macro += 1 self.skip_char(3) while self.str_at(0) != "'" and self.esc_char(): pass # Weird if self.str_at(0) == "'": self.skip_char() self.macro -= 1 return True return False def var(self): reg = "" s0s1 = self.s[0:2] if s0s1 == "\\n": if self.s[3:5] == "dy": self.skip_char(5) return True elif self.str_at(2) == "(" and self.prch(3) and self.prch(4): self.skip_char(5) return True elif self.str_at(2) == "[" and self.prch(3): self.skip_char(3) while self.str_at(0) and self.str_at(0) != "]": self.skip_char() return True elif self.prch(2): self.skip_char(3) return True elif s0s1 == "\\*": if self.str_at(2) == "(" and self.prch(3) and self.prch(4): reg = self.s[3:5] self.skip_char(5) elif self.str_at(2) == "[" and self.prch(3): self.skip_char(3) while self.str_at(0) and self.str_at(0) != "]": reg = reg + self.str_at(0) self.skip_char() if self.s[0:1] == "]": self.skip_char() else: return False elif self.prch(2): reg = self.str_at(2) self.skip_char(3) else: return False if reg in self.reg_table: old_s = self.s self.s = self.reg_table[reg] self.text_arg() return True return False def size(self): # We require that the string starts with \s if self.digit(2) or (self.str_at(2) in "-+" and self.digit(3)): self.skip_char(3) while self.digit(0): self.skip_char() return True return False def spec(self): self.specletter = False if self.s[0:2] == "\\(" and self.prch(2) and self.prch(3): key = self.s[2:4] if key in Deroffer.g_specs_specletter: self.condputs(Deroffer.g_specs_specletter[key]) self.specletter = True elif key in Deroffer.g_specs: self.condputs(Deroffer.g_specs[key]) self.skip_char(4) return True elif self.s.startswith("\\%"): self.specletter = True self.skip_char(2) return True else: return False def esc(self): # We require that the string start with backslash c = self.s[1:2] if not c: return False if c in "eE": self.condputs("\\") elif c in "t": self.condputs("\t") elif c in "0~": self.condputs(" ") elif c in "|^&:": pass else: self.condputs(c) self.skip_char(2) return True def word(self): got_something = False while True: match = Deroffer.g_re_word.match(self.s) if not match: break got_something = True self.condputs(match.group(0)) self.skip_char(match.end(0)) # Consume all specials while self.spec(): if not self.specletter: break return got_something def text(self): while True: idx = self.s.find("\\") if idx == -1: self.condputs(self.s) self.s = "" break else: self.condputs(self.s[:idx]) self.skip_char(idx) if not self.esc_char_backslash(): self.condputs(self.str_at(0)) self.skip_char() return True def letter(self, idx): ch = self.str_at(idx) return ch.isalpha() or ch == "_" # underscore is used in C identifiers def digit(self, idx): ch = self.str_at(idx) return ch.isdigit() def number(self): match = Deroffer.g_re_number.match(self.s) if not match: return False else: self.condputs(match.group(0)) self.skip_char(match.end()) return True def esc_char_backslash(self): # Like esc_char, but we know the string starts with a backslash c = self.s[1:2] if c == '"': return self.comment() elif c == "f": return self.font() elif c == "s": return self.size() elif c in "hvwud": return self.numreq() elif c in "n*": return self.var() elif c == "(": return self.spec() else: return self.esc() def esc_char(self): if self.s[0:1] == "\\": return self.esc_char_backslash() return self.word() or self.number() def quoted_arg(self): if self.str_at(0) == '"': self.skip_char() while self.s and self.str_at(0) != '"': if not self.esc_char(): if self.s: self.condputs(self.str_at(0)) self.skip_char() return True else: return False def text_arg(self): # PCA: The deroff.c textArg() disallowed quotes at the start of an argument # I'm not sure if this was a bug or not got_something = False while True: match = Deroffer.g_re_not_backslash_or_whitespace.match(self.s) if match: # Output the characters in the match self.condputs(match.group(0)) self.skip_char(match.end(0)) got_something = True # Next is either an escape, or whitespace, or the end # If it's the whitespace or the end, we're done if not self.s or self.is_white(0): return got_something # Try an escape if not self.esc_char(): # Some busted escape? Just output it self.condputs(self.str_at(0)) self.skip_char() got_something = True def text_arg2(self): if not self.esc_char(): if self.s and not self.is_white(0): self.condputs(self.str_at(0)) self.skip_char() else: return False while True: if not self.esc_char(): if self.s and not self.is_white(0): self.condputs(self.str_at(0)) self.skip_char() else: return True # Macro functions def macro_sh(self): for header_str in [" SYNOPSIS", ' "SYNOPSIS', " ‹BERSICHT", ' "‹BERSICHT']: if self.s[2:].startswith(header_str): self.inheader = True break else: # Did not find a header string self.inheader = False self.nobody = True def macro_ss_ip(self): self.nobody = True return False def macro_i_ir(self): pass return False def macro_Nm(self): if self.s == "Nm\n": self.condputs(self.name) else: self.name = self.s[3:].strip() + " " return True def macro_close_bracket(self): self.refer = False return False def macro_ps(self): if self.is_white(2): self.pic = True self.condputs("\n") return True def macro_pe(self): if self.is_white(2): self.pic = False self.condputs("\n") return True def macro_ts(self): if self.is_white(2): self.tbl, self.tblstate = True, self.OPTIONS self.condputs("\n") return True def macro_t_and(self): if self.is_white(2): self.tbl, self.tblstate = True, self.FORMAT self.condputs("\n") return True def macro_te(self): if self.is_white(2): self.tbl = False self.condputs("\n") return True def macro_eq(self): if self.is_white(2): self.eqn = True self.condputs("\n") return True def macro_en(self): if self.is_white(2): self.eqn = False self.condputs("\n") return True def macro_r1(self): if self.is_white(2): self.refer2 = True self.condputs("\n") return True def macro_r2(self): if self.is_white(2): self.refer2 = False self.condputs("\n") return True def macro_de(self): macro = True self.condputs("\n") return True def macro_bl_vl(self): if self.is_white(2): self.inlist = True self.condputs("\n") return True def macro_bv(self): if self.str_at(2) == "L" and self.white(self.str_at(3)): self.inlist = True self.condputs("\n") return True def macro_le(self): if self.is_white(2): self.inlist = False self.condputs("\n") return True def macro_lp_pp(self): self.condputs("\n") return True def macro_ds(self): self.skip_char(2) self.skip_leading_whitespace() if self.str_at(0): # Split at whitespace comps = self.s.split(None, 2) if len(comps) is 2: name, value = comps value = value.rstrip() self.reg_table[name] = value self.condputs("\n") return True def macro_so_nx(self): # We always ignore include directives # deroff.c for some reason allowed this to fall through to the 'tr' case # I think that was just a bug so I won't replicate it return True def macro_tr(self): self.skip_char(2) self.skip_leading_whitespace() while self.s and self.str_at(0) != "\n": c = self.str_at(0) ns = self.str_at(1) self.skip_char(2) if not ns or ns == "\n": ns = " " self.tr_from += c self.tr_to += ns # Update our table, then swap in the slower tr-savvy condputs try: # Python2 self.tr = string.maketrans(self.tr_from, self.tr_to) except AttributeError: # Python3 self.tr = "".maketrans(self.tr_from, self.tr_to) self.condputs = self.condputs_tr return True def macro_sp(self): self.condputs("\n") return True def macro_other(self): self.condputs("\n") return True def request_or_macro(self): # s[0] is period or open single quote self.skip_char() s0 = self.s[1:2] if s0 == "\\": if self.str_at(1) == '"': self.condputs("\n") return True else: pass elif s0 == "[": self.refer = True self.condputs("\n") return True elif s0 == "]": self.refer = False self.skip_char() return self.text() elif s0 == ".": self.macro = False self.condputs("\n") return True self.nobody = False s0s1 = self.s[0:2] macro_func = Deroffer.g_macro_dict.get(s0s1, Deroffer.macro_other) if macro_func(self): return True if self.skipheaders and self.nobody: return True self.skip_leading_whitespace() while self.s and not self.is_white(0): self.skip_char() self.skip_leading_whitespace() while True: if not self.quoted_arg() and not self.text_arg(): if self.s: self.condputs(self.str_at(0)) self.skip_char() else: return True def request_or_macro2(self): self.skip_char() s0 = self.s[0:1] if s0 == "\\": if self.str_at(1) == '"': self.condputs("\n") return True else: pass elif s0 == "[": self.refer = True self.condputs("\n") return True elif s0 == "]": self.refer = False self.skip_char() return self.text() elif s0 == ".": self.macro = False self.condputs("\n") return True self.nobody = False s0s1 = self.s[0:2] if s0s1 == "SH": for header_str in [" SYNOPSIS", ' "SYNOPSIS', " ‹BERSICHT", ' "‹BERSICHT']: if self.s[2:].startswith(header_str): self.inheader = True break else: # Did not find a header string self.inheader = False self.nobody = True elif s0s1 in ["SS", "IP", "H "]: self.nobody = True elif s0s1 in ["I ", "IR", "IB", "B ", "BR", "BI", "R ", "RB", "RI", "AB"]: pass elif s0s1 in ["] "]: self.refer = False elif s0s1 in ["PS"]: if self.is_white(2): self.pic = True self.condputs("\n") return True elif s0s1 in ["PE"]: if self.is_white(2): self.pic = False self.condputs("\n") return True elif s0s1 in ["TS"]: if self.is_white(2): self.tbl, self.tblstate = True, self.OPTIONS self.condputs("\n") return True elif s0s1 in ["T&"]: if self.is_white(2): self.tbl, self.tblstate = True, self.FORMAT self.condputs("\n") return True elif s0s1 in ["TE"]: if self.is_white(2): self.tbl = False self.condputs("\n") return True elif s0s1 in ["EQ"]: if self.is_white(2): self.eqn = True self.condputs("\n") return True elif s0s1 in ["EN"]: if self.is_white(2): self.eqn = False self.condputs("\n") return True elif s0s1 in ["R1"]: if self.is_white(2): self.refer2 = True self.condputs("\n") return True elif s0s1 in ["R2"]: if self.is_white(2): self.refer2 = False self.condputs("\n") return True elif s0s1 in ["de"]: macro = True self.condputs("\n") return True elif s0s1 in ["BL", "VL", "AL", "LB", "RL", "ML", "DL"]: if self.is_white(2): self.inlist = True self.condputs("\n") return True elif s0s1 in ["BV"]: if self.str_at(2) == "L" and self.white(self.str_at(3)): self.inlist = True self.condputs("\n") return True elif s0s1 in ["LE"]: if self.is_white(2): self.inlist = False self.condputs("\n") return True elif s0s1 in ["LP", "PP", "P\n"]: self.condputs("\n") return True elif s0s1 in ["ds"]: self.skip_char(2) self.skip_leading_whitespace() if self.str_at(0): # Split at whitespace comps = self.s.split(None, 2) if len(comps) is 2: name, value = comps value = value.rstrip() self.reg_table[name] = value self.condputs("\n") return True elif s0s1 in ["so", "nx"]: # We always ignore include directives # deroff.c for some reason allowed this to fall through to the 'tr' case # I think that was just a bug so I won't replicate it return True elif s0s1 in ["tr"]: self.skip_char(2) self.skip_leading_whitespace() while self.s and self.str_at(0) != "\n": c = self.str_at(0) ns = self.str_at(1) self.skip_char(2) if not ns or ns == "\n": ns = " " self.tr_from += c self.tr_to += ns # Update our table, then swap in the slower tr-savvy condputs try: # Python2 self.tr = string.maketrans(self.tr_from, self.tr_to) except AttributeError: # Python3 self.tr = "".maketrans(self.tr_from, self.tr_to) self.condputs = self.condputs_tr return True elif s0s1 in ["sp"]: self.condputs("\n") return True else: self.condputs("\n") return True if self.skipheaders and self.nobody: return True self.skip_leading_whitespace() while self.s and not self.is_white(0): self.skip_char() self.skip_leading_whitespace() while True: if not self.quoted_arg() and not self.text_arg(): if self.s: self.condputs(self.str_at(0)) self.skip_char() else: return True def do_tbl(self): if self.tblstate == self.OPTIONS: while self.s and self.str_at(0) != ";" and self.str_at(0) != "\n": self.skip_leading_whitespace() if not self.str_at(0).isalpha(): # deroff.c has a bug where it can loop forever here...we try to work around it self.skip_char() else: # Parse option option = self.s arg = "" idx = 0 while option[idx : idx + 1].isalpha(): idx += 1 if option[idx : idx + 1] == "(": option = option[:idx] self.s = self.s[idx + 1 :] arg = self.s else: self.s = "" if arg: idx = arg.find(")") if idx != -1: arg = arg[:idx] self.s = self.s[idx + 1 :] else: # self.skip_char() pass if option.lower() == "tab": self.tblTab = arg[0:1] self.tblstate = self.FORMAT self.condputs("\n") elif self.tblstate == self.FORMAT: while self.s and self.str_at(0) != "." and self.str_at(0) != "\n": self.skip_leading_whitespace() if self.str_at(0): self.skip_char() if self.str_at(0) == ".": self.tblstate = self.DATA self.condputs("\n") elif self.tblstate == self.DATA: if self.tblTab: self.s = self.s.replace(self.tblTab, "\t") self.text() return True def do_line(self): if self.s[0:1] in ".'": if not self.request_or_macro(): return False elif self.tbl: self.do_tbl() else: self.text() return True def deroff(self, str): lines = str.split("\n") for line in lines: self.s = line + "\n" if not self.do_line(): break # self.putchar('\n') def deroff_files(files): for arg in files: sys.stderr.write(arg + "\n") if arg.endswith(".gz"): f = gzip.open(arg, "r") str = f.read() if IS_PY3: str = str.decode("latin-1") else: f = open(arg, "r") str = f.read() d = Deroffer() d.deroff(str) d.flush_output(sys.stdout) f.close() if __name__ == "__main__": import gzip paths = sys.argv[1:] if True: deroff_files(paths) else: import cProfile, profile, pstats profile.run("deroff_files(paths)", "fooprof") p = pstats.Stats("fooprof") p.sort_stats("time").print_stats(100) # p.sort_stats('calls').print_callers(.5, 'startswith')