' + self.title + '

', title, '

\n') prevlevels = [0] for level, title, node in self.contents: if level > maxlevel: continue if level > prevlevels[-1]: # can only advance one level at a time self.write(' '*prevlevels[-1], '

\n') prevlevels.append(level) elif level < prevlevels[-1]: # might drop back multiple levels while level < prevlevels[-1]: del prevlevels[-1] self.write(' '*prevlevels[-1], '\n') self.write(' '*level, '

') self.expand(title) self.write('\n') self.write('

\n') def do_hline(self, args): self.write('

') self.do_deffnx(args) def end_deffn(self): self.write('

') words = splitwords(args, 2) [category, name], rest = words[:2], words[2:] self.expand('@b{%s}' % name) for word in rest: self.expand(' ' + makevar(word)) #self.expand(' -- ' + category) self.write('\n

') self.index('fn', name) def bgn_defun(self, args): self.bgn_deffn('Function ' + args) end_defun = end_deffn def do_defunx(self, args): self.do_deffnx('Function ' + args) def bgn_defmac(self, args): self.bgn_deffn('Macro ' + args) end_defmac = end_deffn def do_defmacx(self, args): self.do_deffnx('Macro ' + args) def bgn_defspec(self, args): self.bgn_deffn('{Special Form} ' + args) end_defspec = end_deffn def do_defspecx(self, args): self.do_deffnx('{Special Form} ' + args) def bgn_defvr(self, args): self.write('

') words = splitwords(args, 2) [category, name], rest = words[:2], words[2:] self.expand('@code{%s}' % name) # If there are too many arguments, show them for word in rest: self.expand(' ' + word) #self.expand(' -- ' + category) self.write('\n

') self.index('vr', name) def bgn_defvar(self, args): self.bgn_defvr('Variable ' + args) end_defvar = end_defvr def do_defvarx(self, args): self.do_defvrx('Variable ' + args) def bgn_defopt(self, args): self.bgn_defvr('{User Option} ' + args) end_defopt = end_defvr def do_defoptx(self, args): self.do_defvrx('{User Option} ' + args) # --- Ditto for typed languages --- def bgn_deftypefn(self, args): self.write('

') words = splitwords(args, 3) [category, datatype, name], rest = words[:3], words[3:] self.expand('@code{%s} @b{%s}' % (datatype, name)) for word in rest: self.expand(' ' + makevar(word)) #self.expand(' -- ' + category) self.write('\n

') self.index('fn', name) def bgn_deftypefun(self, args): self.bgn_deftypefn('Function ' + args) end_deftypefun = end_deftypefn def do_deftypefunx(self, args): self.do_deftypefnx('Function ' + args) def bgn_deftypevr(self, args): self.write('

') words = splitwords(args, 3) [category, datatype, name], rest = words[:3], words[3:] self.expand('@code{%s} @b{%s}' % (datatype, name)) # If there are too many arguments, show them for word in rest: self.expand(' ' + word) #self.expand(' -- ' + category) self.write('\n

') self.index('fn', name) def bgn_deftypevar(self, args): self.bgn_deftypevr('Variable ' + args) end_deftypevar = end_deftypevr def do_deftypevarx(self, args): self.do_deftypevrx('Variable ' + args) # --- Ditto for object-oriented languages --- def bgn_defcv(self, args): self.write('

') words = splitwords(args, 3) [category, classname, name], rest = words[:3], words[3:] self.expand('@b{%s}' % name) # If there are too many arguments, show them for word in rest: self.expand(' ' + word) #self.expand(' -- %s of @code{%s}' % (category, classname)) self.write('\n

') self.index('vr', '%s @r{on %s}' % (name, classname)) def bgn_defivar(self, args): self.bgn_defcv('{Instance Variable} ' + args) end_defivar = end_defcv def do_defivarx(self, args): self.do_defcvx('{Instance Variable} ' + args) def bgn_defop(self, args): self.write('

') words = splitwords(args, 3) [category, classname, name], rest = words[:3], words[3:] self.expand('@b{%s}' % name) for word in rest: self.expand(' ' + makevar(word)) #self.expand(' -- %s of @code{%s}' % (category, classname)) self.write('\n

') self.index('fn', '%s @r{on %s}' % (name, classname)) def bgn_defmethod(self, args): self.bgn_defop('Method ' + args) end_defmethod = end_defop def do_defmethodx(self, args): self.do_defopx('Method ' + args) # --- Ditto for data types --- def bgn_deftp(self, args): self.write('

') words = splitwords(args, 2) [category, name], rest = words[:2], words[2:] self.expand('@b{%s}' % name) for word in rest: self.expand(' ' + word) #self.expand(' -- ' + category) self.write('\n

') self.index('tp', name) # --- Making Lists and Tables def bgn_enumerate(self, args): if not args: self.write('

\n') self.stackinfo[len(self.stack)] = '\n' else: self.itemnumber = args self.write('

