First (rough) cut at HTML index generation in Python. Not very pretty, but

easier to work with than the Perl code.

Doc/tools/buildindex.py

@@ -0,0 +1,211 @@
+#! /usr/bin/env python
+
+"""
+"""
+__version__ = '$Revision$'
+
+import re
+import string
+import sys
+
+
+class Node:
+
+    __rmtt = re.compile(r"(.*)<tt>(.*)</tt>(.*)$", re.IGNORECASE)
+    __rmjunk = re.compile("<#\d+#>")
+
+    def __init__(self, link, str, seqno):
+        self.links = [link]
+        self.seqno = seqno
+        # remove <#\d+#> left in by moving the data out of LaTeX2HTML
+        str = self.__rmjunk.sub('', str)
+        # now remove <tt>...</tt> markup; contents remain.
+        if '<' in str:
+            m = self.__rmtt.match(str)
+            if m:
+                kstr = string.join(m.group(1, 2, 3), '')
+            else:
+                kstr = str
+        else:
+            kstr = str
+        kstr = string.lower(kstr)
+        # build up the text
+        self.text = []
+        parts = string.split(str, '!')
+        parts = map(string.split, parts, ['@'] * len(parts))
+        for entry in parts:
+            if len(entry) != 1:
+                key, text = entry
+            else:
+                text = entry[0]
+            self.text.append(text)
+        # Building the key must be separate since any <tt> has been stripped
+        # from the key, but can be avoided if both key and text sources are
+        # the same.
+        if kstr != str:
+            self.key = []
+            kparts = string.split(kstr, '!')
+            kparts = map(string.split, kparts, ['@'] * len(kparts))
+            for entry in kparts:
+                if len(entry) != 1:
+                    key, text = entry
+                else:
+                    key = entry[0]
+                self.key.append(key)
+        else:
+            self.key = self.text
+
+    def __cmp__(self, other):
+        """Comparison operator includes sequence number, for use with
+        list.sort()."""
+        return self.cmp_entry(other) or cmp(self.seqno, other.seqno)
+
+    def cmp_entry(self, other):
+        """Comparison 'operator' that ignores sequence number."""
+        for i in range(min(len(self.key), len(other.key))):
+            c = (cmp(self.key[i], other.key[i])
+                 or cmp(self.text[i], other.text[i]))
+            if c:
+                return c
+        return cmp(self.key, other.key)
+
+    def __repr__(self):
+        return "<Node for %s (%s)>" % (string.join(self.text, '!'), self.seqno)
+
+    def __str__(self):
+        return string.join(self.key, '!')
+
+    def dump(self):
+        return "%s\0%s###%s\n" \
+               % (string.join(self.links, "\0"),
+                  string.join(self.text, '!'),
+                  self.seqno)
+
+
+def load(fp):
+    nodes = []
+    rx = re.compile(r"(.*)\0(.*)###(.*)$")
+    while 1:
+        line = fp.readline()
+        if not line:
+            break
+        m = rx.match(line)
+        if m:
+            link, str, seqno = m.group(1, 2, 3)
+            nodes.append(Node(link, str, seqno))
+    return nodes
+
+
+def split_letters(nodes):
+    letter_groups = []
+    group = []
+    append = group.append
+    if nodes:
+        letter = nodes[0].key[0][0]
+        letter_groups.append((letter, group))
+        for node in nodes:
+            nletter = node.key[0][0]
+            if letter != nletter:
+                letter = nletter
+                group = []
+                letter_groups.append((letter, group))
+                append = group.append
+            append(node)
+    return letter_groups
+
+
+def format_nodes(nodes):
+    # Does not create multiple links to multiple targets for the same entry;
+    # uses a separate entry for each target.  This is a bug.
+    level = 0
+    strings = ["<dl compact>"]
+    append = strings.append
+    prev = None
+    for node in nodes:
+        nlevel = len(node.key) - 1
+        if nlevel > level:
+            if prev is None or node.key[level] != prev.key[level]:
+                append("%s\n<dl compact>" % node.text[level])
+            else:
+                append("<dl compact>")
+            level = nlevel
+        elif nlevel < level:
+            append("</dl>" * (level - len(node.key) + 1))
+            level = nlevel
+            if prev is not None and node.key[level] != prev.key[level]:
+                append("</dl>")
+            else:
+                append("<dl compact>")
+        elif level:
+            if node.key[level-1] != prev.key[level-1]:
+                append("</dl>\n%s<dl compact>"
+                       % node.text[level-1])
+        append("%s%s</a><br>" % (node.links[0], node.text[-1]))
+        for link in node.links[1:]:
+            strings[-1] = strings[-1][:-4] + ","
+            append(link + "[Link]</a><br>")
+        prev = node
+    append("</dl>" * (level + 1))
+    append("")
+    append("")
+    return string.join(strings, "\n")
+
+
+def format_letter(letter):
+    if letter == '.':
+        lettername = ". (dot)"
+    elif letter == '_':
+        lettername = "_ (underscore)"
+    else:
+        lettername = string.upper(letter)
+    return "<hr>\n<h2><a name=\"letter-%s\">%s</a></h2>\n\n" \
+           % (letter, lettername)
+
+
+def format_html(nodes):
+    letter_groups = split_letters(nodes)
+    items = []
+    for letter, nodes in letter_groups:
+        s = "<b><a href=\"#letter-%s\">%s</a></b>" % (letter, letter)
+        items.append(s)
+    s = "<hr><center>\n%s</center>\n" % string.join(items, " |\n")
+    for letter, nodes in letter_groups:
+        s = s + format_letter(letter) + format_nodes(nodes)
+    return s
+
+
+def collapse(nodes):
+    """Collapse sequences of nodes with matching keys into a single node.
+    Destructive."""
+    if len(nodes) < 2:
+        return
+    prev = nodes[0]
+    i = 1
+    while i < len(nodes):
+        node = nodes[i]
+        if not node.cmp_entry(prev):
+            prev.links.append(node.links[0])
+            del nodes[i]
+##             sys.stderr.write("collapsing %s\n" % `node`)
+        else:
+            i = i + 1
+            prev = node
+
+
+def dump(nodes, fp):
+    for node in nodes:
+        fp.write(node.dump())
+
+
+def main():
+    fn = sys.argv[1]
+    nodes = load(open(fn))
+    nodes.sort()
+    dump(nodes, open(fn + ".dump-1", "w"))
+    collapse(nodes)
+    dump(nodes, open(fn + ".dump-2", "w"))
+    sys.stdout.write(format_html(nodes))
+
+
+if __name__ == "__main__":
+    main()