Tools/scripts/texi2html.py

   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 fexible error handling
  36 # How about icons ?
  37
  38 import os
  39 import string
  40 import re
  41
  42 MAGIC = '\\input texinfo'
  43
  44 cmprog = re.compile('^@([a-z]+)([ \t]|$)')        # Command (line-oriented)
  45 blprog = re.compile('^[ \t]*$')                   # Blank line
  46 kwprog = re.compile('@[a-z]+')                    # Keyword (embedded, usually
  47                                                   # with {} args)
  48 spprog = re.compile('[\n@{}&<>]')                 # Special characters in
  49                                                   # running text
  50                                                   #
  51                                                   # menu item (Yuck!)
  52 miprog = re.compile('^\* ([^:]*):(:|[ \t]*([^\t,\n.]+)([^ \t\n]*))[ \t\n]*')
  53
  54
  55
  56 class HTMLNode:
  57     """Some of the parser's functionality is separated into this class.
  58
  59     A Node accumulates its contents, takes care of links to other Nodes
  60     and saves itself when it is finished and all links are resolved.
  61     """
  62
  63     DOCTYPE = '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">'
  64
  65     type = 0
  66     cont = ''
  67     epilogue = '</BODY></HTML>\n'
  68
  69     def __init__(self, dir, name, topname, title, next, prev, up):
  70         self.dirname = dir
  71         self.name = name
  72         if topname:
  73             self.topname = topname
  74         else:
  75             self.topname = name
  76         self.title = title
  77         self.next = next
  78         self.prev = prev
  79         self.up = up
  80         self.lines = []
  81
  82     def write(self, *lines):
  83         map(self.lines.append, lines)
  84
  85     def flush(self):
  86         fp = open(self.dirname + '/' + makefile(self.name), 'w')
  87         fp.write(self.prologue)
  88         fp.write(self.text)
  89         fp.write(self.epilogue)
  90         fp.close()
  91
  92     def link(self, label, nodename, rel=None, rev=None):
  93         if nodename:
  94             if string.lower(nodename) == '(dir)':
  95                 addr = '../dir.html'
  96                 title = ''
  97             else:
  98                 addr = makefile(nodename)
  99                 title = ' TITLE="%s"' % nodename
 100             self.write(label, ': <A HREF="', addr, '"', \
 101                        rel and (' REL=' + rel) or "", \
 102                        rev and (' REV=' + rev) or "", \
 103                        title, '>', nodename, '</A>  \n')
 104
 105     def finalize(self):
 106         length = len(self.lines)
 107         self.text = string.joinfields(self.lines, '')
 108         self.lines = []
 109         self.open_links()
 110         self.output_links()
 111         self.close_links()
 112         links = string.joinfields(self.lines, '')
 113         self.lines = []
 114
 115         self.prologue = (
 116             self.DOCTYPE +
 117             '\n<HTML><HEAD>\n'
 118             '  <!-- Converted with texi2html and Python -->\n'
 119             '  <TITLE>' + self.title + '</TITLE>\n'
 120             '  <LINK REL=Next HREF="'
 121                 + makefile(self.next) + '" TITLE="' + self.next + '">\n'
 122             '  <LINK REL=Previous HREF="'
 123                 + makefile(self.prev) + '" TITLE="' + self.prev  + '">\n'
 124             '  <LINK REL=Up HREF="'
 125                 + makefile(self.up) + '" TITLE="' + self.up  + '">\n'
 126             '</HEAD><BODY>\n' +
 127             links)
 128         if length > 20:
 129             self.epilogue = '<P>\n%s</BODY></HTML>\n' % links
 130
 131     def open_links(self):
 132         self.write('<HR>\n')
 133
 134     def close_links(self):
 135         self.write('<HR>\n')
 136
 137     def output_links(self):
 138         if self.cont != self.next:
 139             self.link('  Cont', self.cont)
 140         self.link('  Next', self.next, rel='Next')
 141         self.link('  Prev', self.prev, rel='Previous')
 142         self.link('  Up', self.up, rel='Up')
 143         if self.name <> self.topname:
 144             self.link('  Top', self.topname)
 145
 146
 147 class HTML3Node(HTMLNode):
 148
 149     DOCTYPE = '<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML Level 3//EN//3.0">'
 150
 151     def open_links(self):
 152         self.write('<DIV CLASS=Navigation>\n <HR>\n')
 153
 154     def close_links(self):
 155         self.write(' <HR>\n</DIV>\n')
 156
 157
 158 class TexinfoParser:
 159
 160     COPYRIGHT_SYMBOL = "&copy;"
 161     FN_ID_PATTERN = "(%(id)s)"
 162     FN_SOURCE_PATTERN = '<A NAME=footnoteref%(id)s' \
 163                         ' HREF="#footnotetext%(id)s">' \
 164                         + FN_ID_PATTERN + '</A>'
 165     FN_TARGET_PATTERN = '<A NAME=footnotetext%(id)s' \
 166                         ' HREF="#footnoteref%(id)s">' \
 167                         + FN_ID_PATTERN + '</A>\n%(text)s<P>\n'
 168     FN_HEADER = '\n<P>\n<HR NOSHADE SIZE=1 WIDTH=200>\n' \
 169                 '<STRONG><EM>Footnotes</EM></STRONG>\n<P>'
 170
 171
 172     Node = HTMLNode
 173
 174     # Initialize an instance
 175     def __init__(self):
 176         self.unknown = {}       # statistics about unknown @-commands
 177         self.filenames = {}     # Check for identical filenames
 178         self.debugging = 0      # larger values produce more output
 179         self.print_headers = 0  # always print headers?
 180         self.nodefp = None      # open file we're writing to
 181         self.nodelineno = 0     # Linenumber relative to node
 182         self.links = None       # Links from current node
 183         self.savetext = None    # If not None, save text head instead
 184         self.savestack = []     # If not None, save text head instead
 185         self.dirname = 'tmp'    # directory where files are created
 186         self.includedir = '.'   # directory to search @include files
 187         self.nodename = ''      # name of current node
 188         self.topname = ''       # name of top node (first node seen)
 189         self.title = ''         # title of this whole Texinfo tree
 190         self.resetindex()       # Reset all indices
 191         self.contents = []      # Reset table of contents
 192         self.numbering = []     # Reset section numbering counters
 193         self.nofill = 0         # Normal operation: fill paragraphs
 194         self.values={'html': 1} # Names that should be parsed in ifset
 195         self.stackinfo={}       # Keep track of state in the stack
 196         # XXX The following should be reset per node?!
 197         self.footnotes = []     # Reset list of footnotes
 198         self.itemarg = None     # Reset command used by @item
 199         self.itemnumber = None  # Reset number for @item in @enumerate
 200         self.itemindex = None   # Reset item index name
 201         self.node = None
 202         self.nodestack = []
 203         self.cont = 0
 204         self.includedepth = 0
 205     # Set (output) directory name
 206     def setdirname(self, dirname):
 207         self.dirname = dirname
 208
 209     # Set include directory name
 210     def setincludedir(self, includedir):
 211         self.includedir = includedir
 212
 213     # Parse the contents of an entire file
 214     def parse(self, fp):
 215         line = fp.readline()
 216         lineno = 1
 217         while line and (line[0] == '%' or blprog.match(line)):
 218             line = fp.readline()
 219             lineno = lineno + 1
 220         if line[:len(MAGIC)] <> MAGIC:
 221             raise SyntaxError, 'file does not begin with '+`MAGIC`
 222         self.parserest(fp, lineno)
 223
 224     # Parse the contents of a file, not expecting a MAGIC header
 225     def parserest(self, fp, initial_lineno):
 226         lineno = initial_lineno
 227         self.done = 0
 228         self.skip = 0
 229         self.stack = []
 230         accu = []
 231         while not self.done:
 232             line = fp.readline()
 233             self.nodelineno = self.nodelineno + 1
 234             if not line:
 235                 if accu:
 236                     if not self.skip: self.process(accu)
 237                     accu = []
 238                 if initial_lineno > 0:
 239                     print '*** EOF before @bye'
 240                 break
 241             lineno = lineno + 1
 242             mo = cmprog.match(line)
 243             if mo:
 244                 a, b = mo.span(1)
 245                 cmd = line[a:b]
 246                 if cmd in ('noindent', 'refill'):
 247                     accu.append(line)
 248                 else:
 249                     if accu:
 250                         if not self.skip:
 251                             self.process(accu)
 252                         accu = []
 253                     self.command(line, mo)
 254             elif blprog.match(line) and \
 255                  'format' not in self.stack and \
 256                  'example' not in self.stack:
 257                 if accu:
 258                     if not self.skip:
 259                         self.process(accu)
 260                         if self.nofill:
 261                             self.write('\n')
 262                         else:
 263                             self.write('<P>\n')
 264                         accu = []
 265             else:
 266                 # Append the line including trailing \n!
 267                 accu.append(line)
 268         #
 269         if self.skip:
 270             print '*** Still skipping at the end'
 271         if self.stack:
 272             print '*** Stack not empty at the end'
 273             print '***', self.stack
 274         if self.includedepth == 0:
 275             while self.nodestack:
 276                 self.nodestack[-1].finalize()
 277                 self.nodestack[-1].flush()
 278                 del self.nodestack[-1]
 279
 280     # Start saving text in a buffer instead of writing it to a file
 281     def startsaving(self):
 282         if self.savetext <> None:
 283             self.savestack.append(self.savetext)
 284             # print '*** Recursively saving text, expect trouble'
 285         self.savetext = ''
 286
 287     # Return the text saved so far and start writing to file again
 288     def collectsavings(self):
 289         savetext = self.savetext
 290         if len(self.savestack) > 0:
 291             self.savetext = self.savestack[-1]
 292             del self.savestack[-1]
 293         else:
 294             self.savetext = None
 295         return savetext or ''
 296
 297     # Write text to file, or save it in a buffer, or ignore it
 298     def write(self, *args):
 299         try:
 300             text = string.joinfields(args, '')
 301         except:
 302             print args
 303             raise TypeError
 304         if self.savetext <> None:
 305             self.savetext = self.savetext + text
 306         elif self.nodefp:
 307             self.nodefp.write(text)
 308         elif self.node:
 309             self.node.write(text)
 310     # Complete the current node -- write footnotes and close file
 311     def endnode(self):
 312         if self.savetext <> None:
 313             print '*** Still saving text at end of node'
 314             dummy = self.collectsavings()
 315         if self.footnotes:
 316             self.writefootnotes()
 317         if self.nodefp:
 318             if self.nodelineno > 20:
 319                 self.write('<HR>\n')
 320                 [name, next, prev, up] = self.nodelinks[:4]
 321                 self.link('Next', next)
 322                 self.link('Prev', prev)
 323                 self.link('Up', up)
 324                 if self.nodename <> self.topname:
 325                     self.link('Top', self.topname)
 326                 self.write('<HR>\n')
 327             self.write('</BODY>\n')
 328             self.nodefp.close()
 329             self.nodefp = None
 330         elif self.node:
 331             if not self.cont and \
 332                (not self.node.type or \
 333                 (self.node.next and self.node.prev and self.node.up)):
 334                 self.node.finalize()
 335                 self.node.flush()
 336             else:
 337                 self.nodestack.append(self.node)
 338             self.node = None
 339         self.nodename = ''
 340
 341     # Process a list of lines, expanding embedded @-commands
 342     # This mostly distinguishes between menus and normal text
 343     def process(self, accu):
 344         if self.debugging > 1:
 345             print self.skip, self.stack,
 346             if accu: print accu[0][:30],
 347             if accu[0][30:] or accu[1:]: print '...',
 348             print
 349         if self.stack and self.stack[-1] == 'menu':
 350             # XXX should be done differently
 351             for line in accu:
 352                 mo = miprog.match(line)
 353                 if not mo:
 354                     line = string.strip(line) + '\n'
 355                     self.expand(line)
 356                     continue
 357                 bgn, end = mo.span(0)
 358                 a, b = mo.span(1)
 359                 c, d = mo.span(2)
 360                 e, f = mo.span(3)
 361                 g, h = mo.span(4)
 362                 label = line[a:b]
 363                 nodename = line[c:d]
 364                 if nodename[0] == ':': nodename = label
 365                 else: nodename = line[e:f]
 366                 punct = line[g:h]
 367                 self.write('  <LI><A HREF="',
 368                            makefile(nodename),
 369                            '">', nodename,
 370                            '</A>', punct, '\n')
 371                 self.expand(line[end:])
 372         else:
 373             text = string.joinfields(accu, '')
 374             self.expand(text)
 375
 376     # Write a string, expanding embedded @-commands
 377     def expand(self, text):
 378         stack = []
 379         i = 0
 380         n = len(text)
 381         while i < n:
 382             start = i
 383             mo = spprog.search(text, i)
 384             if mo:
 385                 i = mo.start()
 386             else:
 387                 self.write(text[start:])
 388                 break
 389             self.write(text[start:i])
 390             c = text[i]
 391             i = i+1
 392             if c == '\n':
 393                 self.write('\n')
 394                 continue
 395             if c == '<':
 396                 self.write('&lt;')
 397                 continue
 398             if c == '>':
 399                 self.write('&gt;')
 400                 continue
 401             if c == '&':
 402                 self.write('&amp;')
 403                 continue
 404             if c == '{':
 405                 stack.append('')
 406                 continue
 407             if c == '}':
 408                 if not stack:
 409                     print '*** Unmatched }'
 410                     self.write('}')
 411                     continue
 412                 cmd = stack[-1]
 413                 del stack[-1]
 414                 try:
 415                     method = getattr(self, 'close_' + cmd)
 416                 except AttributeError:
 417                     self.unknown_close(cmd)
 418                     continue
 419                 method()
 420                 continue
 421             if c <> '@':
 422                 # Cannot happen unless spprog is changed
 423                 raise RuntimeError, 'unexpected funny '+`c`
 424             start = i
 425             while i < n and text[i] in string.letters: i = i+1
 426             if i == start:
 427                 # @ plus non-letter: literal next character
 428                 i = i+1
 429                 c = text[start:i]
 430                 if c == ':':
 431                     # `@:' means no extra space after
 432                     # preceding `.', `?', `!' or `:'
 433                     pass
 434                 else:
 435                     # `@.' means a sentence-ending period;
 436                     # `@@', `@{', `@}' quote `@', `{', `}'
 437                     self.write(c)
 438                 continue
 439             cmd = text[start:i]
 440             if i < n and text[i] == '{':
 441                 i = i+1
 442                 stack.append(cmd)
 443                 try:
 444                     method = getattr(self, 'open_' + cmd)
 445                 except AttributeError:
 446                     self.unknown_open(cmd)
 447                     continue
 448                 method()
 449                 continue
 450             try:
 451                 method = getattr(self, 'handle_' + cmd)
 452             except AttributeError:
 453                 self.unknown_handle(cmd)
 454                 continue
 455             method()
 456         if stack:
 457             print '*** Stack not empty at para:', stack
 458
 459     # --- Handle unknown embedded @-commands ---
 460
 461     def unknown_open(self, cmd):
 462         print '*** No open func for @' + cmd + '{...}'
 463         cmd = cmd + '{'
 464         self.write('@', cmd)
 465         if not self.unknown.has_key(cmd):
 466             self.unknown[cmd] = 1
 467         else:
 468             self.unknown[cmd] = self.unknown[cmd] + 1
 469
 470     def unknown_close(self, cmd):
 471         print '*** No close func for @' + cmd + '{...}'
 472         cmd = '}' + cmd
 473         self.write('}')
 474         if not self.unknown.has_key(cmd):
 475             self.unknown[cmd] = 1
 476         else:
 477             self.unknown[cmd] = self.unknown[cmd] + 1
 478
 479     def unknown_handle(self, cmd):
 480         print '*** No handler for @' + cmd
 481         self.write('@', cmd)
 482         if not self.unknown.has_key(cmd):
 483             self.unknown[cmd] = 1
 484         else:
 485             self.unknown[cmd] = self.unknown[cmd] + 1
 486
 487     # XXX The following sections should be ordered as the texinfo docs
 488
 489     # --- Embedded @-commands without {} argument list --
 490
 491     def handle_noindent(self): pass
 492
 493     def handle_refill(self): pass
 494
 495     # --- Include file handling ---
 496
 497     def do_include(self, args):
 498         file = args
 499         file = os.path.join(self.includedir, file)
 500         try:
 501             fp = open(file, 'r')
 502         except IOError, msg:
 503             print '*** Can\'t open include file', `file`
 504             return
 505         if self.debugging:
 506             print '--> file', `file`
 507         save_done = self.done
 508         save_skip = self.skip
 509         save_stack = self.stack
 510         self.includedepth = self.includedepth + 1
 511         self.parserest(fp, 0)
 512         self.includedepth = self.includedepth - 1
 513         fp.close()
 514         self.done = save_done
 515         self.skip = save_skip
 516         self.stack = save_stack
 517         if self.debugging:
 518             print '<-- file', `file`
 519
 520     # --- Special Insertions ---
 521
 522     def open_dmn(self): pass
 523     def close_dmn(self): pass
 524
 525     def open_dots(self): self.write('...')
 526     def close_dots(self): pass
 527
 528     def open_bullet(self): pass
 529     def close_bullet(self): pass
 530
 531     def open_TeX(self): self.write('TeX')
 532     def close_TeX(self): pass
 533
 534     def handle_copyright(self): self.write(self.COPYRIGHT_SYMBOL)
 535     def open_copyright(self): self.write(self.COPYRIGHT_SYMBOL)
 536     def close_copyright(self): pass
 537
 538     def open_minus(self): self.write('-')
 539     def close_minus(self): pass
 540
 541     # --- Special Glyphs for Examples ---
 542
 543     def open_result(self): self.write('=&gt;')
 544     def close_result(self): pass
 545
 546     def open_expansion(self): self.write('==&gt;')
 547     def close_expansion(self): pass
 548
 549     def open_print(self): self.write('-|')
 550     def close_print(self): pass
 551
 552     def open_error(self): self.write('error--&gt;')
 553     def close_error(self): pass
 554
 555     def open_equiv(self): self.write('==')
 556     def close_equiv(self): pass
 557
 558     def open_point(self): self.write('-!-')
 559     def close_point(self): pass
 560
 561     # --- Cross References ---
 562
 563     def open_pxref(self):
 564         self.write('see ')
 565         self.startsaving()
 566     def close_pxref(self):
 567         self.makeref()
 568
 569     def open_xref(self):
 570         self.write('See ')
 571         self.startsaving()
 572     def close_xref(self):
 573         self.makeref()
 574
 575     def open_ref(self):
 576         self.startsaving()
 577     def close_ref(self):
 578         self.makeref()
 579
 580     def open_inforef(self):
 581         self.write('See info file ')
 582         self.startsaving()
 583     def close_inforef(self):
 584         text = self.collectsavings()
 585         args = string.splitfields(text, ',')
 586         n = len(args)
 587         for i in range(n):
 588             args[i] = string.strip(args[i])
 589         while len(args) < 3: args.append('')
 590         node = args[0]
 591         file = args[2]
 592         self.write('`', file, '\', node `', node, '\'')
 593
 594     def makeref(self):
 595         text = self.collectsavings()
 596         args = string.splitfields(text, ',')
 597         n = len(args)
 598         for i in range(n):
 599             args[i] = string.strip(args[i])
 600         while len(args) < 5: args.append('')
 601         nodename = label = args[0]
 602         if args[2]: label = args[2]
 603         file = args[3]
 604         title = args[4]
 605         href = makefile(nodename)
 606         if file:
 607             href = '../' + file + '/' + href
 608         self.write('<A HREF="', href, '">', label, '</A>')
 609
 610     # --- Marking Words and Phrases ---
 611
 612     # --- Other @xxx{...} commands ---
 613
 614     def open_(self): pass # Used by {text enclosed in braces}
 615     def close_(self): pass
 616
 617     open_asis = open_
 618     close_asis = close_
 619
 620     def open_cite(self): self.write('<CITE>')
 621     def close_cite(self): self.write('</CITE>')
 622
 623     def open_code(self): self.write('<CODE>')
 624     def close_code(self): self.write('</CODE>')
 625
 626     def open_t(self): self.write('<TT>')
 627     def close_t(self): self.write('</TT>')
 628
 629     def open_dfn(self): self.write('<DFN>')
 630     def close_dfn(self): self.write('</DFN>')
 631
 632     def open_emph(self): self.write('<EM>')
 633     def close_emph(self): self.write('</EM>')
 634
 635     def open_i(self): self.write('<I>')
 636     def close_i(self): self.write('</I>')
 637
 638     def open_footnote(self):
 639         # if self.savetext <> None:
 640         #       print '*** Recursive footnote -- expect weirdness'
 641         id = len(self.footnotes) + 1
 642         self.write(self.FN_SOURCE_PATTERN % {'id': `id`})
 643         self.startsaving()
 644
 645     def close_footnote(self):
 646         id = len(self.footnotes) + 1
 647         self.footnotes.append((id, self.collectsavings()))
 648
 649     def writefootnotes(self):
 650         self.write(self.FN_HEADER)
 651         for id, text in self.footnotes:
 652             self.write(self.FN_TARGET_PATTERN
 653                        % {'id': `id`, 'text': text})
 654         self.footnotes = []
 655
 656     def open_file(self): self.write('<CODE>')
 657     def close_file(self): self.write('</CODE>')
 658
 659     def open_kbd(self): self.write('<KBD>')
 660     def close_kbd(self): self.write('</KBD>')
 661
 662     def open_key(self): self.write('<KEY>')
 663     def close_key(self): self.write('</KEY>')
 664
 665     def open_r(self): self.write('<R>')
 666     def close_r(self): self.write('</R>')
 667
 668     def open_samp(self): self.write('`<SAMP>')
 669     def close_samp(self): self.write('</SAMP>\'')
 670
 671     def open_sc(self): self.write('<SMALLCAPS>')
 672     def close_sc(self): self.write('</SMALLCAPS>')
 673
 674     def open_strong(self): self.write('<STRONG>')
 675     def close_strong(self): self.write('</STRONG>')
 676
 677     def open_b(self): self.write('<B>')
 678     def close_b(self): self.write('</B>')
 679
 680     def open_var(self): self.write('<VAR>')
 681     def close_var(self): self.write('</VAR>')
 682
 683     def open_w(self): self.write('<NOBREAK>')
 684     def close_w(self): self.write('</NOBREAK>')
 685
 686     def open_url(self): self.startsaving()
 687     def close_url(self):
 688         text = self.collectsavings()
 689         self.write('<A HREF="', text, '">', text, '</A>')
 690
 691     def open_email(self): self.startsaving()
 692     def close_email(self):
 693         text = self.collectsavings()
 694         self.write('<A HREF="mailto:', text, '">', text, '</A>')
 695
 696     open_titlefont = open_
 697     close_titlefont = close_
 698
 699     def open_small(self): pass
 700     def close_small(self): pass
 701
 702     def command(self, line, mo):
 703         a, b = mo.span(1)
 704         cmd = line[a:b]
 705         args = string.strip(line[b:])
 706         if self.debugging > 1:
 707             print self.skip, self.stack, '@' + cmd, args
 708         try:
 709             func = getattr(self, 'do_' + cmd)
 710         except AttributeError:
 711             try:
 712                 func = getattr(self, 'bgn_' + cmd)
 713             except AttributeError:
 714                 # don't complain if we are skipping anyway
 715                 if not self.skip:
 716                     self.unknown_cmd(cmd, args)
 717                 return
 718             self.stack.append(cmd)
 719             func(args)
 720             return
 721         if not self.skip or cmd == 'end':
 722             func(args)
 723
 724     def unknown_cmd(self, cmd, args):
 725         print '*** unknown', '@' + cmd, args
 726         if not self.unknown.has_key(cmd):
 727             self.unknown[cmd] = 1
 728         else:
 729             self.unknown[cmd] = self.unknown[cmd] + 1
 730
 731     def do_end(self, args):
 732         words = string.split(args)
 733         if not words:
 734             print '*** @end w/o args'
 735         else:
 736             cmd = words[0]
 737             if not self.stack or self.stack[-1] <> cmd:
 738                 print '*** @end', cmd, 'unexpected'
 739             else:
 740                 del self.stack[-1]
 741             try:
 742                 func = getattr(self, 'end_' + cmd)
 743             except AttributeError:
 744                 self.unknown_end(cmd)
 745                 return
 746             func()
 747
 748     def unknown_end(self, cmd):
 749         cmd = 'end ' + cmd
 750         print '*** unknown', '@' + cmd
 751         if not self.unknown.has_key(cmd):
 752             self.unknown[cmd] = 1
 753         else:
 754             self.unknown[cmd] = self.unknown[cmd] + 1
 755
 756     # --- Comments ---
 757
 758     def do_comment(self, args): pass
 759     do_c = do_comment
 760
 761     # --- Conditional processing ---
 762
 763     def bgn_ifinfo(self, args): pass
 764     def end_ifinfo(self): pass
 765
 766     def bgn_iftex(self, args): self.skip = self.skip + 1
 767     def end_iftex(self): self.skip = self.skip - 1
 768
 769     def bgn_ignore(self, args): self.skip = self.skip + 1
 770     def end_ignore(self): self.skip = self.skip - 1
 771
 772     def bgn_tex(self, args): self.skip = self.skip + 1
 773     def end_tex(self): self.skip = self.skip - 1
 774
 775     def do_set(self, args):
 776         fields = string.splitfields(args, ' ')
 777         key = fields[0]
 778         if len(fields) == 1:
 779             value = 1
 780         else:
 781             value = string.joinfields(fields[1:], ' ')
 782         self.values[key] = value
 783         print self.values
 784
 785     def do_clear(self, args):
 786         self.values[args] = None
 787
 788     def bgn_ifset(self, args):
 789         if args not in self.values.keys() \
 790            or self.values[args] is None:
 791             self.skip = self.skip + 1
 792             self.stackinfo[len(self.stack)] = 1
 793         else:
 794             self.stackinfo[len(self.stack)] = 0
 795     def end_ifset(self):
 796         print self.stack
 797         print self.stackinfo
 798         if self.stackinfo[len(self.stack) + 1]:
 799             self.skip = self.skip - 1
 800         del self.stackinfo[len(self.stack) + 1]
 801
 802     def bgn_ifclear(self, args):
 803         if args in self.values.keys() \
 804            and self.values[args] is not None:
 805             self.skip = self.skip + 1
 806             self.stackinfo[len(self.stack)] = 1
 807         else:
 808             self.stackinfo[len(self.stack)] = 0
 809
 810     end_ifclear = end_ifset
 811
 812     def open_value(self):
 813         self.startsaving()
 814
 815     def close_value(self):
 816         key = self.collectsavings()
 817         if key in self.values.keys():
 818             self.write(self.values[key])
 819         else:
 820             print '*** Undefined value: ', key
 821
 822     # --- Beginning a file ---
 823
 824     do_finalout = do_comment
 825     do_setchapternewpage = do_comment
 826     do_setfilename = do_comment
 827
 828     def do_settitle(self, args):
 829         print args
 830         self.startsaving()
 831         self.expand(args)
 832         self.title = self.collectsavings()
 833         print self.title
 834     def do_parskip(self, args): pass
 835
 836     # --- Ending a file ---
 837
 838     def do_bye(self, args):
 839         self.endnode()
 840         self.done = 1
 841
 842     # --- Title page ---
 843
 844     def bgn_titlepage(self, args): self.skip = self.skip + 1
 845     def end_titlepage(self): self.skip = self.skip - 1
 846     def do_shorttitlepage(self, args): pass
 847
 848     def do_center(self, args):
 849         # Actually not used outside title page...
 850         self.write('<H1>')
 851         self.expand(args)
 852         self.write('</H1>\n')
 853     do_title = do_center
 854     do_subtitle = do_center
 855     do_author = do_center
 856
 857     do_vskip = do_comment
 858     do_vfill = do_comment
 859     do_smallbook = do_comment
 860
 861     do_paragraphindent = do_comment
 862     do_setchapternewpage = do_comment
 863     do_headings = do_comment
 864     do_footnotestyle = do_comment
 865
 866     do_evenheading = do_comment
 867     do_evenfooting = do_comment
 868     do_oddheading = do_comment
 869     do_oddfooting = do_comment
 870     do_everyheading = do_comment
 871     do_everyfooting = do_comment
 872
 873     # --- Nodes ---
 874
 875     def do_node(self, args):
 876         self.endnode()
 877         self.nodelineno = 0
 878         parts = string.splitfields(args, ',')
 879         while len(parts) < 4: parts.append('')
 880         for i in range(4): parts[i] = string.strip(parts[i])
 881         self.nodelinks = parts
 882         [name, next, prev, up] = parts[:4]
 883         file = self.dirname + '/' + makefile(name)
 884         if self.filenames.has_key(file):
 885             print '*** Filename already in use: ', file
 886         else:
 887             if self.debugging: print '--- writing', file
 888         self.filenames[file] = 1
 889         # self.nodefp = open(file, 'w')
 890         self.nodename = name
 891         if self.cont and self.nodestack:
 892             self.nodestack[-1].cont = self.nodename
 893         if not self.topname: self.topname = name
 894         title = name
 895         if self.title: title = title + ' -- ' + self.title
 896         self.node = self.Node(self.dirname, self.nodename, self.topname,
 897                               title, next, prev, up)
 898
 899     def link(self, label, nodename):
 900         if nodename:
 901             if string.lower(nodename) == '(dir)':
 902                 addr = '../dir.html'
 903             else:
 904                 addr = makefile(nodename)
 905             self.write(label, ': <A HREF="', addr, '" TYPE="',
 906                        label, '">', nodename, '</A>  \n')
 907
 908     # --- Sectioning commands ---
 909
 910     def popstack(self, type):
 911         if (self.node):
 912             self.node.type = type
 913             while self.nodestack:
 914                 if self.nodestack[-1].type > type:
 915                     self.nodestack[-1].finalize()
 916                     self.nodestack[-1].flush()
 917                     del self.nodestack[-1]
 918                 elif self.nodestack[-1].type == type:
 919                     if not self.nodestack[-1].next:
 920                         self.nodestack[-1].next = self.node.name
 921                     if not self.node.prev:
 922                         self.node.prev = self.nodestack[-1].name
 923                     self.nodestack[-1].finalize()
 924                     self.nodestack[-1].flush()
 925                     del self.nodestack[-1]
 926                 else:
 927                     if type > 1 and not self.node.up:
 928                         self.node.up = self.nodestack[-1].name
 929                     break
 930
 931     def do_chapter(self, args):
 932         self.heading('H1', args, 0)
 933         self.popstack(1)
 934
 935     def do_unnumbered(self, args):
 936         self.heading('H1', args, -1)
 937         self.popstack(1)
 938     def do_appendix(self, args):
 939         self.heading('H1', args, -1)
 940         self.popstack(1)
 941     def do_top(self, args):
 942         self.heading('H1', args, -1)
 943     def do_chapheading(self, args):
 944         self.heading('H1', args, -1)
 945     def do_majorheading(self, args):
 946         self.heading('H1', args, -1)
 947
 948     def do_section(self, args):
 949         self.heading('H1', args, 1)
 950         self.popstack(2)
 951
 952     def do_unnumberedsec(self, args):
 953         self.heading('H1', args, -1)
 954         self.popstack(2)
 955     def do_appendixsec(self, args):
 956         self.heading('H1', args, -1)
 957         self.popstack(2)
 958     do_appendixsection = do_appendixsec
 959     def do_heading(self, args):
 960         self.heading('H1', args, -1)
 961
 962     def do_subsection(self, args):
 963         self.heading('H2', args, 2)
 964         self.popstack(3)
 965     def do_unnumberedsubsec(self, args):
 966         self.heading('H2', args, -1)
 967         self.popstack(3)
 968     def do_appendixsubsec(self, args):
 969         self.heading('H2', args, -1)
 970         self.popstack(3)
 971     def do_subheading(self, args):
 972         self.heading('H2', args, -1)
 973
 974     def do_subsubsection(self, args):
 975         self.heading('H3', args, 3)
 976         self.popstack(4)
 977     def do_unnumberedsubsubsec(self, args):
 978         self.heading('H3', args, -1)
 979         self.popstack(4)
 980     def do_appendixsubsubsec(self, args):
 981         self.heading('H3', args, -1)
 982         self.popstack(4)
 983     def do_subsubheading(self, args):
 984         self.heading('H3', args, -1)
 985
 986     def heading(self, type, args, level):
 987         if level >= 0:
 988             while len(self.numbering) <= level:
 989                 self.numbering.append(0)
 990             del self.numbering[level+1:]
 991             self.numbering[level] = self.numbering[level] + 1
 992             x = ''
 993             for i in self.numbering:
 994                 x = x + `i` + '.'
 995             args = x + ' ' + args
 996             self.contents.append((level, args, self.nodename))
 997         self.write('<', type, '>')
 998         self.expand(args)
 999         self.write('</', type, '>\n')
