1 #! /usr/bin/env python

     2 

     3 # Convert GNU texinfo files into HTML, one file per node.

     4 # Based on Texinfo 2.14.

     5 # Usage: texi2html [-d] [-d] [-c] inputfile outputdirectory

     6 # The input file must be a complete texinfo file, e.g. emacs.texi.

     7 # This creates many files (one per info node) in the output directory,

     8 # overwriting existing files of the same name.  All files created have

     9 # ".html" as their extension.

    10 

    11 

    12 # XXX To do:

    13 # - handle @comment*** correctly

    14 # - handle @xref {some words} correctly

    15 # - handle @ftable correctly (items aren't indexed?)

    16 # - handle @itemx properly

    17 # - handle @exdent properly

    18 # - add links directly to the proper line from indices

    19 # - check against the definitive list of @-cmds; we still miss (among others):

    20 # - @defindex (hard)

    21 # - @c(omment) in the middle of a line (rarely used)

    22 # - @this* (not really needed, only used in headers anyway)

    23 # - @today{} (ever used outside title page?)

    24 

    25 # More consistent handling of chapters/sections/etc.

    26 # Lots of documentation

    27 # Many more options:

    28 #       -top    designate top node

    29 #       -links  customize which types of links are included

    30 #       -split  split at chapters or sections instead of nodes

    31 #       -name   Allow different types of filename handling. Non unix systems

    32 #               will have problems with long node names

    33 #       ...

    34 # Support the most recent texinfo version and take a good look at HTML 3.0

    35 # More debugging output (customizable) and more flexible error handling

    36 # How about icons ?

    37 

    38 # rpyron 2002-05-07

    39 # Robert Pyron <rpyron@alum.mit.edu>

    40 # 1. BUGFIX: In function makefile(), strip blanks from the nodename.

    41 #    This is necesary to match the behavior of parser.makeref() and

    42 #    parser.do_node().

    43 # 2. BUGFIX fixed KeyError in end_ifset (well, I may have just made

    44 #    it go away, rather than fix it)

    45 # 3. BUGFIX allow @menu and menu items inside @ifset or @ifclear

    46 # 4. Support added for:

    47 #       @uref        URL reference

    48 #       @image       image file reference (see note below)

    49 #       @multitable  output an HTML table

    50 #       @vtable

    51 # 5. Partial support for accents, to match MAKEINFO output

    52 # 6. I added a new command-line option, '-H basename', to specify

    53 #    HTML Help output. This will cause three files to be created

    54 #    in the current directory:

    55 #       `basename`.hhp  HTML Help Workshop project file

    56 #       `basename`.hhc  Contents file for the project

    57 #       `basename`.hhk  Index file for the project

    58 #    When fed into HTML Help Workshop, the resulting file will be

    59 #    named `basename`.chm.

    60 # 7. A new class, HTMLHelp, to accomplish item 6.

    61 # 8. Various calls to HTMLHelp functions.

    62 # A NOTE ON IMAGES: Just as 'outputdirectory' must exist before

    63 # running this program, all referenced images must already exist

    64 # in outputdirectory.

    65 

    66 import os

    67 import sys

    68 import string

    69 import re

    70 

    71 MAGIC = '\\input texinfo'

    72 

    73 cmprog = re.compile('^@([a-z]+)([ \t]|$)')        # Command (line-oriented)

    74 blprog = re.compile('^[ \t]*$')                   # Blank line

    75 kwprog = re.compile('@[a-z]+')                    # Keyword (embedded, usually

    76                                                   # with {} args)

    77 spprog = re.compile('[\n@{}&<>]')                 # Special characters in

    78                                                   # running text

    79                                                   #

    80                                                   # menu item (Yuck!)

    81 miprog = re.compile('^\* ([^:]*):(:|[ \t]*([^\t,\n.]+)([^ \t\n]*))[ \t\n]*')

    82 #                   0    1     1 2        3          34         42        0

    83 #                         -----            ----------  ---------

    84 #                                 -|-----------------------------

    85 #                    -----------------------------------------------------

    86 

    87 

    88 

    89 

    90 class HTMLNode:

    91     """Some of the parser's functionality is separated into this class.

    92 

    93     A Node accumulates its contents, takes care of links to other Nodes

    94     and saves itself when it is finished and all links are resolved.

    95     """

    96 

    97     DOCTYPE = '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">'

    98 

    99     type = 0

   100     cont = ''

   101     epilogue = '</BODY></HTML>\n'

   102 

   103     def __init__(self, dir, name, topname, title, next, prev, up):

   104         self.dirname = dir

   105         self.name = name

   106         if topname:

   107             self.topname = topname

   108         else:

   109             self.topname = name

   110         self.title = title

   111         self.next = next

   112         self.prev = prev

   113         self.up = up

   114         self.lines = []

   115 

   116     def write(self, *lines):

   117         map(self.lines.append, lines)

   118 

   119     def flush(self):

   120         fp = open(self.dirname + '/' + makefile(self.name), 'w')

   121         fp.write(self.prologue)

   122         fp.write(self.text)

   123         fp.write(self.epilogue)

   124         fp.close()

   125 

   126     def link(self, label, nodename, rel=None, rev=None):

   127         if nodename:

   128             if nodename.lower() == '(dir)':

   129                 addr = '../dir.html'

   130                 title = ''

   131             else:

   132                 addr = makefile(nodename)

   133                 title = ' TITLE="%s"' % nodename

   134             self.write(label, ': <A HREF="', addr, '"', \

   135                        rel and (' REL=' + rel) or "", \

   136                        rev and (' REV=' + rev) or "", \

   137                        title, '>', nodename, '</A>  \n')

   138 

   139     def finalize(self):

   140         length = len(self.lines)

   141         self.text = ''.join(self.lines)

   142         self.lines = []

   143         self.open_links()

   144         self.output_links()

   145         self.close_links()

   146         links = ''.join(self.lines)

   147         self.lines = []

   148         self.prologue = (

   149             self.DOCTYPE +

   150             '\n<HTML><HEAD>\n'

   151             '  <!-- Converted with texi2html and Python -->\n'

   152             '  <TITLE>' + self.title + '</TITLE>\n'

   153             '  <LINK REL=Next HREF="'

   154                 + makefile(self.next) + '" TITLE="' + self.next + '">\n'

   155             '  <LINK REL=Previous HREF="'

   156                 + makefile(self.prev) + '" TITLE="' + self.prev  + '">\n'

   157             '  <LINK REL=Up HREF="'

   158                 + makefile(self.up) + '" TITLE="' + self.up  + '">\n'

   159             '</HEAD><BODY>\n' +

   160             links)

   161         if length > 20:

   162             self.epilogue = '<P>\n%s</BODY></HTML>\n' % links

   163 

   164     def open_links(self):

   165         self.write('<HR>\n')

   166 

   167     def close_links(self):

   168         self.write('<HR>\n')

   169 

   170     def output_links(self):

   171         if self.cont != self.next:

   172             self.link('  Cont', self.cont)

   173         self.link('  Next', self.next, rel='Next')

   174         self.link('  Prev', self.prev, rel='Previous')

   175         self.link('  Up', self.up, rel='Up')

   176         if self.name <> self.topname:

   177             self.link('  Top', self.topname)

   178 

   179 

   180 class HTML3Node(HTMLNode):

   181 

   182     DOCTYPE = '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML Level 3//EN//3.0">'

   183 

   184     def open_links(self):

   185         self.write('<DIV CLASS=Navigation>\n <HR>\n')

   186 

   187     def close_links(self):

   188         self.write(' <HR>\n</DIV>\n')

   189 

   190 

   191 class TexinfoParser:

   192 

   193     COPYRIGHT_SYMBOL = "©"

   194     FN_ID_PATTERN = "(%(id)s)"

   195     FN_SOURCE_PATTERN = '<A NAME=footnoteref%(id)s' \

   196                         ' HREF="#footnotetext%(id)s">' \

   197                         + FN_ID_PATTERN + '</A>'

   198     FN_TARGET_PATTERN = '<A NAME=footnotetext%(id)s' \

   199                         ' HREF="#footnoteref%(id)s">' \

   200                         + FN_ID_PATTERN + '</A>\n%(text)s<P>\n'

   201     FN_HEADER = '\n<P>\n<HR NOSHADE SIZE=1 WIDTH=200>\n' \

   202                 '<STRONG><EM>Footnotes</EM></STRONG>\n<P>'

   203 

   204 

   205     Node = HTMLNode

   206 

   207     # Initialize an instance

   208     def __init__(self):

   209         self.unknown = {}       # statistics about unknown @-commands

   210         self.filenames = {}     # Check for identical filenames

   211         self.debugging = 0      # larger values produce more output

   212         self.print_headers = 0  # always print headers?

   213         self.nodefp = None      # open file we're writing to

   214         self.nodelineno = 0     # Linenumber relative to node

   215         self.links = None       # Links from current node

   216         self.savetext = None    # If not None, save text head instead

   217         self.savestack = []     # If not None, save text head instead

   218         self.htmlhelp = None    # html help data

   219         self.dirname = 'tmp'    # directory where files are created

   220         self.includedir = '.'   # directory to search @include files

   221         self.nodename = ''      # name of current node

   222         self.topname = ''       # name of top node (first node seen)

   223         self.title = ''         # title of this whole Texinfo tree

   224         self.resetindex()       # Reset all indices

   225         self.contents = []      # Reset table of contents

   226         self.numbering = []     # Reset section numbering counters

   227         self.nofill = 0         # Normal operation: fill paragraphs

   228         self.values={'html': 1} # Names that should be parsed in ifset

   229         self.stackinfo={}       # Keep track of state in the stack

   230         # XXX The following should be reset per node?!

   231         self.footnotes = []     # Reset list of footnotes

   232         self.itemarg = None     # Reset command used by @item

   233         self.itemnumber = None  # Reset number for @item in @enumerate

   234         self.itemindex = None   # Reset item index name

   235         self.node = None

   236         self.nodestack = []

   237         self.cont = 0

   238         self.includedepth = 0

   239 

   240     # Set htmlhelp helper class

   241     def sethtmlhelp(self, htmlhelp):

   242         self.htmlhelp = htmlhelp

   243 

   244     # Set (output) directory name

   245     def setdirname(self, dirname):

   246         self.dirname = dirname

   247 

   248     # Set include directory name

   249     def setincludedir(self, includedir):

   250         self.includedir = includedir

   251 

   252     # Parse the contents of an entire file

   253     def parse(self, fp):

   254         line = fp.readline()

   255         lineno = 1

   256         while line and (line[0] == '%' or blprog.match(line)):

   257             line = fp.readline()

   258             lineno = lineno + 1

   259         if line[:len(MAGIC)] <> MAGIC:

   260             raise SyntaxError, 'file does not begin with %r' % (MAGIC,)

   261         self.parserest(fp, lineno)

   262 

   263     # Parse the contents of a file, not expecting a MAGIC header

   264     def parserest(self, fp, initial_lineno):

   265         lineno = initial_lineno

   266         self.done = 0

   267         self.skip = 0

   268         self.stack = []

   269         accu = []

   270         while not self.done:

   271             line = fp.readline()

   272             self.nodelineno = self.nodelineno + 1

   273             if not line:

   274                 if accu:

   275                     if not self.skip: self.process(accu)

   276                     accu = []

   277                 if initial_lineno > 0:

   278                     print '*** EOF before @bye'

   279                 break

   280             lineno = lineno + 1

   281             mo = cmprog.match(line)

   282             if mo:

   283                 a, b = mo.span(1)

   284                 cmd = line[a:b]

   285                 if cmd in ('noindent', 'refill'):

   286                     accu.append(line)

   287                 else:

   288                     if accu:

   289                         if not self.skip:

   290                             self.process(accu)

   291                         accu = []

   292                     self.command(line, mo)

   293             elif blprog.match(line) and \

   294                  'format' not in self.stack and \

   295                  'example' not in self.stack:

   296                 if accu:

   297                     if not self.skip:

   298                         self.process(accu)

   299                         if self.nofill:

   300                             self.write('\n')

   301                         else:

   302                             self.write('<P>\n')

   303                         accu = []

   304             else:

   305                 # Append the line including trailing \n!

   306                 accu.append(line)

   307         #

   308         if self.skip:

   309             print '*** Still skipping at the end'

   310         if self.stack:

   311             print '*** Stack not empty at the end'

   312             print '***', self.stack

   313         if self.includedepth == 0:

   314             while self.nodestack:

   315                 self.nodestack[-1].finalize()

   316                 self.nodestack[-1].flush()

   317                 del self.nodestack[-1]

   318 

   319     # Start saving text in a buffer instead of writing it to a file

   320     def startsaving(self):

   321         if self.savetext <> None:

   322             self.savestack.append(self.savetext)

   323             # print '*** Recursively saving text, expect trouble'

   324         self.savetext = ''

   325 

   326     # Return the text saved so far and start writing to file again

   327     def collectsavings(self):

   328         savetext = self.savetext

   329         if len(self.savestack) > 0:

   330             self.savetext = self.savestack[-1]

   331             del self.savestack[-1]

   332         else:

   333             self.savetext = None

   334         return savetext or ''

   335 

   336     # Write text to file, or save it in a buffer, or ignore it

   337     def write(self, *args):

   338         try:

   339             text = ''.join(args)

   340         except:

   341             print args

   342             raise TypeError

   343         if self.savetext <> None:

   344             self.savetext = self.savetext + text

   345         elif self.nodefp:

   346             self.nodefp.write(text)

   347         elif self.node:

   348             self.node.write(text)

   349 

   350     # Complete the current node -- write footnotes and close file

   351     def endnode(self):

   352         if self.savetext <> None:

   353             print '*** Still saving text at end of node'

   354             dummy = self.collectsavings()

   355         if self.footnotes:

   356             self.writefootnotes()

   357         if self.nodefp:

   358             if self.nodelineno > 20:

   359                 self.write('<HR>\n')

   360                 [name, next, prev, up] = self.nodelinks[:4]

   361                 self.link('Next', next)

   362                 self.link('Prev', prev)

   363                 self.link('Up', up)

   364                 if self.nodename <> self.topname:

   365                     self.link('Top', self.topname)

   366                 self.write('<HR>\n')

   367             self.write('</BODY>\n')

   368             self.nodefp.close()

   369             self.nodefp = None

   370         elif self.node:

   371             if not self.cont and \

   372                (not self.node.type or \

   373                 (self.node.next and self.node.prev and self.node.up)):

   374                 self.node.finalize()

   375                 self.node.flush()

   376             else:

   377                 self.nodestack.append(self.node)

   378             self.node = None

   379         self.nodename = ''

   380 

   381     # Process a list of lines, expanding embedded @-commands

   382     # This mostly distinguishes between menus and normal text

   383     def process(self, accu):

   384         if self.debugging > 1:

   385             print '!'*self.debugging, 'process:', self.skip, self.stack,

   386             if accu: print accu[0][:30],

   387             if accu[0][30:] or accu[1:]: print '...',

   388             print

   389         if self.inmenu():

   390             # XXX should be done differently

   391             for line in accu:

   392                 mo = miprog.match(line)

   393                 if not mo:

   394                     line = line.strip() + '\n'

   395                     self.expand(line)

   396                     continue

   397                 bgn, end = mo.span(0)

   398                 a, b = mo.span(1)

   399                 c, d = mo.span(2)

   400                 e, f = mo.span(3)

   401                 g, h = mo.span(4)

   402                 label = line[a:b]

   403                 nodename = line[c:d]

   404                 if nodename[0] == ':': nodename = label

   405                 else: nodename = line[e:f]

   406                 punct = line[g:h]

   407                 self.write('  <LI><A HREF="',

   408                            makefile(nodename),

   409                            '">', nodename,

   410                            '</A>', punct, '\n')

   411                 self.htmlhelp.menuitem(nodename)

   412                 self.expand(line[end:])

   413         else:

   414             text = ''.join(accu)

   415             self.expand(text)

   416 

   417     # find 'menu' (we might be inside 'ifset' or 'ifclear')

   418     def inmenu(self):

   419         #if 'menu' in self.stack:

   420         #    print 'inmenu   :', self.skip, self.stack, self.stackinfo

   421         stack = self.stack

   422         while stack and stack[-1] in ('ifset','ifclear'):

   423             try:

   424                 if self.stackinfo[len(stack)]:

   425                     return 0

   426             except KeyError:

   427                 pass

   428             stack = stack[:-1]

   429         return (stack and stack[-1] == 'menu')

   430 

   431     # Write a string, expanding embedded @-commands

   432     def expand(self, text):

   433         stack = []

   434         i = 0

   435         n = len(text)

   436         while i < n:

   437             start = i

   438             mo = spprog.search(text, i)

   439             if mo:

   440                 i = mo.start()

   441             else:

   442                 self.write(text[start:])

   443                 break

   444             self.write(text[start:i])

   445             c = text[i]

   446             i = i+1

   447             if c == '\n':

   448                 self.write('\n')

   449                 continue

   450             if c == '<':

   451                 self.write('<')

   452                 continue

   453             if c == '>':

   454                 self.write('>')

   455                 continue

   456             if c == '&':

   457                 self.write('&')

   458                 continue

   459             if c == '{':

   460                 stack.append('')

   461                 continue

   462             if c == '}':

   463                 if not stack:

   464                     print '*** Unmatched }'

   465                     self.write('}')

   466                     continue

   467                 cmd = stack[-1]

   468                 del stack[-1]

   469                 try:

   470                     method = getattr(self, 'close_' + cmd)

   471                 except AttributeError:

   472                     self.unknown_close(cmd)

   473                     continue

   474                 method()

   475                 continue

   476             if c <> '@':

   477                 # Cannot happen unless spprog is changed

   478                 raise RuntimeError, 'unexpected funny %r' % c

   479             start = i

   480             while i < n and text[i] in string.ascii_letters: i = i+1

   481             if i == start:

   482                 # @ plus non-letter: literal next character

   483                 i = i+1

   484                 c = text[start:i]

   485                 if c == ':':

   486                     # `@:' means no extra space after

   487                     # preceding `.', `?', `!' or `:'

   488                     pass

   489                 else:

   490                     # `@.' means a sentence-ending period;

   491                     # `@@', `@{', `@}' quote `@', `{', `}'

   492                     self.write(c)

   493                 continue

   494             cmd = text[start:i]

   495             if i < n and text[i] == '{':

   496                 i = i+1

   497                 stack.append(cmd)

   498                 try:

   499                     method = getattr(self, 'open_' + cmd)

   500                 except AttributeError:

   501                     self.unknown_open(cmd)

   502                     continue

   503                 method()

   504                 continue

   505             try:

   506                 method = getattr(self, 'handle_' + cmd)

   507             except AttributeError:

   508                 self.unknown_handle(cmd)

   509                 continue

   510             method()

   511         if stack:

   512             print '*** Stack not empty at para:', stack

   513 

   514     # --- Handle unknown embedded @-commands ---

   515 

   516     def unknown_open(self, cmd):

   517         print '*** No open func for @' + cmd + '{...}'

   518         cmd = cmd + '{'

   519         self.write('@', cmd)

   520         if not self.unknown.has_key(cmd):

   521             self.unknown[cmd] = 1

   522         else:

   523             self.unknown[cmd] = self.unknown[cmd] + 1

   524 

   525     def unknown_close(self, cmd):

   526         print '*** No close func for @' + cmd + '{...}'

   527         cmd = '}' + cmd

   528         self.write('}')

   529         if not self.unknown.has_key(cmd):

   530             self.unknown[cmd] = 1

   531         else:

   532             self.unknown[cmd] = self.unknown[cmd] + 1

   533 

   534     def unknown_handle(self, cmd):

   535         print '*** No handler for @' + cmd

   536         self.write('@', cmd)

   537         if not self.unknown.has_key(cmd):

   538             self.unknown[cmd] = 1

   539         else:

   540             self.unknown[cmd] = self.unknown[cmd] + 1

   541 

   542     # XXX The following sections should be ordered as the texinfo docs

   543 

   544     # --- Embedded @-commands without {} argument list --

   545 

   546     def handle_noindent(self): pass

   547 

   548     def handle_refill(self): pass

   549 

   550     # --- Include file handling ---

   551 

   552     def do_include(self, args):

   553         file = args

   554         file = os.path.join(self.includedir, file)

   555         try:

   556             fp = open(file, 'r')

   557         except IOError, msg:

   558             print '*** Can\'t open include file', repr(file)

   559             return

   560         print '!'*self.debugging, '--> file', repr(file)

   561         save_done = self.done

   562         save_skip = self.skip

   563         save_stack = self.stack

   564         self.includedepth = self.includedepth + 1

   565         self.parserest(fp, 0)

   566         self.includedepth = self.includedepth - 1

   567         fp.close()

   568         self.done = save_done

   569         self.skip = save_skip

   570         self.stack = save_stack

   571         print '!'*self.debugging, '<-- file', repr(file)

   572 

   573     # --- Special Insertions ---

   574 

   575     def open_dmn(self): pass

   576     def close_dmn(self): pass

   577 

   578     def open_dots(self): self.write('...')

   579     def close_dots(self): pass

   580 

   581     def open_bullet(self): pass

   582     def close_bullet(self): pass

   583 

   584     def open_TeX(self): self.write('TeX')

   585     def close_TeX(self): pass

   586 

   587     def handle_copyright(self): self.write(self.COPYRIGHT_SYMBOL)

   588     def open_copyright(self): self.write(self.COPYRIGHT_SYMBOL)

   589     def close_copyright(self): pass

   590 

   591     def open_minus(self): self.write('-')

   592     def close_minus(self): pass

   593 

   594     # --- Accents ---

   595 

   596     # rpyron 2002-05-07

   597     # I would like to do at least as well as makeinfo when

   598     # it is producing HTML output:

   599     #

   600     #   input               output

   601     #     @"o                 @"o                umlaut accent

   602     #     @'o                 'o                 acute accent

   603     #     @,{c}               @,{c}              cedilla accent

   604     #     @=o                 @=o                macron/overbar accent

   605     #     @^o                 @^o                circumflex accent

   606     #     @`o                 `o                 grave accent

   607     #     @~o                 @~o                tilde accent

   608     #     @dotaccent{o}       @dotaccent{o}      overdot accent

   609     #     @H{o}               @H{o}              long Hungarian umlaut

   610     #     @ringaccent{o}      @ringaccent{o}     ring accent

   611     #     @tieaccent{oo}      @tieaccent{oo}     tie-after accent

   612     #     @u{o}               @u{o}              breve accent

   613     #     @ubaraccent{o}      @ubaraccent{o}     underbar accent

   614     #     @udotaccent{o}      @udotaccent{o}     underdot accent

   615     #     @v{o}               @v{o}              hacek or check accent

   616     #     @exclamdown{}       ¡             upside-down !

   617     #     @questiondown{}     ¿             upside-down ?

   618     #     @aa{},@AA{}         å,Å      a,A with circle

   619     #     @ae{},@AE{}         æ,Æ      ae,AE ligatures

   620     #     @dotless{i}         @dotless{i}        dotless i

   621     #     @dotless{j}         @dotless{j}        dotless j

   622     #     @l{},@L{}           l/,L/              suppressed-L,l

   623     #     @o{},@O{}           ø,Ø      O,o with slash

   624     #     @oe{},@OE{}         oe,OE              oe,OE ligatures

   625     #     @ss{}               ß             es-zet or sharp S

   626     #

   627     # The following character codes and approximations have been

   628     # copied from makeinfo's HTML output.

   629 

   630     def open_exclamdown(self): self.write('¡')   # upside-down !

   631     def close_exclamdown(self): pass

   632     def open_questiondown(self): self.write('¿') # upside-down ?

   633     def close_questiondown(self): pass

   634     def open_aa(self): self.write('å') # a with circle

   635     def close_aa(self): pass

   636     def open_AA(self): self.write('Å') # A with circle

   637     def close_AA(self): pass

   638     def open_ae(self): self.write('æ') # ae ligatures

   639     def close_ae(self): pass

   640     def open_AE(self): self.write('Æ') # AE ligatures

   641     def close_AE(self): pass

   642     def open_o(self): self.write('ø')  # o with slash

   643     def close_o(self): pass

   644     def open_O(self): self.write('Ø')  # O with slash

   645     def close_O(self): pass

   646     def open_ss(self): self.write('ß') # es-zet or sharp S

   647     def close_ss(self): pass

   648     def open_oe(self): self.write('oe')     # oe ligatures

   649     def close_oe(self): pass

   650     def open_OE(self): self.write('OE')     # OE ligatures

   651     def close_OE(self): pass

   652     def open_l(self): self.write('l/')      # suppressed-l

   653     def close_l(self): pass

   654     def open_L(self): self.write('L/')      # suppressed-L

   655     def close_L(self): pass

   656 

   657     # --- Special Glyphs for Examples ---

   658 

   659     def open_result(self): self.write('=>')

   660     def close_result(self): pass

   661 

   662     def open_expansion(self): self.write('==>')

   663     def close_expansion(self): pass

   664 

   665     def open_print(self): self.write('-|')

   666     def close_print(self): pass

   667 

   668     def open_error(self): self.write('error-->')

   669     def close_error(self): pass

   670 

   671     def open_equiv(self): self.write('==')

   672     def close_equiv(self): pass

   673 

   674     def open_point(self): self.write('-!-')

   675     def close_point(self): pass

   676 

   677     # --- Cross References ---

   678 

   679     def open_pxref(self):

   680         self.write('see ')

   681         self.startsaving()

   682     def close_pxref(self):

   683         self.makeref()

   684 

   685     def open_xref(self):

   686         self.write('See ')

   687         self.startsaving()

   688     def close_xref(self):

   689         self.makeref()

   690 

   691     def open_ref(self):

   692         self.startsaving()

   693     def close_ref(self):

   694         self.makeref()

   695 

   696     def open_inforef(self):

   697         self.write('See info file ')

   698         self.startsaving()

   699     def close_inforef(self):

   700         text = self.collectsavings()

   701         args = [s.strip() for s in text.split(',')]

   702         while len(args) < 3: args.append('')

   703         node = args[0]

   704         file = args[2]

   705         self.write('`', file, '\', node `', node, '\'')

   706 

   707     def makeref(self):

   708         text = self.collectsavings()

   709         args = [s.strip() for s in text.split(',')]

   710         while len(args) < 5: args.append('')

   711         nodename = label = args[0]

   712         if args[2]: label = args[2]

   713         file = args[3]

   714         title = args[4]

   715         href = makefile(nodename)

   716         if file:

   717             href = '../' + file + '/' + href

   718         self.write('<A HREF="', href, '">', label, '</A>')

   719 

   720     # rpyron 2002-05-07  uref support

   721     def open_uref(self):

   722         self.startsaving()

   723     def close_uref(self):

   724         text = self.collectsavings()

   725         args = [s.strip() for s in text.split(',')]

   726         while len(args) < 2: args.append('')

   727         href = args[0]

   728         label = args[1]

   729         if not label: label = href

   730         self.write('<A HREF="', href, '">', label, '</A>')

   731 

   732     # rpyron 2002-05-07  image support

   733     # GNU makeinfo producing HTML output tries `filename.png'; if

   734     # that does not exist, it tries `filename.jpg'. If that does

   735     # not exist either, it complains. GNU makeinfo does not handle

   736     # GIF files; however, I include GIF support here because

   737     # MySQL documentation uses GIF files.

   738 

   739     def open_image(self):

   740         self.startsaving()

   741     def close_image(self):

   742         self.makeimage()

   743     def makeimage(self):

   744         text = self.collectsavings()

   745         args = [s.strip() for s in text.split(',')]

   746         while len(args) < 5: args.append('')

   747         filename = args[0]

   748         width    = args[1]

   749         height   = args[2]

   750         alt      = args[3]

   751         ext      = args[4]

   752 

   753         # The HTML output will have a reference to the image

   754         # that is relative to the HTML output directory,

   755         # which is what 'filename' gives us. However, we need

   756         # to find it relative to our own current directory,

   757         # so we construct 'imagename'.

   758         imagelocation = self.dirname + '/' + filename

   759 

   760         if   os.path.exists(imagelocation+'.png'):

   761             filename += '.png'

   762         elif os.path.exists(imagelocation+'.jpg'):

   763             filename += '.jpg'

   764         elif os.path.exists(imagelocation+'.gif'):   # MySQL uses GIF files

   765             filename += '.gif'

   766         else:

   767             print "*** Cannot find image " + imagelocation

   768         #TODO: what is 'ext'?

   769         self.write('<IMG SRC="', filename, '"',                     \

   770                     width  and (' WIDTH="'  + width  + '"') or "",  \

   771                     height and (' HEIGHT="' + height + '"') or "",  \

   772                     alt    and (' ALT="'    + alt    + '"') or "",  \

   773                     '/>' )

   774         self.htmlhelp.addimage(imagelocation)

   775 

   776 

   777     # --- Marking Words and Phrases ---

   778 

   779     # --- Other @xxx{...} commands ---

   780 

   781     def open_(self): pass # Used by {text enclosed in braces}

   782     def close_(self): pass

   783 

   784     open_asis = open_

   785     close_asis = close_

   786 

   787     def open_cite(self): self.write('<CITE>')

   788     def close_cite(self): self.write('</CITE>')

   789 

   790     def open_code(self): self.write('<CODE>')

   791     def close_code(self): self.write('</CODE>')

   792 

   793     def open_t(self): self.write('<TT>')

   794     def close_t(self): self.write('</TT>')

   795 

   796     def open_dfn(self): self.write('<DFN>')

   797     def close_dfn(self): self.write('</DFN>')

   798 

   799     def open_emph(self): self.write('<EM>')

   800     def close_emph(self): self.write('</EM>')

   801 

   802     def open_i(self): self.write('<I>')

   803     def close_i(self): self.write('</I>')

   804 

   805     def open_footnote(self):

   806         # if self.savetext <> None:

   807         #       print '*** Recursive footnote -- expect weirdness'

   808         id = len(self.footnotes) + 1

   809         self.write(self.FN_SOURCE_PATTERN % {'id': repr(id)})

   810         self.startsaving()

   811 

   812     def close_footnote(self):

   813         id = len(self.footnotes) + 1

   814         self.footnotes.append((id, self.collectsavings()))

   815 

   816     def writefootnotes(self):

   817         self.write(self.FN_HEADER)

   818         for id, text in self.footnotes:

   819             self.write(self.FN_TARGET_PATTERN

   820                        % {'id': repr(id), 'text': text})

   821         self.footnotes = []

   822 

   823     def open_file(self): self.write('<CODE>')

   824     def close_file(self): self.write('</CODE>')

   825 

   826     def open_kbd(self): self.write('<KBD>')

   827     def close_kbd(self): self.write('</KBD>')

   828 

   829     def open_key(self): self.write('<KEY>')

   830     def close_key(self): self.write('</KEY>')

   831 

   832     def open_r(self): self.write('<R>')

   833     def close_r(self): self.write('</R>')

   834 

   835     def open_samp(self): self.write('`<SAMP>')

   836     def close_samp(self): self.write('</SAMP>\'')

   837 

   838     def open_sc(self): self.write('<SMALLCAPS>')

   839     def close_sc(self): self.write('</SMALLCAPS>')

   840 

   841     def open_strong(self): self.write('<STRONG>')

   842     def close_strong(self): self.write('</STRONG>')

   843 

   844     def open_b(self): self.write('<B>')

   845     def close_b(self): self.write('</B>')

   846 

   847     def open_var(self): self.write('<VAR>')

   848     def close_var(self): self.write('</VAR>')

   849 

   850     def open_w(self): self.write('<NOBREAK>')

   851     def close_w(self): self.write('</NOBREAK>')

   852 

   853     def open_url(self): self.startsaving()

   854     def close_url(self):

   855         text = self.collectsavings()

   856         self.write('<A HREF="', text, '">', text, '</A>')

   857 

   858     def open_email(self): self.startsaving()

   859     def close_email(self):

   860         text = self.collectsavings()

   861         self.write('<A HREF="mailto:', text, '">', text, '</A>')

   862 

   863     open_titlefont = open_

   864     close_titlefont = close_

   865 

   866     def open_small(self): pass

   867     def close_small(self): pass

   868 

   869     def command(self, line, mo):

   870         a, b = mo.span(1)

   871         cmd = line[a:b]

   872         args = line[b:].strip()

   873         if self.debugging > 1:

   874             print '!'*self.debugging, 'command:', self.skip, self.stack, \

   875                   '@' + cmd, args

   876         try:

   877             func = getattr(self, 'do_' + cmd)

   878         except AttributeError:

   879             try:

   880                 func = getattr(self, 'bgn_' + cmd)

   881             except AttributeError:

   882                 # don't complain if we are skipping anyway

   883                 if not self.skip:

   884                     self.unknown_cmd(cmd, args)

   885                 return

   886             self.stack.append(cmd)

   887             func(args)

   888             return

   889         if not self.skip or cmd == 'end':

   890             func(args)

   891 

   892     def unknown_cmd(self, cmd, args):

   893         print '*** unknown', '@' + cmd, args

   894         if not self.unknown.has_key(cmd):

   895             self.unknown[cmd] = 1

   896         else:

   897             self.unknown[cmd] = self.unknown[cmd] + 1

   898 

   899     def do_end(self, args):

   900         words = args.split()

   901         if not words:

   902             print '*** @end w/o args'

   903         else:

   904             cmd = words[0]

   905             if not self.stack or self.stack[-1] <> cmd:

   906                 print '*** @end', cmd, 'unexpected'

   907             else:

   908                 del self.stack[-1]

   909             try:

   910                 func = getattr(self, 'end_' + cmd)

   911             except AttributeError:

   912                 self.unknown_end(cmd)

   913                 return

   914             func()

   915 

   916     def unknown_end(self, cmd):

   917         cmd = 'end ' + cmd

   918         print '*** unknown', '@' + cmd

   919         if not self.unknown.has_key(cmd):

   920             self.unknown[cmd] = 1

   921         else:

   922             self.unknown[cmd] = self.unknown[cmd] + 1

   923 

   924     # --- Comments ---

   925 

   926     def do_comment(self, args): pass

   927     do_c = do_comment

   928 

   929     # --- Conditional processing ---

   930 

   931     def bgn_ifinfo(self, args): pass

   932     def end_ifinfo(self): pass

   933 

   934     def bgn_iftex(self, args): self.skip = self.skip + 1

   935     def end_iftex(self): self.skip = self.skip - 1

   936 

   937     def bgn_ignore(self, args): self.skip = self.skip + 1

   938     def end_ignore(self): self.skip = self.skip - 1

   939 

   940     def bgn_tex(self, args): self.skip = self.skip + 1

   941     def end_tex(self): self.skip = self.skip - 1

   942 

   943     def do_set(self, args):

   944         fields = args.split(' ')

   945         key = fields[0]

   946         if len(fields) == 1:

   947             value = 1

   948         else:

   949             value = ' '.join(fields[1:])

   950         self.values[key] = value

   951 

   952     def do_clear(self, args):

   953         self.values[args] = None

   954 

   955     def bgn_ifset(self, args):

   956         if args not in self.values.keys() \

   957            or self.values[args] is None:

   958             self.skip = self.skip + 1

   959             self.stackinfo[len(self.stack)] = 1

   960         else:

   961             self.stackinfo[len(self.stack)] = 0

   962     def end_ifset(self):

   963         try:

   964             if self.stackinfo[len(self.stack) + 1]:

   965                 self.skip = self.skip - 1

   966             del self.stackinfo[len(self.stack) + 1]

   967         except KeyError:

   968             print '*** end_ifset: KeyError :', len(self.stack) + 1

   969 

   970     def bgn_ifclear(self, args):

   971         if args in self.values.keys() \

   972            and self.values[args] is not None:

   973             self.skip = self.skip + 1

   974             self.stackinfo[len(self.stack)] = 1

   975         else:

   976             self.stackinfo[len(self.stack)] = 0

   977     def end_ifclear(self):

   978         try:

   979             if self.stackinfo[len(self.stack) + 1]:

   980                 self.skip = self.skip - 1

   981             del self.stackinfo[len(self.stack) + 1]

   982         except KeyError:

   983             print '*** end_ifclear: KeyError :', len(self.stack) + 1

   984 

   985     def open_value(self):

   986         self.startsaving()

   987 

   988     def close_value(self):

   989         key = self.collectsavings()

   990         if key in self.values.keys():

   991             self.write(self.values[key])

   992         else:

   993             print '*** Undefined value: ', key

   994 

   995     # --- Beginning a file ---

   996 

   997     do_finalout = do_comment

   998     do_setchapternewpage = do_comment

   999     do_setfilename = do_comment

  1000 

  1001     def do_settitle(self, args):

  1002         self.startsaving()

  1003         self.expand(args)

  1004         self.title = self.collectsavings()

  1005     def do_parskip(self, args): pass

  1006 

  1007     # --- Ending a file ---

  1008 

  1009     def do_bye(self, args):

  1010         self.endnode()

  1011         self.done = 1

  1012 

  1013     # --- Title page ---

  1014 

  1015     def bgn_titlepage(self, args): self.skip = self.skip + 1

  1016     def end_titlepage(self): self.skip = self.skip - 1

  1017     def do_shorttitlepage(self, args): pass

  1018 

  1019     def do_center(self, args):

  1020         # Actually not used outside title page...

  1021         self.write('<H1>')

  1022         self.expand(args)

  1023         self.write('</H1>\n')

  1024     do_title = do_center

  1025     do_subtitle = do_center

  1026     do_author = do_center

  1027 

  1028     do_vskip = do_comment

  1029     do_vfill = do_comment

  1030     do_smallbook = do_comment

  1031 

  1032     do_paragraphindent = do_comment

  1033     do_setchapternewpage = do_comment

  1034     do_headings = do_comment

  1035     do_footnotestyle = do_comment

  1036 

  1037     do_evenheading = do_comment

  1038     do_evenfooting = do_comment

  1039     do_oddheading = do_comment

  1040     do_oddfooting = do_comment

  1041     do_everyheading = do_comment

  1042     do_everyfooting = do_comment

  1043 

  1044     # --- Nodes ---

  1045 

  1046     def do_node(self, args):

  1047         self.endnode()

  1048         self.nodelineno = 0

  1049         parts = [s.strip() for s in args.split(',')]

  1050         while len(parts) < 4: parts.append('')

  1051         self.nodelinks = parts

  1052         [name, next, prev, up] = parts[:4]

  1053         file = self.dirname + '/' + makefile(name)

  1054         if self.filenames.has_key(file):

  1055             print '*** Filename already in use: ', file

  1056         else:

  1057             if self.debugging: print '!'*self.debugging, '--- writing', file

  1058         self.filenames[file] = 1

  1059         # self.nodefp = open(file, 'w')

  1060         self.nodename = name

  1061         if self.cont and self.nodestack:

  1062             self.nodestack[-1].cont = self.nodename

  1063         if not self.topname: self.topname = name

  1064         title = name

  1065         if self.title: title = title + ' -- ' + self.title

  1066         self.node = self.Node(self.dirname, self.nodename, self.topname,

  1067                               title, next, prev, up)

  1068         self.htmlhelp.addnode(self.nodename,next,prev,up,file)

  1069 

  1070     def link(self, label, nodename):

  1071         if nodename:

  1072             if nodename.lower() == '(dir)':

  1073                 addr = '../dir.html'

  1074             else:

  1075                 addr = makefile(nodename)

  1076             self.write(label, ': <A HREF="', addr, '" TYPE="',

  1077                        label, '">', nodename, '</A>  \n')

  1078 

  1079     # --- Sectioning commands ---

  1080 

  1081     def popstack(self, type):

  1082         if (self.node):

  1083             self.node.type = type

  1084             while self.nodestack:

  1085                 if self.nodestack[-1].type > type:

  1086                     self.nodestack[-1].finalize()

  1087                     self.nodestack[-1].flush()

  1088                     del self.nodestack[-1]

  1089                 elif self.nodestack[-1].type == type:

  1090                     if not self.nodestack[-1].next:

  1091                         self.nodestack[-1].next = self.node.name

  1092                     if not self.node.prev:

  1093                         self.node.prev = self.nodestack[-1].name

  1094                     self.nodestack[-1].finalize()

  1095                     self.nodestack[-1].flush()

  1096                     del self.nodestack[-1]

  1097                 else:

  1098                     if type > 1 and not self.node.up:

  1099                         self.node.up = self.nodestack[-1].name

  1100                     break

  1101 

  1102     def do_chapter(self, args):

  1103         self.heading('H1', args, 0)

  1104         self.popstack(1)

  1105 

  1106     def do_unnumbered(self, args):

  1107         self.heading('H1', args, -1)

  1108         self.popstack(1)

  1109     def do_appendix(self, args):

  1110         self.heading('H1', args, -1)

  1111         self.popstack(1)

  1112     def do_top(self, args):

  1113         self.heading('H1', args, -1)

  1114     def do_chapheading(self, args):

  1115         self.heading('H1', args, -1)

  1116     def do_majorheading(self, args):

  1117         self.heading('H1', args, -1)

  1118 

  1119     def do_section(self, args):

  1120         self.heading('H1', args, 1)

  1121         self.popstack(2)

  1122 

  1123     def do_unnumberedsec(self, args):

  1124         self.heading('H1', args, -1)

  1125         self.popstack(2)

  1126     def do_appendixsec(self, args):

  1127         self.heading('H1', args, -1)

  1128         self.popstack(2)

  1129     do_appendixsection = do_appendixsec

  1130     def do_heading(self, args):

  1131         self.heading('H1', args, -1)

  1132 

  1133     def do_subsection(self, args):

  1134         self.heading('H2', args, 2)

  1135         self.popstack(3)