self.write("(%s\n" % entry.outputname)                        self.err_write("--- text: %s\n" % `pentry.text`)                        self.write("-%s\n" % encode(pentry.text))                    elif pentry.type == "entityref":                        self.write("&%s\n" % pentry.name)                if entry.outputname:                    if not opened:                        self.write("(%s\n" % entry.outputname)                        stack.append(entry.name)                    if not implied_content:                        self.write(")%s\n" % entry.outputname)                        stack.pop()                continue            if line[0] == endchar and not stack:                self.line = line[1:]                return self.line            if line[0] == "}":                # end of macro or group                macroname = stack[-1]                if macroname:                    conversion = self.table.get(macroname)                    if conversion.outputname:                        # otherwise, it was just a bare group                        self.write(")%s\n" % conversion.outputname)                del stack[-1]                line = line[1:]                continue            if line[0] == "{":                stack.append("")                line = line[1:]                continue            if line[0] == "\\" and line[1] in ESCAPED_CHARS:                self.write("-%s\n" % encode(line[1]))                line = line[2:]                continue            if line[:2] == r"\\":                self.write("(BREAK\n)BREAK\n")                line = line[2:]                continue            m = _text_rx.match(line)            if m:                text = encode(m.group())                self.write("-%s\n" % text)                line = line[m.end():]                continue            # special case because of \item[]            # XXX can we axe this???            if line[0] == "]":                self.write("-]\n")                line = line[1:]                continue            # avoid infinite loops            extra = ""            if len(line) > 100:                extra = "..."            raise LaTeXFormatError("could not identify markup: %s%s"                                   % (`line[:100]`, extra))        while stack:            entry = self.get_entry(stack[-1])            if entry.closes:                self.write(")%s\n-%s\n" % (entry.outputname, encode("\n")))                del stack[-1]            else:                break        if stack:            raise LaTeXFormatError("elements remain on stack: "                                   + string.join(stack, ", "))        # otherwise we just ran out of input here...    def start_macro(self, name):        conversion = self.get_entry(name)        parameters = conversion.parameters        optional = parameters and parameters[0].optional        return parameters, optional, conversion.empty, conversion.environment    def get_entry(self, name):        entry = self.table.get(name)        if entry is None:            self.err_write("get_entry(%s) failing; building default entry!"                           % `name`)            # not defined; build a default entry:            entry = TableEntry(name)            entry.has_content = 1            entry.parameters.append(Parameter("content"))            self.table[name] = entry        return entry    def get_env_entry(self, name):        entry = self.table.get(name)        if entry is None:            # not defined; build a default entry:            entry = TableEntry(name, 1)            entry.has_content = 1            entry.parameters.append(Parameter("content"))            entry.parameters[-1].implied = 1            self.table[name] = entry        elif not entry.environment:            raise LaTeXFormatError(                name + " is defined as a macro; expected environment")        return entry    def dump_attr(self, pentry, value):        if not (pentry.name and value):            return        if _token_rx.match(value):            dtype = "TOKEN"        else:            dtype = "CDATA"        self.write("A%s %s %s\n" % (pentry.name, dtype, encode(value)))def convert(ifp, ofp, table):    c = Conversion(ifp, ofp, table)    try:        c.convert()    except IOError, (err, msg):        if err != errno.EPIPE:            raisedef skip_white(line):    while line and line[0] in " %\n\t\r":        line = string.lstrip(line[1:])    return lineclass TableEntry:    def __init__(self, name, environment=0):        self.name = name        self.outputname = name        self.environment = environment        self.empty = not environment        self.has_content = 0        self.verbatim = 0        self.auto_close = 0        self.parameters = []        self.closes = []        self.endcloses = []class Parameter:    def __init__(self, type, name=None, optional=0):        self.type = type        self.name = name        self.optional = optional        self.text = ''        self.implied = 0class TableParser(XMLParser):    def __init__(self, table=None):        if table is None:            table = {}        self.__table = table        self.__current = None        self.__buffer = ''        XMLParser.__init__(self)    def get_table(self):        for entry in self.__table.values():            if entry.environment and not entry.has_content:                p = Parameter("content")                p.implied = 1                entry.parameters.append(p)                entry.has_content = 1        return self.__table    def start_environment(self, attrs):        name = attrs["name"]        self.__current = TableEntry(name, environment=1)        self.__current.verbatim = attrs.get("verbatim") == "yes"        if attrs.has_key("outputname"):            self.__current.outputname = attrs.get("outputname")        self.__current.endcloses = string.split(attrs.get("endcloses", ""))    def end_environment(self):        self.end_macro()    def start_macro(self, attrs):        name = attrs["name"]        self.__current = TableEntry(name)        self.__current.closes = string.split(attrs.get("closes", ""))        if attrs.has_key("outputname"):            self.__current.outputname = attrs.get("outputname")    def end_macro(self):        self.__table[self.__current.name] = self.__current        self.__current = None    def start_attribute(self, attrs):        name = attrs.get("name")        optional = attrs.get("optional") == "yes"        if name:            p = Parameter("attribute", name, optional=optional)        else:            p = Parameter("attribute", optional=optional)        self.__current.parameters.append(p)        self.__buffer = ''    def end_attribute(self):        self.__current.parameters[-1].text = self.__buffer    def start_entityref(self, attrs):        name = attrs["name"]        p = Parameter("entityref", name)        self.__current.parameters.append(p)    def start_child(self, attrs):        name = attrs["name"]        p = Parameter("child", name, attrs.get("optional") == "yes")        self.__current.parameters.append(p)        self.__current.empty = 0    def start_content(self, attrs):        p = Parameter("content")        p.implied = attrs.get("implied") == "yes"        if self.__current.environment:            p.implied = 1        self.__current.parameters.append(p)        self.__current.has_content = 1        self.__current.empty = 0    def start_text(self, attrs):        self.__current.empty = 0        self.__buffer = ''    def end_text(self):        p = Parameter("text")        p.text = self.__buffer        self.__current.parameters.append(p)    def handle_data(self, data):        self.__buffer = self.__buffer + datadef load_table(fp, table=None):    parser = TableParser(table=table)    parser.feed(fp.read())    parser.close()    return parser.get_table()def main():    global DEBUG    #    opts, args = getopt.getopt(sys.argv[1:], "D", ["debug"])    for opt, arg in opts:        if opt in ("-D", "--debug"):            DEBUG = DEBUG + 1    if len(args) == 0:        ifp = sys.stdin        ofp = sys.stdout    elif len(args) == 1:        ifp = open(args)        ofp = sys.stdout    elif len(args) == 2:        ifp = open(args[0])        ofp = open(args[1], "w")    else:        usage()        sys.exit(2)    table = load_table(open(os.path.join(sys.path[0], 'conversion.xml')))    convert(ifp, ofp, table)if __name__ == "__main__":    main()