Edit File: Latex.py
class Doc2Latex: sizes = ('tiny', 'scriptsize', 'footnotesize', 'small', 'normalsize', 'large', 'Large', 'LARGE', 'huge', 'Huge') def __init__(self, mod, doc, node): self.mod = mod self.doc = doc self.encoder = Encoder(mod) self.encode = self.encoder.encode self.node = node self.out = [] self.ms = [] self.mode = None self.cur_style = 'rm' self.cur_size = list(self.sizes).index('normalsize') self.document_lang = None self.document_title = None self.document_metas = [] self.latex_list_nesting = 0 self.latex_mode = 0 self.noindent = 0 self.authors = [] node.accept(self) def _visit_children(self, node): E = self.mod.ReportedError for ch in node.children: try: ch.accept(self) except E: pass def abs_size(self, size, node): osize = self.cur_size si = size if si < 0: si = 0 elif si >= len(self.sizes): si = len(self.sizes) - 1 self.append('{\\%s ' % self.sizes[si]) self.cur_size = si if self.cur_style != 'rm': self.style(self.cur_style, node) else: node.arg_accept(self) self.append('}') self.cur_size = osize def append(self, x): self.out.append(x) def changed_size(self, delta, node): self.abs_size(self.cur_size + delta, node) def error(self, msg, *args, **kwds): msg = 'Doc2Latex: ' + msg self.doc.env.error(msg, *args, **kwds) def get_latex(self): return ''.join(self.out) def no_children(self, node): if node.children: self.error('No children allowed for %r.' % node.tag, node.children[0]) def style(self, style, node): self.append('{\\%s ' % style) ostyle = self.cur_style self.cur_style = style node.arg_accept(self) self.cur_style = ostyle if style == 'em': self.append('\\/}') else: self.append('\\/}') def visit_a(self, node): pass def visit_author(self, node): self.authors.append(node.arg) self.no_children(node) def visit_big(self, node): self.changed_size(1, node) def visit_block(self, node): self._visit_children(node) def visit_blockquote(self, node): self.append('\\begin{quote}\n') self.latex_list_nesting += 1 node.arg_accept(self) self.latex_list_nesting -= 1 self.append('\\end{quote}\n') char_table = { 'nbsp': '~', } def visit_char(self, node): char = node.arg.strip() c = self.char_table.get(char) if c is None: self.error('No such character: %r.' % char, node) c = char self.append(c) def visit_code(self, node): self.style('tt', node) def visit_comment(self, node): pass def visit_dd(self, node): self.ms.append('dd') step = 24 ls = (self.ms.count('dd') + self.latex_list_nesting) * step self.append('{\\par \\noindent \\leftskip = %d pt ' % ls) for i, v in enumerate(('i', 'ii', 'iii', 'iv', 'v', 'vi')[self.latex_list_nesting:]): self.append(' \\leftmargin%s = %d pt ' % (v, ls + (i + 1) * step)) node.arg_accept(self) self.append('\\par}\n') self.ms.pop() def visit_default(self, node): self.error('I don\'t know what to generate for the tag %r.' % node.tag, node) def visit_define(self, node): # xxx self._visit_children(node) def visit_dl(self, node): if self.ms and self.ms[-1] == 'dt': self.visit_dd(node) else: self.append('{\\par \\noindent\n') self._visit_children(node) self.append('\\par}\n') def visit_dt(self, node): self.ms.append('dt') self.append('{\\par \\pagebreak[%f] \\noindent \\hangindent = 12 pt \\hangafter = 1 \n' % ( 3.4-0.1*len(self.ms), )) node.arg_accept(self) self.append('\\par}\n') self.ms.pop() def visit_document(self, node): self._visit_children(node) def visit_document_lang(self, node): if self.document_lang is not None: self.error('Duplicate document lang directive.', node) self.document_lang = node def visit_document_title(self, node): if self.document_title is not None: self.error('Duplicate document title directive.', node) self.document_title = node def visit_exdefs(self, node): self.symplace = {} for ch in node.children: syms = [x.strip() for x in ch.arg.split(',')] for sym in syms: self.symplace[sym] = ch.tag def visit_em(self, node): self.style('em', node) def visit_enumerate(self, node): self.append('\\begin{enumerate}\n') for c in node.children: self.append('\\item ') c.accept(self) self.append('\\end{enumerate}\n') def visit_h0(self, node): # Not a html header, # we may treat this as 'new page' or chapter here # and some larger divisor in html. self.visit_hx(node) def visit_h1(self, node): self.visit_hx(node) def visit_h2(self, node): self.visit_hx(node) def visit_h3(self, node): self.visit_hx(node) def visit_h4(self, node): self.visit_hx(node) def visit_h5(self, node): self.visit_hx(node) def visit_h6(self, node): self.visit_hx(node) def visit_hx(self, node): n = int(node.tag[1:]) if self.mode == 'man_page': self.append('{\\par \\pagebreak[%d] \\vskip %d pt \\noindent\n' % ( [4, 3, 3, 2, 2, 1, 1][n], (12 - 2 * n))) self.abs_size(len(self.sizes) - n - 2, self.mod.node_of_taci( '', '', [self.mod.node_of_taci('strong', node.arg, node.children)])) self.append('\\par \\vskip %d pt\n} \\noindent\n' % (12 - 2 * n)) self.noindent = 1 # self.append('\\end{list}\n') else: self.append('\\%s{' % self.mod.section_table[n]) node.arg_accept(self) self.append('}\n') def visit_itemize(self, node): self.append('\\begin{itemize}\n') self.latex_list_nesting += 1 for c in node.children: self.append('\\item ') c.accept(self) self.latex_list_nesting -= 1 self.append('\\end{itemize}\n') def visit_latex(self, node): self.latex_mode += 1 node.arg_accept(self) self.latex_mode -= 1 def visit_li(self, node): self.append('\\item ') node.arg_accept(self) def visit_link_to(self, node): # xxx name = node.arg self.append(' {\\em ') if not node.children: self.append(self.encode(name)) else: self._visit_children(node) self.append('\\/}') def visit_link_to_extern(self, node): # xxx name = node.arg doc = node.children[0].arg children = node.children[1:] self.append(' {\\em ') if not children: self.append(self.encode(name)) else: for ch in children: ch.accept(self) self.append('\\/}') def visit_link_to_local(self, node): # xxx name = node.arg self.append(' {\\em ') if not node.children: self.append(self.encode(name)) else: self._visit_children(node) self.append('\\/}') def visit_link_to_unresolved(self, node): # xxx name = node.arg self.append(' {\\em ') if not node.children: self.append(self.encode(name)) else: self._visit_children(node) self.append('\\/}') def visit_literal_block(self, node): self.append('{\\ttfamily \\raggedright \\noindent') self.encoder.literal_block = 1 self.encoder.insert_none_breaking_blanks = 1 node.arg_accept(self) self.encoder.literal_block = 0 self.encoder.insert_none_breaking_blanks = 0 self.append('}\n') def visit_lp(self, node): self.latex_mode += 1 self.visit_paragraph(node) self.latex_mode -= 1 def visit_man_page_mode(self, node): omode = self.mode self.mode = 'man_page' self._visit_children(node) self.mode = omode def visit_meta(self, node): self.document_metas.append(node) def visit_ol(self, node): self.append('\\begin{enumerate}\n') self._visit_children(node) self.append('\\end{enumerate}\n') def visit_p(self, node): self.visit_paragraph(node) def visit_paragraph(self, node): self.append('{\\par ') if self.noindent: self.append('\\parindent = 0 pt ') self.noindent = 0 self.append('\n') node.arg_accept(self) self.append(' \\par}\n') def visit_pre(self, node): # I couldn't use Latex verbatim environment # since it didn't respected leftskip # so the environment became misplaced (within dd) text = node.arg.strip() if text: text += '\n' text = text + node.get_text() text = text.expandtabs() lines = text.split('\n') if lines and not lines[-1]: lines.pop() if not lines: return self.append('\\par\n') self.encoder.insert_none_breaking_blanks += 1 self.encoder.literal += 1 first = 1 self.append('{\\tt{%s}}\n' % self.encode(lines[0])) for line in lines[1:]: self.append( '{ \\par \\parindent = 0 pt \\parskip = 0 pt \\tt{%s} }\n' % self.encode(line)) self.encoder.insert_none_breaking_blanks -= 1 self.encoder.literal -= 1 self.append('\\par\n') def visit_small(self, node): self.changed_size(-1, node) def visit_spc_colonkind(self, node): self.append('~{\\bf :} ') def visit_spc_mapsto(self, node): self.append(' \\(\mapsto \\) ') def visit_string(self, node): self._visit_children(node) def visit_strong(self, node): self.style('bf', node) def visit_sub(self, node): self.append('\\raisebox{-.6ex}{') self.changed_size(-1, node) self.append('}') def visit_sup(self, node): self.append('\\raisebox{.6ex}{') self.changed_size(-1, node) self.append('}') def visit_symbol(self, node): self.visit_text(node) def visit_table(self, node): Table(self, node) def visit_text(self, node): if self.latex_mode: self.append(node.arg) else: text = node.arg text = self.encoder.encode(text) self.append(text) self._visit_children(node) def visit_to_document_only(self, node): self._visit_children(node) def visit_to_html_only(self, node): pass def visit_to_tester_only(self, node): pass def visit_tt(self, node): self.append('\\texttt{') self.encoder.literal = 1 node.arg_accept(self) self.encoder.literal = 0 self.append('}') def visit_ul(self, node): self.append('\\begin{itemize}\n') self._visit_children(node) self.append('\\end{itemize}\n') def visit_var(self, node): self.style('em', node) class Table(Doc2Latex): many_hlines = 1 # Use extra many hlines.. looks good, a matter of taste. def __init__(self, d2l, node): self.d2l = d2l self.__dict__.update(d2l.__dict__) self.node = node self.out = [] self.rows = [] self.colwidth = None self._visit_children(node) maxcols = 0 for row in self.rows: if len(row.columns) > maxcols: maxcols = len(row.columns) if not maxcols: return # Empty table if self.colwidth is not None: if not len(self.colwidth) == maxcols: self.error("Wrong number of column width specifications (%d) vs\n" " max columns in table (%d)." % ( len(self.colwidth), maxcols), node) else: self.colwidth = [1.0/maxcols]*maxcols ap = self.d2l.append ap('\n\\begin{longtable}[c]{|%s|}\n' % ('|'.join(['p{%.2g\\linewidth}' % cw for cw in self.colwidth]))) if self.many_hlines: ap('\\hline\n') for row in self.rows: for col in row.columns: ap(''.join(col.data)) if col is row.columns[-1]: if self.many_hlines: ap('\\\\\n') ap('\\hline\n') else: if row is not self.rows[-1]: ap('\\\\\n') else: ap('&\n') if row.is_head: ap('\\hline\n') ap('\\endhead\n') ap('\n\\end{longtable}\n') def visit_colgroup(self, node): colwidth = [] for c in node.children: if c.tag != "col_width": self.error('Unrecognized colgroup option: %r' % c.tag, c) cg = c.arg if cg.endswith('%'): cg = cg[:-1] cg = float(cg)/100.0 else: cg = float(cg) colwidth.append(cg) self.colwidth = colwidth def visit_options(self, node): pass def visit_thead(self, node): self._visit_children(node) self.rows[-1].is_head = 1 def visit_tr(self, node): self.rows.append(Row(self, node)) class Row(Doc2Latex): is_head = 0 def __init__(self, table, node): self.__dict__.update(table.__dict__) self.columns = [] self._visit_children(node) def visit_td(self, node): self.columns.append(Column(self, node)) def visit_th(self, node): self.columns.append(Column(self, node)) class Column(Doc2Latex): def __init__(self, row, node): self.__dict__.update(row.__dict__) self.data = [] self.append = self.data.append node.arg_accept(self) class Babel: """Language specifics for LaTeX.""" # country code by a.schlock. # partly manually converted from iso and babel stuff, dialects and some _ISO639_TO_BABEL = { 'no': 'norsk', # XXX added by hand ( forget about nynorsk?) 'gd': 'scottish', # XXX added by hand 'hu': 'magyar', # XXX added by hand 'pt': 'portuguese', # XXX added by hand 'sl': 'slovenian', 'af': 'afrikaans', 'bg': 'bulgarian', 'br': 'breton', 'ca': 'catalan', 'cs': 'czech', 'cy': 'welsh', 'da': 'danish', 'fr': 'french', # french, francais, canadien, acadian 'de': 'ngerman', # XXX rather than german # ngerman, naustrian, german, germanb, austrian 'el': 'greek', 'en': 'english', # english, USenglish, american, UKenglish, british, canadian 'eo': 'esperanto', 'es': 'spanish', 'et': 'estonian', 'eu': 'basque', 'fi': 'finnish', 'ga': 'irish', 'gl': 'galician', 'he': 'hebrew', 'hr': 'croatian', 'hu': 'hungarian', 'is': 'icelandic', 'it': 'italian', 'la': 'latin', 'nl': 'dutch', 'pl': 'polish', 'pt': 'portuguese', 'ro': 'romanian', 'ru': 'russian', 'sk': 'slovak', 'sr': 'serbian', 'sv': 'swedish', 'tr': 'turkish', 'uk': 'ukrainian' } def __init__(self, mod): self.language = mod.language_code self.re = mod.re # pdflatex does not produce double quotes for ngerman in tt. self.double_quote_replacment = None if self.re.search('^de', self.language): #self.quotes = ("\"`", "\"'") self.quotes = ('{\\glqq}', '{\\grqq}') self.double_quote_replacment = "{\\dq}" else: self.quotes = ("``", "''") self.quote_index = 0 def next_quote(self): q = self.quotes[self.quote_index] self.quote_index = (self.quote_index+1) % 2 return q def quote_quotes(self, text): t = None for part in text.split('"'): if t == None: t = part else: t += self.next_quote() + part return t def double_quotes_in_tt(self, text): if not self.double_quote_replacment: return text return text.replace('"', self.double_quote_replacment) def get_language(self): if self.language in self._ISO639_TO_BABEL: return self._ISO639_TO_BABEL[self.language] else: # support dialects. l = self.language.split("_")[0] if l in self._ISO639_TO_BABEL: return self._ISO639_TO_BABEL[l] return None class Encoder: literal_block = 0 literal = 0 mathmode = 0 verbatim = 0 insert_newline = 0 mbox_newline = 0 insert_none_breaking_blanks = 0 latex_equivalents = { '\u00A0': '~', '\u2013': '{--}', '\u2014': '{---}', '\u2018': '`', '\u2019': '\'', '\u201A': ',', '\u201C': '``', '\u201D': '\'\'', '\u201E': ',,', '\u2020': '{\\dag}', '\u2021': '{\\ddag}', '\u2026': '{\\dots}', '\u2122': '{\\texttrademark}', '\u21d4': '{$\\Leftrightarrow$}', } def __init__(self, mod): self.mod = mod self.re = mod.re self.babel = Babel(mod) self.font_encoding = mod.font_encoding self.latex_encoding = self.to_latex_encoding(mod.output_encoding) def to_latex_encoding(self, docutils_encoding): """ Translate docutils encoding name into latex's. Default fallback method is remove "-" and "_" chars from docutils_encoding. """ tr = {"iso-8859-1": "latin1", # west european "iso-8859-2": "latin2", # east european "iso-8859-3": "latin3", # esperanto, maltese "iso-8859-4": "latin4", # north european,scandinavian, baltic "iso-8859-5": "iso88595", # cyrillic (ISO) "iso-8859-9": "latin5", # turkish "iso-8859-15": "latin9", # latin9, update to latin1. "mac_cyrillic": "maccyr", # cyrillic (on Mac) "windows-1251": "cp1251", # cyrillic (on Windows) "koi8-r": "koi8-r", # cyrillic (Russian) "koi8-u": "koi8-u", # cyrillic (Ukrainian) "windows-1250": "cp1250", # "windows-1252": "cp1252", # "us-ascii": "ascii", # ASCII (US) # unmatched encodings # "": "applemac", # "": "ansinew", # windows 3.1 ansi # "": "ascii", # ASCII encoding for the range 32--127. # "": "cp437", # dos latine us # "": "cp850", # dos latin 1 # "": "cp852", # dos latin 2 # "": "decmulti", # "": "latin10", # "iso-8859-6": "" # arabic # "iso-8859-7": "" # greek # "iso-8859-8": "" # hebrew # "iso-8859-10": "" # latin6, more complete iso-8859-4 } if docutils_encoding.lower() in tr: return tr[docutils_encoding.lower()] return docutils_encoding.translate(str.maketrans("", "", "_-")).lower() def unicode_to_latex(self, text): # see LaTeX codec # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/252124 # Only some special chracters are translated, for documents with many # utf-8 chars one should use the LaTeX unicode package. for uchar in list(self.latex_equivalents.keys()): text = text.replace(uchar, self.latex_equivalents[uchar]) return text def encode(self, text): """ Encode special characters in `text` & return. # $ % & ~ _ ^ \ { } Escaping with a backslash does not help with backslashes, ~ and ^. < > are only available in math-mode or tt font. (really ?) $ starts math- mode. AND quotes: """ if self.verbatim: return text # compile the regexps once. do it here so one can see them. # # first the braces. if 'encode_re_braces' not in self.__dict__: self.encode_re_braces = self.re.compile(r'([{}])') text = self.encode_re_braces.sub(r'{\\\1}', text) if 'encode_re_bslash' not in self.__dict__: # find backslash: except in the form '{\{}' or '{\}}'. self.encode_re_bslash = self.re.compile(r'(?<!{)(\\)(?![{}]})') # then the backslash: except in the form from line above: # either '{\{}' or '{\}}'. text = self.encode_re_bslash.sub(r'{\\textbackslash}', text) # then dollar text = text.replace("$", '{\\$}') if not (self.literal_block or self.literal or self.mathmode): # the vertical bar: in mathmode |,\vert or \mid # in textmode \textbar text = text.replace("|", '{\\textbar}') text = text.replace("<", '{\\textless}') text = text.replace(">", '{\\textgreater}') # then text = text.replace("&", '{\\&}') # the ^: # * verb|^| does not work in mbox. # * mathmode has wedge. hat{~} would also work. # text = text.replace("^", '{\\ensuremath{^\\wedge}}') text = text.replace("^", '{\\textasciicircum}') text = text.replace("%", '{\\%}') text = text.replace("#", '{\\#}') text = text.replace("~", '{\\textasciitilde}') # Separate compound characters, e.g. "--" to "-{}-". (The # actual separation is done later; see below.) separate_chars = '-' if self.literal_block or self.literal: # In monospace-font, we also separate ",,", "``" and "''" # and some other characters which can't occur in # non-literal text. separate_chars += ',`\'"<>' # pdflatex does not produce doublequotes for ngerman. text = self.babel.double_quotes_in_tt(text) if self.font_encoding == 'OT1': # We're using OT1 font-encoding and have to replace # underscore by underlined blank, because this has # correct width. text = text.replace('_', '{\\underline{ }}') # And the tt-backslash doesn't work in OT1, so we use # a mirrored slash. text = text.replace('\\textbackslash', '\\reflectbox{/}') else: text = text.replace('_', '{\\_}') else: text = self.babel.quote_quotes(text) text = text.replace("_", '{\\_}') for char in separate_chars * 2: # Do it twice ("* 2") becaues otherwise we would replace # "---" by "-{}--". text = text.replace(char + char, char + '{}' + char) if self.insert_newline or self.literal_block: # Insert a blank before the newline, to avoid # ! LaTeX Error: There's no line here to end. text = text.replace("\n", '~\\\\\n') elif self.mbox_newline: if self.literal_block: closings = "}" * len(self.literal_block_stack) openings = "".join(self.literal_block_stack) else: closings = "" openings = "" text = text.replace( "\n", "%s}\\\\\n\\mbox{%s" % (closings, openings)) # lines starting with "[" give errors. text = text.replace('[', '{[}') if self.insert_none_breaking_blanks: text = text.replace(' ', '~') if self.latex_encoding != 'utf8': text = self.unicode_to_latex(text) return text class _GLUECLAMP_: _imports_ = ( '_parent:SpecNodes', '_parent.SpecNodes:node_of_taci', '_parent.Main:ReportedError', '_root:re', ) font_encoding = '' double_quote_replacment = '' language_code = '' output_encoding = '' section_table = { 0: 'part', 1: 'chapter', 2: 'section', 3: 'subsection', 4: 'subsubsection', 5: 'paragraph', 6: 'subparagraph' } def doc2text(self, doc, node): d2l = Doc2Latex(self, doc, node) return d2l.get_latex() def doc2filer(self, doc, node, name, dir, opts, IO): text = self.doc2text(doc, node) path = IO.path.join(dir, '%s.tex' % name) node = self.node_of_taci('write_file', path, [ self.node_of_taci('text', text)]) return node