ok
Mini Shell
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
Zerion Mini Shell 1.0