\n') self.stackinfo[len(self.stack)] = '\n' def end_enumerate(self): self.itemnumber = None self.write(self.stackinfo[len(self.stack) + 1]) del self.stackinfo[len(self.stack) + 1] def bgn_itemize(self, args): self.itemarg = args self.write('

\n') def end_itemize(self): self.itemarg = None self.write('\n') def bgn_table(self, args): self.itemarg = args self.write('

\n') def end_table(self): self.itemarg = None self.write('\n') def bgn_ftable(self, args): self.itemindex = 'fn' self.bgn_table(args) def end_ftable(self): self.itemindex = None self.end_table() def do_item(self, args): if self.itemindex: self.index(self.itemindex, args) if self.itemarg: if self.itemarg[0] == '@' and self.itemarg[1:2] and \ self.itemarg[1] in string.letters: args = self.itemarg + '{' + args + '}' else: # some other character, e.g. '-' args = self.itemarg + ' ' + args if self.itemnumber <> None: args = self.itemnumber + '. ' + args self.itemnumber = increment(self.itemnumber) if self.stack and self.stack[-1] == 'table': self.write('

') self.expand(args) self.write('\n

') else: self.write('

') self.expand(args) self.write(' ') do_itemx = do_item # XXX Should suppress leading blank line # --- Enumerations, displays, quotations --- # XXX Most of these should increase the indentation somehow def bgn_quotation(self, args): self.write('

') def end_quotation(self): self.write('

\n') def bgn_example(self, args): self.nofill = self.nofill + 1 self.write('