1000         if self.debugging or self.print_headers:
1001             print '---', args
1002
1003     def do_contents(self, args):
1004         # pass
1005         self.listcontents('Table of Contents', 999)
1006
1007     def do_shortcontents(self, args):
1008         pass
1009         # self.listcontents('Short Contents', 0)
1010     do_summarycontents = do_shortcontents
1011
1012     def listcontents(self, title, maxlevel):
1013         self.write('<H1>', title, '</H1>\n<UL COMPACT PLAIN>\n')
1014         prevlevels = [0]
1015         for level, title, node in self.contents:
1016             if level > maxlevel:
1017                 continue
1018             if level > prevlevels[-1]:
1019                 # can only advance one level at a time
1020                 self.write('  '*prevlevels[-1], '<UL PLAIN>\n')
1021                 prevlevels.append(level)
1022             elif level < prevlevels[-1]:
1023                 # might drop back multiple levels
1024                 while level < prevlevels[-1]:
1025                     del prevlevels[-1]
1026                     self.write('  '*prevlevels[-1],
1027                                '</UL>\n')
1028             self.write('  '*level, '<LI> <A HREF="',
1029                        makefile(node), '">')
1030             self.expand(title)
1031             self.write('</A>\n')
1032         self.write('</UL>\n' * len(prevlevels))
1033
1034     # --- Page lay-out ---
1035
1036     # These commands are only meaningful in printed text
1037
1038     def do_page(self, args): pass
1039
1040     def do_need(self, args): pass
1041
1042     def bgn_group(self, args): pass
1043     def end_group(self): pass
1044
1045     # --- Line lay-out ---
1046
1047     def do_sp(self, args):
1048         if self.nofill:
1049             self.write('\n')
1050         else:
1051             self.write('<P>\n')
1052
1053     def do_hline(self, args):
1054         self.write('<HR>')
1055
1056     # --- Function and variable definitions ---
1057
1058     def bgn_deffn(self, args):
1059         self.write('<DL>')
1060         self.do_deffnx(args)
1061
1062     def end_deffn(self):
1063         self.write('</DL>\n')
1064
1065     def do_deffnx(self, args):
1066         self.write('<DT>')
1067         words = splitwords(args, 2)
1068         [category, name], rest = words[:2], words[2:]
1069         self.expand('@b{%s}' % name)
1070         for word in rest: self.expand(' ' + makevar(word))
1071         #self.expand(' -- ' + category)
1072         self.write('\n<DD>')
1073         self.index('fn', name)
1074
1075     def bgn_defun(self, args): self.bgn_deffn('Function ' + args)
1076     end_defun = end_deffn
1077     def do_defunx(self, args): self.do_deffnx('Function ' + args)
1078
1079     def bgn_defmac(self, args): self.bgn_deffn('Macro ' + args)
1080     end_defmac = end_deffn
1081     def do_defmacx(self, args): self.do_deffnx('Macro ' + args)
1082
1083     def bgn_defspec(self, args): self.bgn_deffn('{Special Form} ' + args)
1084     end_defspec = end_deffn
1085     def do_defspecx(self, args): self.do_deffnx('{Special Form} ' + args)
1086
1087     def bgn_defvr(self, args):
1088         self.write('<DL>')
1089         self.do_defvrx(args)
1090
1091     end_defvr = end_deffn
1092
1093     def do_defvrx(self, args):
1094         self.write('<DT>')
1095         words = splitwords(args, 2)
1096         [category, name], rest = words[:2], words[2:]
1097         self.expand('@code{%s}' % name)
1098         # If there are too many arguments, show them
1099         for word in rest: self.expand(' ' + word)
1100         #self.expand(' -- ' + category)
1101         self.write('\n<DD>')
1102         self.index('vr', name)
1103
1104     def bgn_defvar(self, args): self.bgn_defvr('Variable ' + args)
1105     end_defvar = end_defvr
1106     def do_defvarx(self, args): self.do_defvrx('Variable ' + args)
1107
1108     def bgn_defopt(self, args): self.bgn_defvr('{User Option} ' + args)
1109     end_defopt = end_defvr
1110     def do_defoptx(self, args): self.do_defvrx('{User Option} ' + args)
1111
1112     # --- Ditto for typed languages ---
1113
1114     def bgn_deftypefn(self, args):
1115         self.write('<DL>')
1116         self.do_deftypefnx(args)
1117
1118     end_deftypefn = end_deffn
1119
1120     def do_deftypefnx(self, args):
1121         self.write('<DT>')
1122         words = splitwords(args, 3)
1123         [category, datatype, name], rest = words[:3], words[3:]
1124         self.expand('@code{%s} @b{%s}' % (datatype, name))
1125         for word in rest: self.expand(' ' + makevar(word))
1126         #self.expand(' -- ' + category)
1127         self.write('\n<DD>')
1128         self.index('fn', name)
1129
1130
1131     def bgn_deftypefun(self, args): self.bgn_deftypefn('Function ' + args)
1132     end_deftypefun = end_deftypefn
1133     def do_deftypefunx(self, args): self.do_deftypefnx('Function ' + args)
1134
1135     def bgn_deftypevr(self, args):
1136         self.write('<DL>')
1137         self.do_deftypevrx(args)
1138
1139     end_deftypevr = end_deftypefn
1140
1141     def do_deftypevrx(self, args):
1142         self.write('<DT>')
1143         words = splitwords(args, 3)
1144         [category, datatype, name], rest = words[:3], words[3:]
1145         self.expand('@code{%s} @b{%s}' % (datatype, name))
1146         # If there are too many arguments, show them
1147         for word in rest: self.expand(' ' + word)
1148         #self.expand(' -- ' + category)
1149         self.write('\n<DD>')
1150         self.index('fn', name)
1151
1152     def bgn_deftypevar(self, args):
1153         self.bgn_deftypevr('Variable ' + args)
1154     end_deftypevar = end_deftypevr
1155     def do_deftypevarx(self, args):
1156         self.do_deftypevrx('Variable ' + args)
1157
1158     # --- Ditto for object-oriented languages ---
1159
1160     def bgn_defcv(self, args):
1161         self.write('<DL>')
1162         self.do_defcvx(args)
1163
1164     end_defcv = end_deftypevr
1165
1166     def do_defcvx(self, args):
1167         self.write('<DT>')
1168         words = splitwords(args, 3)
1169         [category, classname, name], rest = words[:3], words[3:]
1170         self.expand('@b{%s}' % name)
1171         # If there are too many arguments, show them
1172         for word in rest: self.expand(' ' + word)
1173         #self.expand(' -- %s of @code{%s}' % (category, classname))
1174         self.write('\n<DD>')
1175         self.index('vr', '%s @r{on %s}' % (name, classname))
1176
1177     def bgn_defivar(self, args):
1178         self.bgn_defcv('{Instance Variable} ' + args)
1179     end_defivar = end_defcv
1180     def do_defivarx(self, args):
1181         self.do_defcvx('{Instance Variable} ' + args)
1182
1183     def bgn_defop(self, args):
1184         self.write('<DL>')
1185         self.do_defopx(args)
1186
1187     end_defop = end_defcv
1188
1189     def do_defopx(self, args):
1190         self.write('<DT>')
1191         words = splitwords(args, 3)
1192         [category, classname, name], rest = words[:3], words[3:]
1193         self.expand('@b{%s}' % name)
1194         for word in rest: self.expand(' ' + makevar(word))
1195         #self.expand(' -- %s of @code{%s}' % (category, classname))
1196         self.write('\n<DD>')
1197         self.index('fn', '%s @r{on %s}' % (name, classname))
1198
1199     def bgn_defmethod(self, args):
1200         self.bgn_defop('Method ' + args)
1201     end_defmethod = end_defop
1202     def do_defmethodx(self, args):
1203         self.do_defopx('Method ' + args)
1204
1205     # --- Ditto for data types ---
1206
1207     def bgn_deftp(self, args):
1208         self.write('<DL>')
1209         self.do_deftpx(args)
1210
1211     end_deftp = end_defcv
1212
1213     def do_deftpx(self, args):
1214         self.write('<DT>')
1215         words = splitwords(args, 2)
1216         [category, name], rest = words[:2], words[2:]
1217         self.expand('@b{%s}' % name)
1218         for word in rest: self.expand(' ' + word)
1219         #self.expand(' -- ' + category)
1220         self.write('\n<DD>')
1221         self.index('tp', name)
1222
1223     # --- Making Lists and Tables
1224
1225     def bgn_enumerate(self, args):
1226         if not args:
1227             self.write('<OL>\n')
1228             self.stackinfo[len(self.stack)] = '</OL>\n'
1229         else:
1230             self.itemnumber = args
1231             self.write('<UL>\n')
1232             self.stackinfo[len(self.stack)] = '</UL>\n'
1233     def end_enumerate(self):
1234         self.itemnumber = None
1235         self.write(self.stackinfo[len(self.stack) + 1])
1236         del self.stackinfo[len(self.stack) + 1]
1237
1238     def bgn_itemize(self, args):
1239         self.itemarg = args
1240         self.write('<UL>\n')
1241     def end_itemize(self):
1242         self.itemarg = None
1243         self.write('</UL>\n')
1244
1245     def bgn_table(self, args):
1246         self.itemarg = args
1247         self.write('<DL>\n')
1248     def end_table(self):
1249         self.itemarg = None
1250         self.write('</DL>\n')
1251
1252     def bgn_ftable(self, args):
1253         self.itemindex = 'fn'
1254         self.bgn_table(args)
1255     def end_ftable(self):
1256         self.itemindex = None
1257         self.end_table()
1258
1259     def do_item(self, args):
1260         if self.itemindex: self.index(self.itemindex, args)
1261         if self.itemarg:
1262             if self.itemarg[0] == '@' and self.itemarg[1:2] and \
1263                             self.itemarg[1] in string.letters:
1264                 args = self.itemarg + '{' + args + '}'
1265             else:
1266                 # some other character, e.g. '-'
1267                 args = self.itemarg + ' ' + args
1268         if self.itemnumber <> None:
1269             args = self.itemnumber + '. ' + args
1270             self.itemnumber = increment(self.itemnumber)
1271         if self.stack and self.stack[-1] == 'table':
1272             self.write('<DT>')
1273             self.expand(args)
1274             self.write('\n<DD>')
1275         else:
1276             self.write('<LI>')
1277             self.expand(args)
1278             self.write('  ')
1279     do_itemx = do_item # XXX Should suppress leading blank line
1280
1281     # --- Enumerations, displays, quotations ---
1282     # XXX Most of these should increase the indentation somehow
1283
1284     def bgn_quotation(self, args): self.write('<BLOCKQUOTE>')
1285     def end_quotation(self): self.write('</BLOCKQUOTE>\n')
1286
1287     def bgn_example(self, args):
1288         self.nofill = self.nofill + 1
1289         self.write('<PRE>')
1290     def end_example(self):
1291         self.write('</PRE>\n')
1292         self.nofill = self.nofill - 1
1293
1294     bgn_lisp = bgn_example # Synonym when contents are executable lisp code
1295     end_lisp = end_example
1296
1297     bgn_smallexample = bgn_example # XXX Should use smaller font
1298     end_smallexample = end_example
1299
1300     bgn_smalllisp = bgn_lisp # Ditto
1301     end_smalllisp = end_lisp
1302
1303     bgn_display = bgn_example
1304     end_display = end_example
1305
1306     bgn_format = bgn_display
1307     end_format = end_display
1308
1309     def do_exdent(self, args): self.expand(args + '\n')
1310     # XXX Should really mess with indentation
1311
1312     def bgn_flushleft(self, args):
1313         self.nofill = self.nofill + 1
1314         self.write('<PRE>\n')
1315     def end_flushleft(self):
1316         self.write('</PRE>\n')
1317         self.nofill = self.nofill - 1
1318
1319     def bgn_flushright(self, args):
1320         self.nofill = self.nofill + 1
1321         self.write('<ADDRESS COMPACT>\n')
1322     def end_flushright(self):
1323         self.write('</ADDRESS>\n')
1324         self.nofill = self.nofill - 1
1325
1326     def bgn_menu(self, args):
1327         self.write('<DIR>\n')
1328         self.write('  <STRONG><EM>Menu</EM></STRONG><P>\n')
1329     def end_menu(self):
1330         self.write('</DIR>\n')
1331
1332     def bgn_cartouche(self, args): pass
1333     def end_cartouche(self): pass
1334
1335     # --- Indices ---
1336
1337     def resetindex(self):
1338         self.noncodeindices = ['cp']
1339         self.indextitle = {}
1340         self.indextitle['cp'] = 'Concept'
1341         self.indextitle['fn'] = 'Function'
1342         self.indextitle['ky'] = 'Keyword'
1343         self.indextitle['pg'] = 'Program'
1344         self.indextitle['tp'] = 'Type'
1345         self.indextitle['vr'] = 'Variable'
1346         #
1347         self.whichindex = {}
1348         for name in self.indextitle.keys():
1349             self.whichindex[name] = []
1350
1351     def user_index(self, name, args):
1352         if self.whichindex.has_key(name):
1353             self.index(name, args)
1354         else:
1355             print '*** No index named', `name`
1356
1357     def do_cindex(self, args): self.index('cp', args)
1358     def do_findex(self, args): self.index('fn', args)
1359     def do_kindex(self, args): self.index('ky', args)
1360     def do_pindex(self, args): self.index('pg', args)
1361     def do_tindex(self, args): self.index('tp', args)
1362     def do_vindex(self, args): self.index('vr', args)
1363
1364     def index(self, name, args):
1365         self.whichindex[name].append((args, self.nodename))
1366
1367     def do_synindex(self, args):
1368         words = string.split(args)
1369         if len(words) <> 2:
1370             print '*** bad @synindex', args
1371             return
1372         [old, new] = words
1373         if not self.whichindex.has_key(old) or \
1374                   not self.whichindex.has_key(new):
1375             print '*** bad key(s) in @synindex', args
1376             return
1377         if old <> new and \
1378                   self.whichindex[old] is not self.whichindex[new]:
1379             inew = self.whichindex[new]
1380             inew[len(inew):] = self.whichindex[old]
1381             self.whichindex[old] = inew
1382     do_syncodeindex = do_synindex # XXX Should use code font
1383
1384     def do_printindex(self, args):
1385         words = string.split(args)
1386         for name in words:
1387             if self.whichindex.has_key(name):
1388                 self.prindex(name)
1389             else:
1390                 print '*** No index named', `name`
1391
1392     def prindex(self, name):
1393         iscodeindex = (name not in self.noncodeindices)
1394         index = self.whichindex[name]
1395         if not index: return
1396         if self.debugging:
1397             print '--- Generating', self.indextitle[name], 'index'
1398         #  The node already provides a title
1399         index1 = []
1400         junkprog = re.compile('^(@[a-z]+)?{')
1401         for key, node in index:
1402             sortkey = string.lower(key)
1403             # Remove leading `@cmd{' from sort key
1404             # -- don't bother about the matching `}'
1405             oldsortkey = sortkey
1406             while 1:
1407                 mo = junkprog.match(sortkey)
1408                 if not mo:
1409                     break
1410                 i = mo.end()
1411                 sortkey = sortkey[i:]
1412             index1.append((sortkey, key, node))
1413         del index[:]
1414         index1.sort()
1415         self.write('<DL COMPACT>\n')
1416         prevkey = prevnode = None
1417         for sortkey, key, node in index1:
1418             if (key, node) == (prevkey, prevnode):
1419                 continue
1420             if self.debugging > 1: print key, ':', node
1421             self.write('<DT>')
1422             if iscodeindex: key = '@code{' + key + '}'
1423             if key != prevkey:
1424                 self.expand(key)
1425             self.write('\n<DD><A HREF="%s">%s</A>\n' % (makefile(node), node))
1426             prevkey, prevnode = key, node
1427         self.write('</DL>\n')
1428
1429     # --- Final error reports ---
1430
1431     def report(self):
1432         if self.unknown:
1433             print '--- Unrecognized commands ---'
1434             cmds = self.unknown.keys()
1435             cmds.sort()
1436             for cmd in cmds:
1437                 print string.ljust(cmd, 20), self.unknown[cmd]
1438
1439
1440 class TexinfoParserHTML3(TexinfoParser):
1441
1442     COPYRIGHT_SYMBOL = "&copy;"
1443     FN_ID_PATTERN = "[%(id)s]"
1444     FN_SOURCE_PATTERN = '<A ID=footnoteref%(id)s ' \
1445                         'HREF="#footnotetext%(id)s">' + FN_ID_PATTERN + '</A>'
1446     FN_TARGET_PATTERN = '<FN ID=footnotetext%(id)s>\n' \
1447                         '<P><A HREF="#footnoteref%(id)s">' + FN_ID_PATTERN \
1448                         + '</A>\n%(text)s</P></FN>\n'
1449     FN_HEADER = '<DIV CLASS=footnotes>\n  <HR NOSHADE WIDTH=200>\n' \
1450                 '  <STRONG><EM>Footnotes</EM></STRONG>\n  <P>\n'
1451
1452     Node = HTML3Node
1453
1454     def bgn_quotation(self, args): self.write('<BQ>')
1455     def end_quotation(self): self.write('</BQ>\n')
1456
1457     def bgn_example(self, args):
1458         # this use of <CODE> would not be legal in HTML 2.0,
1459         # but is in more recent DTDs.
1460         self.nofill = self.nofill + 1
1461         self.write('<PRE CLASS=example><CODE>')
1462     def end_example(self):
1463         self.write("</CODE></PRE>\n")
1464         self.nofill = self.nofill - 1
1465
1466     def bgn_flushleft(self, args):
1467         self.nofill = self.nofill + 1
1468         self.write('<PRE CLASS=flushleft>\n')
1469
1470     def bgn_flushright(self, args):
1471         self.nofill = self.nofill + 1
1472         self.write('<DIV ALIGN=right CLASS=flushright><ADDRESS COMPACT>\n')
1473     def end_flushright(self):
1474         self.write('</ADDRESS></DIV>\n')
1475         self.nofill = self.nofill - 1
1476
1477     def bgn_menu(self, args):
1478         self.write('<UL PLAIN CLASS=menu>\n')
1479         self.write('  <LH>Menu</LH>\n')
1480     def end_menu(self):
1481         self.write('</UL>\n')
1482
1483
1484 # Put @var{} around alphabetic substrings
1485 def makevar(str):
1486     return '@var{'+str+'}'
1487
1488
1489 # Split a string in "words" according to findwordend
1490 def splitwords(str, minlength):
1491     words = []
1492     i = 0
1493     n = len(str)
1494     while i < n:
1495         while i < n and str[i] in ' \t\n': i = i+1
1496         if i >= n: break
1497         start = i
1498         i = findwordend(str, i, n)
1499         words.append(str[start:i])
1500     while len(words) < minlength: words.append('')
1501     return words
1502
1503
1504 # Find the end of a "word", matching braces and interpreting @@ @{ @}
1505 fwprog = re.compile('[@{} ]')
1506 def findwordend(str, i, n):
1507     level = 0
1508     while i < n:
1509         mo = fwprog.search(str, i)
1510         if not mo:
1511             break
1512         i = mo.start()
1513         c = str[i]; i = i+1
1514         if c == '@': i = i+1 # Next character is not special
1515         elif c == '{': level = level+1
1516         elif c == '}': level = level-1
1517         elif c == ' ' and level <= 0: return i-1
1518     return n
1519
1520
1521 # Convert a node name into a file name
1522 def makefile(nodename):
1523     return fixfunnychars(nodename) + '.html'
1524
1525
1526 # Characters that are perfectly safe in filenames and hyperlinks
1527 goodchars = string.letters + string.digits + '!@-=+.'
1528
1529 # Replace characters that aren't perfectly safe by dashes
1530 # Underscores are bad since Cern HTTPD treats them as delimiters for
1531 # encoding times, so you get mismatches if you compress your files:
1532 # a.html.gz will map to a_b.html.gz
1533 def fixfunnychars(addr):
1534     i = 0
1535     while i < len(addr):
1536         c = addr[i]
1537         if c not in goodchars:
1538             c = '-'
1539             addr = addr[:i] + c + addr[i+1:]
1540         i = i + len(c)
1541     return addr
1542
1543
1544 # Increment a string used as an enumeration
1545 def increment(s):
1546     if not s:
1547         return '1'
1548     for sequence in string.digits, string.lowercase, string.uppercase:
1549         lastc = s[-1]
1550         if lastc in sequence:
1551             i = string.index(sequence, lastc) + 1
1552             if i >= len(sequence):
1553                 if len(s) == 1:
1554                     s = sequence[0]*2
1555                     if s == '00':
1556                         s = '10'
1557                 else:
1558                     s = increment(s[:-1]) + sequence[0]
1559             else:
1560                 s = s[:-1] + sequence[i]
1561             return s
1562     return s # Don't increment
1563
1564
1565 def test():
1566     import sys
1567     debugging = 0
1568     print_headers = 0
1569     cont = 0
1570     html3 = 0
1571
1572     while sys.argv[1:2] == ['-d']:
1573         debugging = debugging + 1
1574         del sys.argv[1:2]
1575     if sys.argv[1] == '-p':
1576         print_headers = 1
1577         del sys.argv[1]
1578     if sys.argv[1] == '-c':
1579         cont = 1
1580         del sys.argv[1]
1581     if sys.argv[1] == '-3':
1582         html3 = 1
1583         del sys.argv[1]
1584     if len(sys.argv) <> 3:
1585         print 'usage: texi2html [-d [-d]] [-p] [-c] inputfile outputdirectory'
1586         sys.exit(2)
1587
1588     if html3:
1589         parser = TexinfoParserHTML3()
1590     else:
1591         parser = TexinfoParser()
1592     parser.cont = cont
1593     parser.debugging = debugging
1594     parser.print_headers = print_headers
1595
1596     file = sys.argv[1]
1597     parser.setdirname(sys.argv[2])
1598     if file == '-':
1599         fp = sys.stdin
1600     else:
1601         parser.setincludedir(os.path.dirname(file))
1602         try:
1603             fp = open(file, 'r')
1604         except IOError, msg:
1605             print file, ':', msg
1606             sys.exit(1)
1607     parser.parse(fp)
1608     fp.close()
1609     parser.report()
1610
1611
1612 if __name__ == "__main__":
1613     test()