#!/usr/bin/python -u## generate python wrappers from the XML API description# functions = {}enums = {} # { enumType: { enumConstant: enumValue } } import osimport sysimport string if __name__ == "__main__":    # launched as a script    srcPref = os.path.dirname(sys.argv[0])else:    # imported    srcPref = os.path.dirname(__file__) #########################################################################  That part if purely the API acquisition phase from the#  XML API description########################################################################import osimport xml.sax debug = 0 def getparser():    # Attach parser to an unmarshalling object. return both objects.    target = docParser()    parser = xml.sax.make_parser()    parser.setContentHandler(target)    return parser, target class docParser(xml.sax.handler.ContentHandler):    def __init__(self):        self._methodname = None        self._data = []        self.in_function = 0         self.startElement = self.start        self.endElement = self.end        self.characters = self.data     def close(self):        if debug:            print "close"     def getmethodname(self):        return self._methodname     def data(self, text):        if debug:            print "data %s" % text        self._data.append(text)     def start(self, tag, attrs):        if debug:            print "start %s, %s" % (tag, attrs)        if tag == 'function':            self._data = []            self.in_function = 1            self.function = None            self.function_cond = None            self.function_args = []            self.function_descr = None            self.function_return = None            self.function_file = None            if attrs.has_key('name'):                self.function = attrs['name']            if attrs.has_key('file'):                self.function_file = attrs['file']        elif tag == 'cond':            self._data = []        elif tag == 'info':            self._data = []        elif tag == 'arg':            if self.in_function == 1:                self.function_arg_name = None                self.function_arg_type = None                self.function_arg_info = None                if attrs.has_key('name'):                    self.function_arg_name = attrs['name']                if attrs.has_key('type'):                    self.function_arg_type = attrs['type']                if attrs.has_key('info'):                    self.function_arg_info = attrs['info']        elif tag == 'return':            if self.in_function == 1:                self.function_return_type = None                self.function_return_info = None                self.function_return_field = None                if attrs.has_key('type'):                    self.function_return_type = attrs['type']                if attrs.has_key('info'):                    self.function_return_info = attrs['info']                if attrs.has_key('field'):                    self.function_return_field = attrs['field']        elif tag == 'enum':            enum(attrs['type'],attrs['name'],attrs['value'])     def end(self, tag):        if debug:            print "end %s" % tag        if tag == 'function':            if self.function != None:                function(self.function, self.function_descr,                         self.function_return, self.function_args,                         self.function_file, self.function_cond)                self.in_function = 0        elif tag == 'arg':            if self.in_function == 1:                self.function_args.append([self.function_arg_name,                                           self.function_arg_type,                                           self.function_arg_info])        elif tag == 'return':            if self.in_function == 1:                self.function_return = [self.function_return_type,                                        self.function_return_info,                                        self.function_return_field]        elif tag == 'info':            str = ''            for c in self._data:                str = str + c            if self.in_function == 1:                self.function_descr = str        elif tag == 'cond':            str = ''            for c in self._data:                str = str + c            if self.in_function == 1:                self.function_cond = str                                def function(name, desc, ret, args, file, cond):    functions[name] = (desc, ret, args, file, cond) def enum(type, name, value):    if not enums.has_key(type):        enums[type] = {}    enums[type][name] = value #########################################################################  Some filtering rukes to drop functions/types which should not#  be exposed as-is on the Python interface######################################################################## skipped_modules = {    'xmlmemory': None,    'DOCBparser': None,    'SAX': None,    'hash': None,    'list': None,    'threads': None,#    'xpointer': None,}skipped_types = {    'int *': "usually a return type",    'xmlSAXHandlerPtr': "not the proper interface for SAX",    'htmlSAXHandlerPtr': "not the proper interface for SAX",    'xmlRMutexPtr': "thread specific, skipped",    'xmlMutexPtr': "thread specific, skipped",    'xmlGlobalStatePtr': "thread specific, skipped",    'xmlListPtr': "internal representation not suitable for python",    'xmlBufferPtr': "internal representation not suitable for python",    'FILE *': None,} #########################################################################  Table of remapping to/from the python type or class to the C#  counterpart.######################################################################## py_types = {    'void': (None, None, None, None),    'int':  ('i', None, "int", "int"),    'long':  ('l', None, "long", "long"),    'double':  ('d', None, "double", "double"),    'unsigned int':  ('i', None, "int", "int"),    'xmlChar':  ('c', None, "int", "int"),    'unsigned char *':  ('z', None, "charPtr", "char *"),    'char *':  ('z', None, "charPtr", "char *"),    'const char *':  ('z', None, "charPtrConst", "const char *"),    'xmlChar *':  ('z', None, "xmlCharPtr", "xmlChar *"),    'const xmlChar *':  ('z', None, "xmlCharPtrConst", "const xmlChar *"),    'xmlNodePtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'const xmlNodePtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'xmlNode *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'const xmlNode *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'xmlDtdPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'const xmlDtdPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'xmlDtd *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'const xmlDtd *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'xmlAttrPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'const xmlAttrPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'xmlAttr *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'const xmlAttr *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'xmlEntityPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'const xmlEntityPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'xmlEntity *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'const xmlEntity *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'xmlElementPtr':  ('O', "xmlElement", "xmlElementPtr", "xmlElementPtr"),    'const xmlElementPtr':  ('O', "xmlElement", "xmlElementPtr", "xmlElementPtr"),    'xmlElement *':  ('O', "xmlElement", "xmlElementPtr", "xmlElementPtr"),    'const xmlElement *':  ('O', "xmlElement", "xmlElementPtr", "xmlElementPtr"),    'xmlAttributePtr':  ('O', "xmlAttribute", "xmlAttributePtr", "xmlAttributePtr"),    'const xmlAttributePtr':  ('O', "xmlAttribute", "xmlAttributePtr", "xmlAttributePtr"),    'xmlAttribute *':  ('O', "xmlAttribute", "xmlAttributePtr", "xmlAttributePtr"),    'const xmlAttribute *':  ('O', "xmlAttribute", "xmlAttributePtr", "xmlAttributePtr"),    'xmlNsPtr':  ('O', "xmlNode", "xmlNsPtr", "xmlNsPtr"),    'const xmlNsPtr':  ('O', "xmlNode", "xmlNsPtr", "xmlNsPtr"),    'xmlNs *':  ('O', "xmlNode", "xmlNsPtr", "xmlNsPtr"),    'const xmlNs *':  ('O', "xmlNode", "xmlNsPtr", "xmlNsPtr"),    'xmlDocPtr':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),    'const xmlDocPtr':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),    'xmlDoc *':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),    'const xmlDoc *':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),    'htmlDocPtr':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),    'const htmlDocPtr':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),    'htmlDoc *':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),    'const htmlDoc *':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),    'htmlNodePtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'const htmlNodePtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'htmlNode *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'const htmlNode *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),    'xmlXPathContextPtr':  ('O', "xmlXPathContext", "xmlXPathContextPtr", "xmlXPathContextPtr"),    'xmlXPathContext *':  ('O', "xpathContext", "xmlXPathContextPtr", "xmlXPathContextPtr"),    'xmlXPathParserContextPtr':  ('O', "xmlXPathParserContext", "xmlXPathParserContextPtr", "xmlXPathParserContextPtr"),    'xmlParserCtxtPtr': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),    'xmlParserCtxt *': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),    'htmlParserCtxtPtr': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),    'htmlParserCtxt *': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),    'xmlValidCtxtPtr': ('O', "ValidCtxt", "xmlValidCtxtPtr", "xmlValidCtxtPtr"),    'xmlCatalogPtr': ('O', "catalog", "xmlCatalogPtr", "xmlCatalogPtr"),    'FILE *': ('O', "File", "FILEPtr", "FILE *"),    'xmlURIPtr': ('O', "URI", "xmlURIPtr", "xmlURIPtr"),    'xmlErrorPtr': ('O', "Error", "xmlErrorPtr", "xmlErrorPtr"),    'xmlOutputBufferPtr': ('O', "outputBuffer", "xmlOutputBufferPtr", "xmlOutputBufferPtr"),    'xmlParserInputBufferPtr': ('O', "inputBuffer", "xmlParserInputBufferPtr", "xmlParserInputBufferPtr"),    'xmlRegexpPtr': ('O', "xmlReg", "xmlRegexpPtr", "xmlRegexpPtr"),    'xmlTextReaderLocatorPtr': ('O', "xmlTextReaderLocator", "xmlTextReaderLocatorPtr", "xmlTextReaderLocatorPtr"),    'xmlTextReaderPtr': ('O', "xmlTextReader", "xmlTextReaderPtr", "xmlTextReaderPtr"),    'xmlRelaxNGPtr': ('O', "relaxNgSchema", "xmlRelaxNGPtr", "xmlRelaxNGPtr"),    'xmlRelaxNGParserCtxtPtr': ('O', "relaxNgParserCtxt", "xmlRelaxNGParserCtxtPtr", "xmlRelaxNGParserCtxtPtr"),    'xmlRelaxNGValidCtxtPtr': ('O', "relaxNgValidCtxt", "xmlRelaxNGValidCtxtPtr", "xmlRelaxNGValidCtxtPtr"),    'xmlSchemaPtr': ('O', "Schema", "xmlSchemaPtr", "xmlSchemaPtr"),    'xmlSchemaParserCtxtPtr': ('O', "SchemaParserCtxt", "xmlSchemaParserCtxtPtr", "xmlSchemaParserCtxtPtr"),    'xmlSchemaValidCtxtPtr': ('O', "SchemaValidCtxt", "xmlSchemaValidCtxtPtr", "xmlSchemaValidCtxtPtr"),} py_return_types = {    'xmlXPathObjectPtr':  ('O', "foo", "xmlXPathObjectPtr", "xmlXPathObjectPtr"),} unknown_types = {} foreign_encoding_args = (    'htmlCreateMemoryParserCtxt',    'htmlCtxtReadMemory',    'htmlParseChunk',    'htmlReadMemory',    'xmlCreateMemoryParserCtxt',    'xmlCtxtReadMemory',    'xmlCtxtResetPush',    'xmlParseChunk',    'xmlParseMemory',    'xmlReadMemory',    'xmlRecoverMemory',) #########################################################################  This part writes the C <-> Python stubs libxml2-py.[ch] and#  the table libxml2-export.c to add when registrering the Python module######################################################################## # Class methods which are written by hand in libxml.c but the Python-level# code is still automatically generated (so they are not in skip_function()).skip_impl = (    'xmlSaveFileTo',    'xmlSaveFormatFileTo',) def skip_function(name):    if name[0:12] == "xmlXPathWrap":        return 1    if name == "xmlFreeParserCtxt":        return 1    if name == "xmlCleanupParser":        return 1    if name == "xmlFreeTextReader":        return 1#    if name[0:11] == "xmlXPathNew":#        return 1    # the next function is defined in libxml.c    if name == "xmlRelaxNGFreeValidCtxt":        return 1    if name == "xmlFreeValidCtxt":        return 1    if name == "xmlSchemaFreeValidCtxt":        return 1 ## Those are skipped because the Const version is used of the bindings# instead.#    if name == "xmlTextReaderBaseUri":        return 1    if name == "xmlTextReaderLocalName":        return 1    if name == "xmlTextReaderName":        return 1    if name == "xmlTextReaderNamespaceUri":        return 1    if name == "xmlTextReaderPrefix":        return 1    if name == "xmlTextReaderXmlLang":        return 1    if name == "xmlTextReaderValue":        return 1    if name == "xmlOutputBufferClose": # handled by by the superclass        return 1    if name == "xmlOutputBufferFlush": # handled by by the superclass        return 1    if name == "xmlErrMemory":        return 1     if name == "xmlValidBuildContentModel":        return 1    if name == "xmlValidateElementDecl":        return 1    if name == "xmlValidateAttributeDecl":        return 1     return 0 def print_function_wrapper(name, output, export, include):    global py_types    global unknown_types    global functions    global skipped_modules     try:        (desc, ret, args, file, cond) = functions[name]    except:        print "failed to get function %s infos"        return     if skipped_modules.has_key(file):        return 0    if skip_function(name) == 1:        return 0    if name in skip_impl:        # Don't delete the function entry in the caller.        return 1     c_call = ""    format=""    format_args=""    c_args=""    c_return=""    c_convert=""    num_bufs=0    for arg in args:        # This should be correct        if arg[1][0:6] == "const ":            arg[1] = arg[1][6:]        c_args = c_args + "    %s %s;\n" % (arg[1], arg[0])        if py_types.has_key(arg[1]):            (f, t, n, c) = py_types[arg[1]]            if (f == 'z') and (name in foreign_encoding_args) and (num_bufs == 0):                f = 't#'            if f != None:                format = format + f            if t != None:                format_args = format_args + ", &pyobj_%s" % (arg[0])                c_args = c_args + "    PyObject *pyobj_%s;\n" % (arg[0])                c_convert = c_convert + \                   "    %s = (%s) Py%s_Get(pyobj_%s);\n" % (arg[0],                   arg[1], t, arg[0])            else:                format_args = format_args + ", &%s" % (arg[0])            if f == 't#':                format_args = format_args + ", &py_buffsize%d" % num_bufs                c_args = c_args + "    int py_buffsize%d;\n" % num_bufs                num_bufs = num_bufs + 1            if c_call != "":                c_call = c_call + ", "            c_call = c_call + "%s" % (arg[0])        else:            if skipped_types.has_key(arg[1]):                return 0            if unknown_types.has_key(arg[1]):                lst = unknown_types[arg[1]]                lst.append(name)            else:                unknown_types[arg[1]] = [name]            return -1    if format != "":        format = format + ":%s" % (name)     if ret[0] == 'void':        if file == "python_accessor":            if args[1][1] == "char *" or args[1][1] == "xmlChar *":                c_call = "\n    if (%s->%s != NULL) xmlFree(%s->%s);\n" % (                                 args[0][0], args[1][0], args[0][0], args[1][0])                c_call = c_call + "    %s->%s = (%s)xmlStrdup((const xmlChar *)%s);\n" % (args[0][0],                                 args[1][0], args[1][1], args[1][0])            else:                c_call = "\n    %s->%s = %s;\n" % (args[0][0], args[1][0],                                                   args[1][0])        else:            c_call = "\n    %s(%s);\n" % (name, c_call)        ret_convert = "    Py_INCREF(Py_None);\n    return(Py_None);\n"    elif py_types.has_key(ret[0]):        (f, t, n, c) = py_types[ret[0]]        c_return = "    %s c_retval;\n" % (ret[0])        if file == "python_accessor" and ret[2] != None:            c_call = "\n    c_retval = %s->%s;\n" % (args[0][0], ret[2])        else:            c_call = "\n    c_retval = %s(%s);\n" % (name, c_call)        ret_convert = "    py_retval = libxml_%sWrap((%s) c_retval);\n" % (n,c)        ret_convert = ret_convert + "    return(py_retval);\n"    elif py_return_types.has_key(ret[0]):        (f, t, n, c) = py_return_types[ret[0]]        c_return = "    %s c_retval;\n" % (ret[0])        c_call = "\n    c_retval = %s(%s);\n" % (name, c_call)        ret_convert = "    py_retval = libxml_%sWrap((%s) c_retval);\n" % (n,c)        ret_convert = ret_convert + "    return(py_retval);\n"    else:        if skipped_types.has_key(ret[0]):            return 0        if unknown_types.has_key(ret[0]):            lst = unknown_types[ret[0]]            lst.append(name)        else:            unknown_types[ret[0]] = [name]        return -1     if cond != None and cond != "":        include.write("#if %s\n" % cond)        export.write("#if %s\n" % cond)        output.write("#if %s\n" % cond)     include.write("PyObject * ")    include.write("libxml_%s(PyObject *self, PyObject *args);\n" % (name))     export.write("    { (char *)\"%s\", libxml_%s, METH_VARARGS, NULL },\n" %                 (name, name))     if file == "python":        # Those have been manually generated        if cond != None and cond != "":            include.write("#endif\n")            export.write("#endif\n")            output.write("#endif\n")        return 1    if file == "python_accessor" and ret[0] != "void" and ret[2] is None:        # Those have been manually generated        if cond != None and cond != "":            include.write("#endif\n")            export.write("#endif\n")            output.write("#endif\n")        return 1     output.write("PyObject *\n")    output.write("libxml_%s(PyObject *self ATTRIBUTE_UNUSED," % (name))    output.write(" PyObject *args")    if format == "":        output.write(" ATTRIBUTE_UNUSED")    output.write(") {\n")    if ret[0] != 'void':        output.write("    PyObject *py_retval;\n")    if c_return != "":        output.write(c_return)    if c_args != "":        output.write(c_args)    if format != "":        output.write("\n    if (!PyArg_ParseTuple(args, (char *)\"%s\"%s))\n" %                     (format, format_args))        output.write("        return(NULL);\n")    if c_convert != "":        output.write(c_convert)                                                                  output.write(c_call)    output.write(ret_convert)    output.write("}\n\n")    if cond != None and cond != "":        include.write("#endif /* %s */\n" % cond)        export.write("#endif /* %s */\n" % cond)        output.write("#endif /* %s */\n" % cond)    return 1

Lines 1–500 of 1187. Load more