')
    def end_example(self):
	self.write('

\n') self.nofill = self.nofill - 1 bgn_lisp = bgn_example # Synonym when contents are executable lisp code end_lisp = end_example bgn_smallexample = bgn_example # XXX Should use smaller font end_smallexample = end_example bgn_smalllisp = bgn_lisp # Ditto end_smalllisp = end_lisp bgn_display = bgn_example end_display = end_example bgn_format = bgn_display end_format = end_display def do_exdent(self, args): self.expand(args + '\n') # XXX Should really mess with indentation def bgn_flushleft(self, args): self.nofill = self.nofill + 1 self.write('

\n')
    def end_flushleft(self):
	self.write('

\n') self.nofill = self.nofill - 1 def bgn_flushright(self, args): self.nofill = self.nofill + 1 self.write('

\n') def end_flushright(self): self.write('

\n') self.nofill = self.nofill - 1 def bgn_menu(self, args): self.write('\n') self.write(' Menu

\n') def end_menu(self): self.write('

\n') def bgn_cartouche(self, args): pass def end_cartouche(self): pass # --- Indices --- def resetindex(self): self.noncodeindices = ['cp'] self.indextitle = {} self.indextitle['cp'] = 'Concept' self.indextitle['fn'] = 'Function' self.indextitle['ky'] = 'Keyword' self.indextitle['pg'] = 'Program' self.indextitle['tp'] = 'Type' self.indextitle['vr'] = 'Variable' # self.whichindex = {} for name in self.indextitle.keys(): self.whichindex[name] = [] def user_index(self, name, args): if self.whichindex.has_key(name): self.index(name, args) else: print '*** No index named', `name` def do_cindex(self, args): self.index('cp', args) def do_findex(self, args): self.index('fn', args) def do_kindex(self, args): self.index('ky', args) def do_pindex(self, args): self.index('pg', args) def do_tindex(self, args): self.index('tp', args) def do_vindex(self, args): self.index('vr', args) def index(self, name, args): self.whichindex[name].append(args, self.nodename) def do_synindex(self, args): words = string.split(args) if len(words) <> 2: print '*** bad @synindex', args return [old, new] = words if not self.whichindex.has_key(old) or \ not self.whichindex.has_key(new): print '*** bad key(s) in @synindex', args return if old <> new and \ self.whichindex[old] is not self.whichindex[new]: inew = self.whichindex[new] inew[len(inew):] = self.whichindex[old] self.whichindex[old] = inew do_syncodeindex = do_synindex # XXX Should use code font def do_printindex(self, args): words = string.split(args) for name in words: if self.whichindex.has_key(name): self.prindex(name) else: print '*** No index named', `name` def prindex(self, name): iscodeindex = (name not in self.noncodeindices) index = self.whichindex[name] if not index: return if self.debugging: print '--- Generating', self.indextitle[name], 'index' # The node already provides a title index1 = [] junkprog = regex.compile('^\(@[a-z]+\)?{') for key, node in index: sortkey = string.lower(key) # Remove leading `@cmd{' from sort key # -- don't bother about the matching `}' oldsortkey = sortkey while 1: i = junkprog.match(sortkey) if i < 0: break sortkey = sortkey[i:] index1.append(sortkey, key, node) del index[:] index1.sort() self.write('

') if iscodeindex: key = '@code{' + key + '}' if key != prevkey: self.expand(key) self.write('\n: %s\n' % (makefile(node), node)) prevkey, prevnode = key, node self.write('

\n') # --- Final error reports --- def report(self): if self.unknown: print '--- Unrecognized commands ---' cmds = self.unknown.keys() cmds.sort() for cmd in cmds: print string.ljust(cmd, 20), self.unknown[cmd] class TexinfoParserHTML3(TexinfoParser): COPYRIGHT_SYMBOL = "©" FN_ID_PATTERN = "[%(id)s]" FN_SOURCE_PATTERN = '' + FN_ID_PATTERN + '' FN_TARGET_PATTERN = '\n' \ '

' + FN_ID_PATTERN \ + '\n%(text)s

\n' FN_HEADER = '

\n' \ ' Footnotes\n

\n' Node = HTML3Node def bgn_quotation(self, args): self.write('') def end_quotation(self): self.write('\n') def bgn_example(self, args): # this use of would not be legal in HTML 2.0, # but is in more recent DTDs. self.nofill = self.nofill + 1 self.write('

')
    def end_example(self):
	self.write("

\n")
	self.nofill = self.nofill - 1

    def bgn_flushleft(self, args):
	self.nofill = self.nofill + 1
	self.write('\n')

    def bgn_flushright(self, args):
	self.nofill = self.nofill + 1
	self.write('\n')
    def end_flushright(self):
	self.write('\n')
	self.nofill = self.nofill - 1

    def bgn_menu(self, args):
	self.write('\n')
	self.write('  Menu\n')
    def end_menu(self):
	self.write('\n')


# Put @var{} around alphabetic substrings
def makevar(str):
    return '@var{'+str+'}'


# Split a string in "words" according to findwordend
def splitwords(str, minlength):
    words = []
    i = 0
    n = len(str)
    while i < n:
	while i < n and str[i] in ' \t\n': i = i+1
	if i >= n: break
	start = i
	i = findwordend(str, i, n)
	words.append(str[start:i])
    while len(words) < minlength: words.append('')
    return words


# Find the end of a "word", matching braces and interpreting @@ @{ @}
fwprog = regex.compile('[@{} ]')
def findwordend(str, i, n):
    level = 0
    while i < n:
	i = fwprog.search(str, i)
	if i < 0: break
	c = str[i]; i = i+1
	if c == '@': i = i+1 # Next character is not special
	elif c == '{': level = level+1
	elif c == '}': level = level-1
	elif c == ' ' and level <= 0: return i-1
    return n


# Convert a node name into a file name
def makefile(nodename):
    return fixfunnychars(nodename) + '.html'


# Characters that are perfectly safe in filenames and hyperlinks
goodchars = string.letters + string.digits + '!@-=+.'

# Replace characters that aren't perfectly safe by dashes
# Underscores are bad since Cern HTTPD treats them as delimiters for
# encoding times, so you get mismatches if you compress your files:
# a.html.gz will map to a_b.html.gz
def fixfunnychars(addr):
    i = 0
    while i < len(addr):
	c = addr[i]
	if c not in goodchars:
	    c = '-'
	    addr = addr[:i] + c + addr[i+1:]
	i = i + len(c)
    return addr


# Increment a string used as an enumeration
def increment(s):
    if not s:
	return '1'
    for sequence in string.digits, string.lowercase, string.uppercase:
	lastc = s[-1]
	if lastc in sequence:
	    i = string.index(sequence, lastc) + 1
	    if i >= len(sequence):
		if len(s) == 1:
		    s = sequence[0]*2
		    if s == '00':
			s = '10'
		else:
		    s = increment(s[:-1]) + sequence[0]
	    else:
		s = s[:-1] + sequence[i]
	    return s
    return s # Don't increment


def test():
    import sys
    debugging = 0
    print_headers = 0
    cont = 0
    html3 = 0
   
    while sys.argv[1:2] == ['-d']:
	debugging = debugging + 1
	del sys.argv[1:2]
    if sys.argv[1] == '-p':
	print_headers = 1
	del sys.argv[1]
    if sys.argv[1] == '-c':
	cont = 1
	del sys.argv[1]
    if sys.argv[1] == '-3':
	html3 = 1
	del sys.argv[1]
    if len(sys.argv) <> 3:
	print 'usage: texi2html [-d [-d]] [-p] [-c] inputfile outputdirectory'
	sys.exit(2)

    if html3:
	parser = TexinfoParserHTML3()
    else:
	parser = TexinfoParser()
    parser.cont = cont
    parser.debugging = debugging
    parser.print_headers = print_headers

    file = sys.argv[1]
    parser.setdirname(sys.argv[2])
    if file == '-':
	fp = sys.stdin
    else:
	parser.setincludedir(os.path.dirname(file))
	try:
	    fp = open(file, 'r')
	except IOError, msg:
	    print file, ':', msg
	    sys.exit(1)
    parser.parse(fp)
    fp.close()
    parser.report()


if __name__ == "__main__":
    test()