python/generator.py

   1 #!/usr/bin/python -u
   2 #
   3 # generate python wrappers from the XML API description
   4 #
   5
   6 functions = {}
   7 enums = {} # { enumType: { enumConstant: enumValue } }
   8
   9 import os
  10 import sys
  11 import string
  12
  13 if __name__ == "__main__":
  14     # launched as a script
  15     srcPref = os.path.dirname(sys.argv[0])
  16 else:
  17     # imported
  18     srcPref = os.path.dirname(__file__)
  19
  20 #######################################################################
  21 #
  22 #  That part if purely the API acquisition phase from the
  23 #  XML API description
  24 #
  25 #######################################################################
  26 import os
  27 import xml.sax
  28
  29 debug = 0
  30
  31 def getparser():
  32     # Attach parser to an unmarshalling object. return both objects.
  33     target = docParser()
  34     parser = xml.sax.make_parser()
  35     parser.setContentHandler(target)
  36     return parser, target
  37
  38 class docParser(xml.sax.handler.ContentHandler):
  39     def __init__(self):
  40         self._methodname = None
  41         self._data = []
  42         self.in_function = 0
  43
  44         self.startElement = self.start
  45         self.endElement = self.end
  46         self.characters = self.data
  47
  48     def close(self):
  49         if debug:
  50             print("close")
  51
  52     def getmethodname(self):
  53         return self._methodname
  54
  55     def data(self, text):
  56         if debug:
  57             print("data %s" % text)
  58         self._data.append(text)
  59
  60     def start(self, tag, attrs):
  61         if debug:
  62             print("start %s, %s" % (tag, attrs))
  63         if tag == 'function':
  64             self._data = []
  65             self.in_function = 1
  66             self.function = None
  67             self.function_cond = None
  68             self.function_args = []
  69             self.function_descr = None
  70             self.function_return = None
  71             self.function_file = None
  72             if 'name' in attrs.keys():
  73                 self.function = attrs['name']
  74             if 'file' in attrs.keys():
  75                 self.function_file = attrs['file']
  76         elif tag == 'cond':
  77             self._data = []
  78         elif tag == 'info':
  79             self._data = []
  80         elif tag == 'arg':
  81             if self.in_function == 1:
  82                 self.function_arg_name = None
  83                 self.function_arg_type = None
  84                 self.function_arg_info = None
  85                 if 'name' in attrs.keys():
  86                     self.function_arg_name = attrs['name']
  87                 if 'type' in attrs.keys():
  88                     self.function_arg_type = attrs['type']
  89                 if 'info' in attrs.keys():
  90                     self.function_arg_info = attrs['info']
  91         elif tag == 'return':
  92             if self.in_function == 1:
  93                 self.function_return_type = None
  94                 self.function_return_info = None
  95                 self.function_return_field = None
  96                 if 'type' in attrs.keys():
  97                     self.function_return_type = attrs['type']
  98                 if 'info' in attrs.keys():
  99                     self.function_return_info = attrs['info']
 100                 if 'field' in attrs.keys():
 101                     self.function_return_field = attrs['field']
 102         elif tag == 'enum':
 103             enum(attrs['type'],attrs['name'],attrs['value'])
 104
 105     def end(self, tag):
 106         if debug:
 107             print("end %s" % tag)
 108         if tag == 'function':
 109             if self.function != None:
 110                 function(self.function, self.function_descr,
 111                          self.function_return, self.function_args,
 112                          self.function_file, self.function_cond)
 113                 self.in_function = 0
 114         elif tag == 'arg':
 115             if self.in_function == 1:
 116                 self.function_args.append([self.function_arg_name,
 117                                            self.function_arg_type,
 118                                            self.function_arg_info])
 119         elif tag == 'return':
 120             if self.in_function == 1:
 121                 self.function_return = [self.function_return_type,
 122                                         self.function_return_info,
 123                                         self.function_return_field]
 124         elif tag == 'info':
 125             str = ''
 126             for c in self._data:
 127                 str = str + c
 128             if self.in_function == 1:
 129                 self.function_descr = str
 130         elif tag == 'cond':
 131             str = ''
 132             for c in self._data:
 133                 str = str + c
 134             if self.in_function == 1:
 135                 self.function_cond = str
 136
 137
 138 def function(name, desc, ret, args, file, cond):
 139     functions[name] = (desc, ret, args, file, cond)
 140
 141 def enum(type, name, value):
 142     if type not in enums:
 143         enums[type] = {}
 144     enums[type][name] = value
 145
 146 #######################################################################
 147 #
 148 #  Some filtering rukes to drop functions/types which should not
 149 #  be exposed as-is on the Python interface
 150 #
 151 #######################################################################
 152
 153 skipped_modules = {
 154     'xmlmemory': None,
 155     'DOCBparser': None,
 156     'SAX': None,
 157     'hash': None,
 158     'list': None,
 159     'threads': None,
 160 #    'xpointer': None,
 161 }
 162 skipped_types = {
 163     'int *': "usually a return type",
 164     'xmlSAXHandlerPtr': "not the proper interface for SAX",
 165     'htmlSAXHandlerPtr': "not the proper interface for SAX",
 166     'xmlRMutexPtr': "thread specific, skipped",
 167     'xmlMutexPtr': "thread specific, skipped",
 168     'xmlGlobalStatePtr': "thread specific, skipped",
 169     'xmlListPtr': "internal representation not suitable for python",
 170     'xmlBufferPtr': "internal representation not suitable for python",
 171     'FILE *': None,
 172 }
 173
 174 #######################################################################
 175 #
 176 #  Table of remapping to/from the python type or class to the C
 177 #  counterpart.
 178 #
 179 #######################################################################
 180
 181 py_types = {
 182     'void': (None, None, None, None),
 183     'int':  ('i', None, "int", "int"),
 184     'long':  ('l', None, "long", "long"),
 185     'double':  ('d', None, "double", "double"),
 186     'unsigned int':  ('i', None, "int", "int"),
 187     'xmlChar':  ('c', None, "int", "int"),
 188     'unsigned char *':  ('z', None, "charPtr", "char *"),
 189     'char *':  ('z', None, "charPtr", "char *"),
 190     'const char *':  ('z', None, "charPtrConst", "const char *"),
 191     'xmlChar *':  ('z', None, "xmlCharPtr", "xmlChar *"),
 192     'const xmlChar *':  ('z', None, "xmlCharPtrConst", "const xmlChar *"),
 193     'xmlNodePtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 194     'const xmlNodePtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 195     'xmlNode *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 196     'const xmlNode *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 197     'xmlDtdPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 198     'const xmlDtdPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 199     'xmlDtd *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 200     'const xmlDtd *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 201     'xmlAttrPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 202     'const xmlAttrPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 203     'xmlAttr *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 204     'const xmlAttr *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 205     'xmlEntityPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 206     'const xmlEntityPtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 207     'xmlEntity *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 208     'const xmlEntity *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 209     'xmlElementPtr':  ('O', "xmlElement", "xmlElementPtr", "xmlElementPtr"),
 210     'const xmlElementPtr':  ('O', "xmlElement", "xmlElementPtr", "xmlElementPtr"),
 211     'xmlElement *':  ('O', "xmlElement", "xmlElementPtr", "xmlElementPtr"),
 212     'const xmlElement *':  ('O', "xmlElement", "xmlElementPtr", "xmlElementPtr"),
 213     'xmlAttributePtr':  ('O', "xmlAttribute", "xmlAttributePtr", "xmlAttributePtr"),
 214     'const xmlAttributePtr':  ('O', "xmlAttribute", "xmlAttributePtr", "xmlAttributePtr"),
 215     'xmlAttribute *':  ('O', "xmlAttribute", "xmlAttributePtr", "xmlAttributePtr"),
 216     'const xmlAttribute *':  ('O', "xmlAttribute", "xmlAttributePtr", "xmlAttributePtr"),
 217     'xmlNsPtr':  ('O', "xmlNode", "xmlNsPtr", "xmlNsPtr"),
 218     'const xmlNsPtr':  ('O', "xmlNode", "xmlNsPtr", "xmlNsPtr"),
 219     'xmlNs *':  ('O', "xmlNode", "xmlNsPtr", "xmlNsPtr"),
 220     'const xmlNs *':  ('O', "xmlNode", "xmlNsPtr", "xmlNsPtr"),
 221     'xmlDocPtr':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),
 222     'const xmlDocPtr':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),
 223     'xmlDoc *':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),
 224     'const xmlDoc *':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),
 225     'htmlDocPtr':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),
 226     'const htmlDocPtr':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),
 227     'htmlDoc *':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),
 228     'const htmlDoc *':  ('O', "xmlNode", "xmlDocPtr", "xmlDocPtr"),
 229     'htmlNodePtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 230     'const htmlNodePtr':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 231     'htmlNode *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 232     'const htmlNode *':  ('O', "xmlNode", "xmlNodePtr", "xmlNodePtr"),
 233     'xmlXPathContextPtr':  ('O', "xmlXPathContext", "xmlXPathContextPtr", "xmlXPathContextPtr"),
 234     'xmlXPathContext *':  ('O', "xpathContext", "xmlXPathContextPtr", "xmlXPathContextPtr"),
 235     'xmlXPathParserContextPtr':  ('O', "xmlXPathParserContext", "xmlXPathParserContextPtr", "xmlXPathParserContextPtr"),
 236     'xmlParserCtxtPtr': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),
 237     'xmlParserCtxt *': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),
 238     'htmlParserCtxtPtr': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),
 239     'htmlParserCtxt *': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),
 240     'xmlValidCtxtPtr': ('O', "ValidCtxt", "xmlValidCtxtPtr", "xmlValidCtxtPtr"),
 241     'xmlCatalogPtr': ('O', "catalog", "xmlCatalogPtr", "xmlCatalogPtr"),
 242     'FILE *': ('O', "File", "FILEPtr", "FILE *"),
 243     'xmlURIPtr': ('O', "URI", "xmlURIPtr", "xmlURIPtr"),
 244     'xmlErrorPtr': ('O', "Error", "xmlErrorPtr", "xmlErrorPtr"),
 245     'xmlOutputBufferPtr': ('O', "outputBuffer", "xmlOutputBufferPtr", "xmlOutputBufferPtr"),
 246     'xmlParserInputBufferPtr': ('O', "inputBuffer", "xmlParserInputBufferPtr", "xmlParserInputBufferPtr"),
 247     'xmlRegexpPtr': ('O', "xmlReg", "xmlRegexpPtr", "xmlRegexpPtr"),
 248     'xmlTextReaderLocatorPtr': ('O', "xmlTextReaderLocator", "xmlTextReaderLocatorPtr", "xmlTextReaderLocatorPtr"),
 249     'xmlTextReaderPtr': ('O', "xmlTextReader", "xmlTextReaderPtr", "xmlTextReaderPtr"),
 250     'xmlRelaxNGPtr': ('O', "relaxNgSchema", "xmlRelaxNGPtr", "xmlRelaxNGPtr"),
 251     'xmlRelaxNGParserCtxtPtr': ('O', "relaxNgParserCtxt", "xmlRelaxNGParserCtxtPtr", "xmlRelaxNGParserCtxtPtr"),
 252     'xmlRelaxNGValidCtxtPtr': ('O', "relaxNgValidCtxt", "xmlRelaxNGValidCtxtPtr", "xmlRelaxNGValidCtxtPtr"),
 253     'xmlSchemaPtr': ('O', "Schema", "xmlSchemaPtr", "xmlSchemaPtr"),
 254     'xmlSchemaParserCtxtPtr': ('O', "SchemaParserCtxt", "xmlSchemaParserCtxtPtr", "xmlSchemaParserCtxtPtr"),
 255     'xmlSchemaValidCtxtPtr': ('O', "SchemaValidCtxt", "xmlSchemaValidCtxtPtr", "xmlSchemaValidCtxtPtr"),
 256 }
 257
 258 py_return_types = {
 259     'xmlXPathObjectPtr':  ('O', "foo", "xmlXPathObjectPtr", "xmlXPathObjectPtr"),
 260 }
 261
 262 unknown_types = {}
 263
 264 foreign_encoding_args = (
 265     'htmlCreateMemoryParserCtxt',
 266     'htmlCtxtReadMemory',
 267     'htmlParseChunk',
 268     'htmlReadMemory',
 269     'xmlCreateMemoryParserCtxt',
 270     'xmlCtxtReadMemory',
 271     'xmlCtxtResetPush',
 272     'xmlParseChunk',
 273     'xmlParseMemory',
 274     'xmlReadMemory',
 275     'xmlRecoverMemory',
 276 )
 277
 278 #######################################################################
 279 #
 280 #  This part writes the C <-> Python stubs libxml2-py.[ch] and
 281 #  the table libxml2-export.c to add when registrering the Python module
 282 #
 283 #######################################################################
 284
 285 # Class methods which are written by hand in libxml.c but the Python-level
 286 # code is still automatically generated (so they are not in skip_function()).
 287 skip_impl = (
 288     'xmlSaveFileTo',
 289     'xmlSaveFormatFileTo',
 290 )
 291
 292 def skip_function(name):
 293     if name[0:12] == "xmlXPathWrap":
 294         return 1
 295     if name == "xmlFreeParserCtxt":
 296         return 1
 297     if name == "xmlCleanupParser":
 298         return 1
 299     if name == "xmlFreeTextReader":
 300         return 1
 301 #    if name[0:11] == "xmlXPathNew":
 302 #        return 1
 303     # the next function is defined in libxml.c
 304     if name == "xmlRelaxNGFreeValidCtxt":
 305         return 1
 306     if name == "xmlFreeValidCtxt":
 307         return 1
 308     if name == "xmlSchemaFreeValidCtxt":
 309         return 1
 310
 311 #
 312 # Those are skipped because the Const version is used of the bindings
 313 # instead.
 314 #
 315     if name == "xmlTextReaderBaseUri":
 316         return 1
 317     if name == "xmlTextReaderLocalName":
 318         return 1
 319     if name == "xmlTextReaderName":
 320         return 1
 321     if name == "xmlTextReaderNamespaceUri":
 322         return 1
 323     if name == "xmlTextReaderPrefix":
 324         return 1
 325     if name == "xmlTextReaderXmlLang":
 326         return 1
 327     if name == "xmlTextReaderValue":
 328         return 1
 329     if name == "xmlOutputBufferClose": # handled by by the superclass
 330         return 1
 331     if name == "xmlOutputBufferFlush": # handled by by the superclass
 332         return 1
 333     if name == "xmlErrMemory":
 334         return 1
 335
 336     if name == "xmlValidBuildContentModel":
 337         return 1
 338     if name == "xmlValidateElementDecl":
 339         return 1
 340     if name == "xmlValidateAttributeDecl":
 341         return 1
 342     if name == "xmlPopInputCallbacks":
 343         return 1
 344
 345     return 0
 346
 347 def print_function_wrapper(name, output, export, include):
 348     global py_types
 349     global unknown_types
 350     global functions
 351     global skipped_modules
 352
 353     try:
 354         (desc, ret, args, file, cond) = functions[name]
 355     except:
 356         print("failed to get function %s infos")
 357         return
 358
 359     if file in skipped_modules:
 360         return 0
 361     if skip_function(name) == 1:
 362         return 0
 363     if name in skip_impl:
 364         # Don't delete the function entry in the caller.
 365         return 1
 366
 367     c_call = ""
 368     format=""
 369     format_args=""
 370     c_args=""
 371     c_return=""
 372     c_convert=""
 373     c_release=""
 374     num_bufs=0
 375     for arg in args:
 376         # This should be correct
 377         if arg[1][0:6] == "const ":
 378             arg[1] = arg[1][6:]
 379         c_args = c_args + "    %s %s;\n" % (arg[1], arg[0])
 380         if arg[1] in py_types:
 381             (f, t, n, c) = py_types[arg[1]]
 382             if (f == 'z') and (name in foreign_encoding_args) and (num_bufs == 0):
 383                 f = 's#'
 384             if f != None:
 385                 format = format + f
 386             if t != None:
 387                 format_args = format_args + ", &pyobj_%s" % (arg[0])
 388                 c_args = c_args + "    PyObject *pyobj_%s;\n" % (arg[0])
 389                 c_convert = c_convert + \
 390                    "    %s = (%s) Py%s_Get(pyobj_%s);\n" % (arg[0],
 391                    arg[1], t, arg[0])
 392             else:
 393                 format_args = format_args + ", &%s" % (arg[0])
 394             if f == 's#':
 395                 format_args = format_args + ", &py_buffsize%d" % num_bufs
 396                 c_args = c_args + "    int py_buffsize%d;\n" % num_bufs
 397                 num_bufs = num_bufs + 1
 398             if c_call != "":
 399                 c_call = c_call + ", "
 400             c_call = c_call + "%s" % (arg[0])
 401             if t == "File":
 402                 c_release = c_release + \
 403                             "    PyFile_Release(%s);\n" % (arg[0])
 404         else:
 405             if arg[1] in skipped_types:
 406                 return 0
 407             if arg[1] in unknown_types:
 408                 lst = unknown_types[arg[1]]
 409                 lst.append(name)
 410             else:
 411                 unknown_types[arg[1]] = [name]
 412             return -1
 413     if format != "":
 414         format = format + ":%s" % (name)
 415
 416     if ret[0] == 'void':
 417         if file == "python_accessor":
 418             if args[1][1] == "char *" or args[1][1] == "xmlChar *":
 419                 c_call = "\n    if (%s->%s != NULL) xmlFree(%s->%s);\n" % (
 420                                  args[0][0], args[1][0], args[0][0], args[1][0])
 421                 c_call = c_call + "    %s->%s = (%s)xmlStrdup((const xmlChar *)%s);\n" % (args[0][0],
 422                                  args[1][0], args[1][1], args[1][0])
 423             else:
 424                 c_call = "\n    %s->%s = %s;\n" % (args[0][0], args[1][0],
 425                                                    args[1][0])
 426         else:
 427             c_call = "\n    %s(%s);\n" % (name, c_call)
 428         ret_convert = "    Py_INCREF(Py_None);\n    return(Py_None);\n"
 429     elif ret[0] in py_types:
 430         (f, t, n, c) = py_types[ret[0]]
 431         c_return = c_return + "    %s c_retval;\n" % (ret[0])
 432         if file == "python_accessor" and ret[2] != None:
 433             c_call = "\n    c_retval = %s->%s;\n" % (args[0][0], ret[2])
 434         else:
 435             c_call = "\n    c_retval = %s(%s);\n" % (name, c_call)
 436         ret_convert = "    py_retval = libxml_%sWrap((%s) c_retval);\n" % (n,c)
 437         ret_convert = ret_convert + "    return(py_retval);\n"
 438     elif ret[0] in py_return_types:
 439         (f, t, n, c) = py_return_types[ret[0]]
 440         c_return = c_return + "    %s c_retval;\n" % (ret[0])
 441         c_call = "\n    c_retval = %s(%s);\n" % (name, c_call)
 442         ret_convert = "    py_retval = libxml_%sWrap((%s) c_retval);\n" % (n,c)
 443         ret_convert = ret_convert + "    return(py_retval);\n"
 444     else:
 445         if ret[0] in skipped_types:
 446             return 0
 447         if ret[0] in unknown_types:
 448             lst = unknown_types[ret[0]]
 449             lst.append(name)
 450         else:
 451             unknown_types[ret[0]] = [name]
 452         return -1
 453
 454     if cond != None and cond != "":
 455         include.write("#if %s\n" % cond)
 456         export.write("#if %s\n" % cond)
 457         output.write("#if %s\n" % cond)
 458
 459     include.write("PyObject * ")
 460     include.write("libxml_%s(PyObject *self, PyObject *args);\n" % (name))
 461
 462     export.write("    { (char *)\"%s\", libxml_%s, METH_VARARGS, NULL },\n" %
 463                  (name, name))
 464
 465     if file == "python":
 466         # Those have been manually generated
 467         if cond != None and cond != "":
 468             include.write("#endif\n")
 469             export.write("#endif\n")
 470             output.write("#endif\n")
 471         return 1
 472     if file == "python_accessor" and ret[0] != "void" and ret[2] is None:
 473         # Those have been manually generated
 474         if cond != None and cond != "":
 475             include.write("#endif\n")
 476             export.write("#endif\n")
 477             output.write("#endif\n")
 478         return 1
 479
 480     output.write("PyObject *\n")
 481     output.write("libxml_%s(PyObject *self ATTRIBUTE_UNUSED," % (name))
 482     output.write(" PyObject *args")
 483     if format == "":
 484         output.write(" ATTRIBUTE_UNUSED")
 485     output.write(") {\n")
 486     if ret[0] != 'void':
 487         output.write("    PyObject *py_retval;\n")
 488     if c_return != "":
 489         output.write(c_return)
 490     if c_args != "":
 491         output.write(c_args)
 492     if format != "":
 493         output.write("\n    if (!PyArg_ParseTuple(args, (char *)\"%s\"%s))\n" %
 494                      (format, format_args))
 495         output.write("        return(NULL);\n")
 496     if c_convert != "":
 497         output.write(c_convert)
 498
 499     output.write(c_call)
 500     if c_release != "":
 501         output.write(c_release)
 502     output.write(ret_convert)
 503     output.write("}\n\n")
 504     if cond != None and cond != "":
 505         include.write("#endif /* %s */\n" % cond)
 506         export.write("#endif /* %s */\n" % cond)
 507         output.write("#endif /* %s */\n" % cond)
 508     return 1
 509
 510 def buildStubs():
 511     global py_types
 512     global py_return_types
 513     global unknown_types
 514
 515     try:
 516         f = open(os.path.join(srcPref,"libxml2-api.xml"))
 517         data = f.read()
 518         (parser, target)  = getparser()
 519         parser.feed(data)
 520         parser.close()
 521     except IOError as msg:
 522         try:
 523             f = open(os.path.join(srcPref,"..","doc","libxml2-api.xml"))
 524             data = f.read()
 525             (parser, target)  = getparser()
 526             parser.feed(data)
 527             parser.close()
 528         except IOError as msg:
 529             print(file, ":", msg)
 530             sys.exit(1)
 531
 532     n = len(list(functions.keys()))
 533     print("Found %d functions in libxml2-api.xml" % (n))
 534
 535     py_types['pythonObject'] = ('O', "pythonObject", "pythonObject", "pythonObject")
 536     try:
 537         f = open(os.path.join(srcPref,"libxml2-python-api.xml"))
 538         data = f.read()
 539         (parser, target)  = getparser()
 540         parser.feed(data)
 541         parser.close()
 542     except IOError as msg:
 543         print(file, ":", msg)
 544
 545
 546     print("Found %d functions in libxml2-python-api.xml" % (
 547           len(list(functions.keys())) - n))
 548     nb_wrap = 0
 549     failed = 0
 550     skipped = 0
 551
 552     include = open("libxml2-py.h", "w")
 553     include.write("/* Generated */\n\n")
 554     export = open("libxml2-export.c", "w")
 555     export.write("/* Generated */\n\n")
 556     wrapper = open("libxml2-py.c", "w")
 557     wrapper.write("/* Generated */\n\n")
 558     wrapper.write("#include <Python.h>\n")
 559     wrapper.write("#include <libxml/xmlversion.h>\n")
 560     wrapper.write("#include <libxml/tree.h>\n")
 561     wrapper.write("#include <libxml/xmlschemastypes.h>\n")
 562     wrapper.write("#include \"libxml_wrap.h\"\n")
 563     wrapper.write("#include \"libxml2-py.h\"\n\n")
 564     for function in sorted(functions.keys()):
 565         ret = print_function_wrapper(function, wrapper, export, include)
 566         if ret < 0:
 567             failed = failed + 1
 568             del functions[function]
 569         if ret == 0:
 570             skipped = skipped + 1
 571             del functions[function]
 572         if ret == 1:
 573             nb_wrap = nb_wrap + 1
 574     include.close()
 575     export.close()
 576     wrapper.close()
 577
 578     print("Generated %d wrapper functions, %d failed, %d skipped\n" % (nb_wrap,
 579                                                               failed, skipped))
 580     print("Missing type converters: ")
 581     for type in list(unknown_types.keys()):
 582         print("%s:%d " % (type, len(unknown_types[type])))
 583     print()
 584
 585 #######################################################################
 586 #
 587 #  This part writes part of the Python front-end classes based on
 588 #  mapping rules between types and classes and also based on function
 589 #  renaming to get consistent function names at the Python level
 590 #
 591 #######################################################################
 592
 593 #
 594 # The type automatically remapped to generated classes
 595 #
 596 classes_type = {
 597     "xmlNodePtr": ("._o", "xmlNode(_obj=%s)", "xmlNode"),
 598     "xmlNode *": ("._o", "xmlNode(_obj=%s)", "xmlNode"),
 599     "xmlDocPtr": ("._o", "xmlDoc(_obj=%s)", "xmlDoc"),
 600     "xmlDocPtr *": ("._o", "xmlDoc(_obj=%s)", "xmlDoc"),
 601     "htmlDocPtr": ("._o", "xmlDoc(_obj=%s)", "xmlDoc"),
 602     "htmlxmlDocPtr *": ("._o", "xmlDoc(_obj=%s)", "xmlDoc"),
 603     "xmlAttrPtr": ("._o", "xmlAttr(_obj=%s)", "xmlAttr"),
 604     "xmlAttr *": ("._o", "xmlAttr(_obj=%s)", "xmlAttr"),
 605     "xmlNsPtr": ("._o", "xmlNs(_obj=%s)", "xmlNs"),
 606     "xmlNs *": ("._o", "xmlNs(_obj=%s)", "xmlNs"),
 607     "xmlDtdPtr": ("._o", "xmlDtd(_obj=%s)", "xmlDtd"),
 608     "xmlDtd *": ("._o", "xmlDtd(_obj=%s)", "xmlDtd"),
 609     "xmlEntityPtr": ("._o", "xmlEntity(_obj=%s)", "xmlEntity"),
 610     "xmlEntity *": ("._o", "xmlEntity(_obj=%s)", "xmlEntity"),
 611     "xmlElementPtr": ("._o", "xmlElement(_obj=%s)", "xmlElement"),
 612     "xmlElement *": ("._o", "xmlElement(_obj=%s)", "xmlElement"),
 613     "xmlAttributePtr": ("._o", "xmlAttribute(_obj=%s)", "xmlAttribute"),
 614     "xmlAttribute *": ("._o", "xmlAttribute(_obj=%s)", "xmlAttribute"),
 615     "xmlXPathContextPtr": ("._o", "xpathContext(_obj=%s)", "xpathContext"),
 616     "xmlXPathContext *": ("._o", "xpathContext(_obj=%s)", "xpathContext"),
 617     "xmlXPathParserContext *": ("._o", "xpathParserContext(_obj=%s)", "xpathParserContext"),
 618     "xmlXPathParserContextPtr": ("._o", "xpathParserContext(_obj=%s)", "xpathParserContext"),
 619     "xmlParserCtxtPtr": ("._o", "parserCtxt(_obj=%s)", "parserCtxt"),
 620     "xmlParserCtxt *": ("._o", "parserCtxt(_obj=%s)", "parserCtxt"),
 621     "htmlParserCtxtPtr": ("._o", "parserCtxt(_obj=%s)", "parserCtxt"),
 622     "htmlParserCtxt *": ("._o", "parserCtxt(_obj=%s)", "parserCtxt"),
 623     "xmlValidCtxtPtr": ("._o", "ValidCtxt(_obj=%s)", "ValidCtxt"),
 624     "xmlCatalogPtr": ("._o", "catalog(_obj=%s)", "catalog"),
 625     "xmlURIPtr": ("._o", "URI(_obj=%s)", "URI"),
 626     "xmlErrorPtr": ("._o", "Error(_obj=%s)", "Error"),
 627     "xmlOutputBufferPtr": ("._o", "outputBuffer(_obj=%s)", "outputBuffer"),
 628     "xmlParserInputBufferPtr": ("._o", "inputBuffer(_obj=%s)", "inputBuffer"),
 629     "xmlRegexpPtr": ("._o", "xmlReg(_obj=%s)", "xmlReg"),
 630     "xmlTextReaderLocatorPtr": ("._o", "xmlTextReaderLocator(_obj=%s)", "xmlTextReaderLocator"),
 631     "xmlTextReaderPtr": ("._o", "xmlTextReader(_obj=%s)", "xmlTextReader"),
 632     'xmlRelaxNGPtr': ('._o', "relaxNgSchema(_obj=%s)", "relaxNgSchema"),
 633     'xmlRelaxNGParserCtxtPtr': ('._o', "relaxNgParserCtxt(_obj=%s)", "relaxNgParserCtxt"),
 634     'xmlRelaxNGValidCtxtPtr': ('._o', "relaxNgValidCtxt(_obj=%s)", "relaxNgValidCtxt"),
 635     'xmlSchemaPtr': ("._o", "Schema(_obj=%s)", "Schema"),
 636     'xmlSchemaParserCtxtPtr': ("._o", "SchemaParserCtxt(_obj=%s)", "SchemaParserCtxt"),
 637     'xmlSchemaValidCtxtPtr': ("._o", "SchemaValidCtxt(_obj=%s)", "SchemaValidCtxt"),
 638 }
 639
 640 converter_type = {
 641     "xmlXPathObjectPtr": "xpathObjectRet(%s)",
 642 }
 643
 644 primary_classes = ["xmlNode", "xmlDoc"]
 645
 646 classes_ancestor = {
 647     "xmlNode" : "xmlCore",
 648     "xmlDtd" : "xmlNode",
 649     "xmlDoc" : "xmlNode",
 650     "xmlAttr" : "xmlNode",
 651     "xmlNs" : "xmlNode",
 652     "xmlEntity" : "xmlNode",
 653     "xmlElement" : "xmlNode",
 654     "xmlAttribute" : "xmlNode",
 655     "outputBuffer": "ioWriteWrapper",
 656     "inputBuffer": "ioReadWrapper",
 657     "parserCtxt": "parserCtxtCore",
 658     "xmlTextReader": "xmlTextReaderCore",
 659     "ValidCtxt": "ValidCtxtCore",
 660     "SchemaValidCtxt": "SchemaValidCtxtCore",
 661     "relaxNgValidCtxt": "relaxNgValidCtxtCore",
 662 }
 663 classes_destructors = {
 664     "parserCtxt": "xmlFreeParserCtxt",
 665     "catalog": "xmlFreeCatalog",
 666     "URI": "xmlFreeURI",
 667 #    "outputBuffer": "xmlOutputBufferClose",
 668     "inputBuffer": "xmlFreeParserInputBuffer",
 669     "xmlReg": "xmlRegFreeRegexp",
 670     "xmlTextReader": "xmlFreeTextReader",
 671     "relaxNgSchema": "xmlRelaxNGFree",
 672     "relaxNgParserCtxt": "xmlRelaxNGFreeParserCtxt",
 673     "relaxNgValidCtxt": "xmlRelaxNGFreeValidCtxt",
 674         "Schema": "xmlSchemaFree",
 675         "SchemaParserCtxt": "xmlSchemaFreeParserCtxt",
 676         "SchemaValidCtxt": "xmlSchemaFreeValidCtxt",
 677         "ValidCtxt": "xmlFreeValidCtxt",
 678 }
 679
 680 functions_noexcept = {
 681     "xmlHasProp": 1,
 682     "xmlHasNsProp": 1,
 683     "xmlDocSetRootElement": 1,
 684     "xmlNodeGetNs": 1,
 685     "xmlNodeGetNsDefs": 1,
 686     "xmlNextElementSibling": 1,
 687     "xmlPreviousElementSibling": 1,
 688     "xmlFirstElementChild": 1,
 689     "xmlLastElementChild": 1,
 690 }
 691
 692 reference_keepers = {
 693     "xmlTextReader": [('inputBuffer', 'input')],
 694     "relaxNgValidCtxt": [('relaxNgSchema', 'schema')],
 695         "SchemaValidCtxt": [('Schema', 'schema')],
 696 }
 697
 698 function_classes = {}
 699
 700 function_classes["None"] = []
 701
 702 def nameFixup(name, classe, type, file):
 703     listname = classe + "List"
 704     ll = len(listname)
 705     l = len(classe)
 706     if name[0:l] == listname:
 707         func = name[l:]
 708         func = func[0:1].lower() + func[1:]
 709     elif name[0:12] == "xmlParserGet" and file == "python_accessor":
 710         func = name[12:]
 711         func = func[0:1].lower() + func[1:]
 712     elif name[0:12] == "xmlParserSet" and file == "python_accessor":
 713         func = name[12:]
 714         func = func[0:1].lower() + func[1:]
 715     elif name[0:10] == "xmlNodeGet" and file == "python_accessor":
 716         func = name[10:]
 717         func = func[0:1].lower() + func[1:]
 718     elif name[0:9] == "xmlURIGet" and file == "python_accessor":
 719         func = name[9:]
 720         func = func[0:1].lower() + func[1:]
 721     elif name[0:9] == "xmlURISet" and file == "python_accessor":
 722         func = name[6:]
 723         func = func[0:1].lower() + func[1:]
 724     elif name[0:11] == "xmlErrorGet" and file == "python_accessor":
 725         func = name[11:]
 726         func = func[0:1].lower() + func[1:]
 727     elif name[0:17] == "xmlXPathParserGet" and file == "python_accessor":
 728         func = name[17:]
 729         func = func[0:1].lower() + func[1:]
 730     elif name[0:11] == "xmlXPathGet" and file == "python_accessor":
 731         func = name[11:]
 732         func = func[0:1].lower() + func[1:]
 733     elif name[0:11] == "xmlXPathSet" and file == "python_accessor":
 734         func = name[8:]
 735         func = func[0:1].lower() + func[1:]
 736     elif name[0:15] == "xmlOutputBuffer" and file != "python":
 737         func = name[15:]
 738         func = func[0:1].lower() + func[1:]
 739     elif name[0:20] == "xmlParserInputBuffer" and file != "python":
 740         func = name[20:]
 741         func = func[0:1].lower() + func[1:]
 742     elif name[0:9] == "xmlRegexp" and file == "xmlregexp":
 743         func = "regexp" + name[9:]
 744     elif name[0:6] == "xmlReg" and file == "xmlregexp":
 745         func = "regexp" + name[6:]
 746     elif name[0:20] == "xmlTextReaderLocator" and file == "xmlreader":
 747         func = name[20:]
 748     elif name[0:18] == "xmlTextReaderConst" and file == "xmlreader":
 749         func = name[18:]
 750     elif name[0:13] == "xmlTextReader" and file == "xmlreader":
 751         func = name[13:]
 752     elif name[0:12] == "xmlReaderNew" and file == "xmlreader":
 753         func = name[9:]
 754     elif name[0:11] == "xmlACatalog":
 755         func = name[11:]
 756         func = func[0:1].lower() + func[1:]
 757     elif name[0:l] == classe:
 758         func = name[l:]
 759         func = func[0:1].lower() + func[1:]
 760     elif name[0:7] == "libxml_":
 761         func = name[7:]
 762         func = func[0:1].lower() + func[1:]
 763     elif name[0:6] == "xmlGet":
 764         func = name[6:]
 765         func = func[0:1].lower() + func[1:]
 766     elif name[0:3] == "xml":
 767         func = name[3:]
 768         func = func[0:1].lower() + func[1:]
 769     else:
 770         func = name
 771     if func[0:5] == "xPath":
 772         func = "xpath" + func[5:]
 773     elif func[0:4] == "xPtr":
 774         func = "xpointer" + func[4:]
 775     elif func[0:8] == "xInclude":
 776         func = "xinclude" + func[8:]
 777     elif func[0:2] == "iD":
 778         func = "ID" + func[2:]
 779     elif func[0:3] == "uRI":
 780         func = "URI" + func[3:]
 781     elif func[0:4] == "uTF8":
 782         func = "UTF8" + func[4:]
 783     elif func[0:3] == 'sAX':
 784         func = "SAX" + func[3:]
 785     return func
 786
 787
 788 def functionCompare(info1, info2):
 789     (index1, func1, name1, ret1, args1, file1) = info1
 790     (index2, func2, name2, ret2, args2, file2) = info2
 791     if file1 == file2:
 792         if func1 < func2:
 793             return -1
 794         if func1 > func2:
 795             return 1
 796     if file1 == "python_accessor":
 797         return -1
 798     if file2 == "python_accessor":
 799         return 1
 800     if file1 < file2:
 801         return -1
 802     if file1 > file2:
 803         return 1
 804     return 0
 805
 806 def cmp_to_key(mycmp):
 807     'Convert a cmp= function into a key= function'
 808     class K(object):
 809         def __init__(self, obj, *args):
 810             self.obj = obj
 811         def __lt__(self, other):
 812             return mycmp(self.obj, other.obj) < 0
 813         def __gt__(self, other):
 814             return mycmp(self.obj, other.obj) > 0
 815         def __eq__(self, other):
 816             return mycmp(self.obj, other.obj) == 0
 817         def __le__(self, other):
 818             return mycmp(self.obj, other.obj) <= 0
 819         def __ge__(self, other):
 820             return mycmp(self.obj, other.obj) >= 0
 821         def __ne__(self, other):
 822             return mycmp(self.obj, other.obj) != 0
 823     return K
 824 def writeDoc(name, args, indent, output):
 825      if functions[name][0] is None or functions[name][0] == "":
 826          return
 827      val = functions[name][0]
 828      val = val.replace("NULL", "None")
 829      output.write(indent)
 830      output.write('"""')
 831      while len(val) > 60:
 832          if val[0] == " ":
 833              val = val[1:]
 834              continue
 835          str = val[0:60]
 836          i = str.rfind(" ")
 837          if i < 0:
 838              i = 60
 839          str = val[0:i]
 840          val = val[i:]
 841          output.write(str)
 842          output.write('\n  ')
 843          output.write(indent)
 844      output.write(val)
 845      output.write(' """\n')
 846
 847 def buildWrappers():
 848     global ctypes
 849     global py_types
 850     global py_return_types
 851     global unknown_types
 852     global functions
 853     global function_classes
 854     global classes_type
 855     global classes_list
 856     global converter_type
 857     global primary_classes
 858     global converter_type
 859     global classes_ancestor
 860     global converter_type
 861     global primary_classes
 862     global classes_ancestor
 863     global classes_destructors
 864     global functions_noexcept
 865
 866     for type in classes_type.keys():
 867         function_classes[classes_type[type][2]] = []
 868
 869     #
 870     # Build the list of C types to look for ordered to start
 871     # with primary classes
 872     #
 873     ctypes = []
 874     classes_list = []
 875     ctypes_processed = {}
 876     classes_processed = {}
 877     for classe in primary_classes:
 878         classes_list.append(classe)
 879         classes_processed[classe] = ()
 880         for type in classes_type.keys():
 881             tinfo = classes_type[type]
 882             if tinfo[2] == classe:
 883                 ctypes.append(type)
 884                 ctypes_processed[type] = ()
 885     for type in sorted(classes_type.keys()):
 886         if type in ctypes_processed:
 887             continue
 888         tinfo = classes_type[type]
 889         if tinfo[2] not in classes_processed:
 890             classes_list.append(tinfo[2])
 891             classes_processed[tinfo[2]] = ()
 892
 893         ctypes.append(type)
 894         ctypes_processed[type] = ()
 895
 896     for name in functions.keys():
 897         found = 0
 898         (desc, ret, args, file, cond) = functions[name]
 899         for type in ctypes:
 900             classe = classes_type[type][2]
 901
 902             if name[0:3] == "xml" and len(args) >= 1 and args[0][1] == type:
 903                 found = 1
 904                 func = nameFixup(name, classe, type, file)
 905                 info = (0, func, name, ret, args, file)
 906                 function_classes[classe].append(info)
 907             elif name[0:3] == "xml" and len(args) >= 2 and args[1][1] == type \
 908                 and file != "python_accessor":
 909                 found = 1
 910                 func = nameFixup(name, classe, type, file)
 911                 info = (1, func, name, ret, args, file)
 912                 function_classes[classe].append(info)
 913             elif name[0:4] == "html" and len(args) >= 1 and args[0][1] == type:
 914                 found = 1
 915                 func = nameFixup(name, classe, type, file)
 916                 info = (0, func, name, ret, args, file)
 917                 function_classes[classe].append(info)
 918             elif name[0:4] == "html" and len(args) >= 2 and args[1][1] == type \
 919                 and file != "python_accessor":
 920                 found = 1
 921                 func = nameFixup(name, classe, type, file)
 922                 info = (1, func, name, ret, args, file)
 923                 function_classes[classe].append(info)
 924         if found == 1:
 925             continue
 926         if name[0:8] == "xmlXPath":
 927             continue
 928         if name[0:6] == "xmlStr":
 929             continue
 930         if name[0:10] == "xmlCharStr":
 931             continue
 932         func = nameFixup(name, "None", file, file)
 933         info = (0, func, name, ret, args, file)
 934         function_classes['None'].append(info)
 935
 936     classes = open("libxml2class.py", "w")
 937     txt = open("libxml2class.txt", "w")
 938     txt.write("          Generated Classes for libxml2-python\n\n")
 939
 940     txt.write("#\n# Global functions of the module\n#\n\n")
 941     if "None" in function_classes:
 942         flist = function_classes["None"]
 943         flist = sorted(flist, key=cmp_to_key(functionCompare))
 944         oldfile = ""
 945         for info in flist:
 946             (index, func, name, ret, args, file) = info
 947             if file != oldfile:
 948                 classes.write("#\n# Functions from module %s\n#\n\n" % file)
 949                 txt.write("\n# functions from module %s\n" % file)
 950                 oldfile = file
 951             classes.write("def %s(" % func)
 952             txt.write("%s()\n" % func)
 953             n = 0
 954             for arg in args:
 955                 if n != 0:
 956                     classes.write(", ")
 957                 classes.write("%s" % arg[0])
 958                 n = n + 1
 959             classes.write("):\n")
 960             writeDoc(name, args, '    ', classes)
 961
 962             for arg in args:
 963                 if arg[1] in classes_type:
 964                     classes.write("    if %s is None: %s__o = None\n" %
 965                                   (arg[0], arg[0]))
 966                     classes.write("    else: %s__o = %s%s\n" %
 967                                   (arg[0], arg[0], classes_type[arg[1]][0]))
 968                 if arg[1] in py_types:
 969                     (f, t, n, c) = py_types[arg[1]]
 970                     if t == "File":
 971                         classes.write("    if %s is not None: %s.flush()\n" % (
 972                                       arg[0], arg[0]))
 973
 974             if ret[0] != "void":
 975                 classes.write("    ret = ")
 976             else:
 977                 classes.write("    ")
 978             classes.write("libxml2mod.%s(" % name)
 979             n = 0
 980             for arg in args:
 981                 if n != 0:
 982                     classes.write(", ")
 983                 classes.write("%s" % arg[0])
 984                 if arg[1] in classes_type:
 985                     classes.write("__o")
 986                 n = n + 1
 987             classes.write(")\n")
 988
 989 # This may be needed to reposition the I/O, but likely to cause more harm
 990 # than good. Those changes in Python3 really break the model.
 991 #           for arg in args:
 992 #               if arg[1] in py_types:
 993 #                   (f, t, n, c) = py_types[arg[1]]
 994 #                   if t == "File":
 995 #                       classes.write("    if %s is not None: %s.seek(0,0)\n"%(
 996 #                                     arg[0], arg[0]))
 997
 998             if ret[0] != "void":
 999                 if ret[0] in classes_type:
1000                     #
1001                     # Raise an exception
1002                     #
1003                     if name in functions_noexcept:
1004                         classes.write("    if ret is None:return None\n")
1005                     elif name.find("URI") >= 0:
1006                         classes.write(
1007                         "    if ret is None:raise uriError('%s() failed')\n"
1008                                       % (name))
1009                     elif name.find("XPath") >= 0:
1010                         classes.write(
1011                         "    if ret is None:raise xpathError('%s() failed')\n"
1012                                       % (name))
1013                     elif name.find("Parse") >= 0:
1014                         classes.write(
1015                         "    if ret is None:raise parserError('%s() failed')\n"
1016                                       % (name))
1017                     else:
1018                         classes.write(
1019                         "    if ret is None:raise treeError('%s() failed')\n"
1020                                       % (name))
1021                     classes.write("    return ")
1022                     classes.write(classes_type[ret[0]][1] % ("ret"))
1023                     classes.write("\n")
1024                 else:
1025                     classes.write("    return ret\n")
1026             classes.write("\n")
1027
1028     txt.write("\n\n#\n# Set of classes of the module\n#\n\n")
1029     for classname in classes_list:
1030         if classname == "None":
1031             pass
1032         else:
1033             if classname in classes_ancestor:
1034                 txt.write("\n\nClass %s(%s)\n" % (classname,
1035                           classes_ancestor[classname]))
1036                 classes.write("class %s(%s):\n" % (classname,
1037                               classes_ancestor[classname]))
1038                 classes.write("    def __init__(self, _obj=None):\n")
1039                 if classes_ancestor[classname] == "xmlCore" or \
1040                    classes_ancestor[classname] == "xmlNode":
1041                     classes.write("        if checkWrapper(_obj) != 0:")
1042                     classes.write("            raise TypeError")
1043                     classes.write("('%s got a wrong wrapper object type')\n" % \
1044                                 classname)
1045                 if classname in reference_keepers:
1046                     rlist = reference_keepers[classname]
1047                     for ref in rlist:
1048                         classes.write("        self.%s = None\n" % ref[1])
1049                 classes.write("        self._o = _obj\n")
1050                 classes.write("        %s.__init__(self, _obj=_obj)\n\n" % (
1051                               classes_ancestor[classname]))
1052                 if classes_ancestor[classname] == "xmlCore" or \
1053                    classes_ancestor[classname] == "xmlNode":
1054                     classes.write("    def __repr__(self):\n")
1055                     format = "<%s (%%s) object at 0x%%x>" % (classname)
1056                     classes.write("        return \"%s\" %% (self.name, int(pos_id (self)))\n\n" % (
1057                                   format))
1058             else:
1059                 txt.write("Class %s()\n" % (classname))
1060                 classes.write("class %s:\n" % (classname))
1061                 classes.write("    def __init__(self, _obj=None):\n")
1062                 if classname in reference_keepers:
1063                     list = reference_keepers[classname]
1064                     for ref in list:
1065                         classes.write("        self.%s = None\n" % ref[1])
1066                 classes.write("        if _obj != None:self._o = _obj;return\n")
1067                 classes.write("        self._o = None\n\n")
1068             destruct=None
1069             if classname in classes_destructors:
1070                 classes.write("    def __del__(self):\n")
1071                 classes.write("        if self._o != None:\n")
1072                 classes.write("            libxml2mod.%s(self._o)\n" %
1073                               classes_destructors[classname])
1074                 classes.write("        self._o = None\n\n")
1075                 destruct=classes_destructors[classname]
1076             flist = function_classes[classname]
1077             flist = sorted(flist, key=cmp_to_key(functionCompare))
1078             oldfile = ""
1079             for info in flist:
1080                 (index, func, name, ret, args, file) = info
1081                 #
1082                 # Do not provide as method the destructors for the class
1083                 # to avoid double free
1084                 #
1085                 if name == destruct:
1086                     continue
1087                 if file != oldfile:
1088                     if file == "python_accessor":
1089                         classes.write("    # accessors for %s\n" % (classname))
1090                         txt.write("    # accessors\n")
1091                     else:
1092                         classes.write("    #\n")
1093                         classes.write("    # %s functions from module %s\n" % (
1094                                       classname, file))
1095                         txt.write("\n    # functions from module %s\n" % file)
1096                         classes.write("    #\n\n")
1097                 oldfile = file
1098                 classes.write("    def %s(self" % func)
1099                 txt.write("    %s()\n" % func)
1100                 n = 0
1101                 for arg in args:
1102                     if n != index:
1103                         classes.write(", %s" % arg[0])
1104                     n = n + 1
1105                 classes.write("):\n")
1106                 writeDoc(name, args, '        ', classes)
1107                 n = 0
1108                 for arg in args:
1109                     if arg[1] in classes_type:
1110                         if n != index:
1111                             classes.write("        if %s is None: %s__o = None\n" %
1112                                           (arg[0], arg[0]))
1113                             classes.write("        else: %s__o = %s%s\n" %
1114                                           (arg[0], arg[0], classes_type[arg[1]][0]))
1115                     n = n + 1
1116                 if ret[0] != "void":
1117                     classes.write("        ret = ")
1118                 else:
1119                     classes.write("        ")
1120                 classes.write("libxml2mod.%s(" % name)
1121                 n = 0
1122                 for arg in args:
1123                     if n != 0:
1124                         classes.write(", ")
1125                     if n != index:
1126                         classes.write("%s" % arg[0])
1127                         if arg[1] in classes_type:
1128                             classes.write("__o")
1129                     else:
1130                         classes.write("self")
1131                         if arg[1] in classes_type:
1132                             classes.write(classes_type[arg[1]][0])
1133                     n = n + 1
1134                 classes.write(")\n")
1135                 if ret[0] != "void":
1136                     if ret[0] in classes_type:
1137                         #
1138                         # Raise an exception
1139                         #
1140                         if name in functions_noexcept:
1141                             classes.write(
1142                                 "        if ret is None:return None\n")
1143                         elif name.find("URI") >= 0:
1144                             classes.write(
1145                     "        if ret is None:raise uriError('%s() failed')\n"
1146                                           % (name))
1147                         elif name.find("XPath") >= 0:
1148                             classes.write(
1149                     "        if ret is None:raise xpathError('%s() failed')\n"
1150                                           % (name))
1151                         elif name.find("Parse") >= 0:
1152                             classes.write(
1153                     "        if ret is None:raise parserError('%s() failed')\n"
1154                                           % (name))
1155                         else:
1156                             classes.write(
1157                     "        if ret is None:raise treeError('%s() failed')\n"
1158                                           % (name))
1159
1160                         #
1161                         # generate the returned class wrapper for the object
1162                         #
1163                         classes.write("        __tmp = ")
1164                         classes.write(classes_type[ret[0]][1] % ("ret"))
1165                         classes.write("\n")
1166
1167                         #
1168                         # Sometime one need to keep references of the source
1169                         # class in the returned class object.
1170                         # See reference_keepers for the list
1171                         #
1172                         tclass = classes_type[ret[0]][2]
1173                         if tclass in reference_keepers:
1174                             list = reference_keepers[tclass]
1175                             for pref in list:
1176                                 if pref[0] == classname:
1177                                     classes.write("        __tmp.%s = self\n" %
1178                                                   pref[1])
1179                         #
1180                         # return the class
1181                         #
1182                         classes.write("        return __tmp\n")
1183                     elif ret[0] in converter_type:
1184                         #
1185                         # Raise an exception
1186                         #
1187                         if name in functions_noexcept:
1188                             classes.write(
1189                                 "        if ret is None:return None")
1190                         elif name.find("URI") >= 0:
1191                             classes.write(
1192                     "        if ret is None:raise uriError('%s() failed')\n"
1193                                           % (name))
1194                         elif name.find("XPath") >= 0:
1195                             classes.write(
1196                     "        if ret is None:raise xpathError('%s() failed')\n"
1197                                           % (name))
1198                         elif name.find("Parse") >= 0:
1199                             classes.write(
1200                     "        if ret is None:raise parserError('%s() failed')\n"
1201                                           % (name))
1202                         else:
1203                             classes.write(
1204                     "        if ret is None:raise treeError('%s() failed')\n"
1205                                           % (name))
1206                         classes.write("        return ")
1207                         classes.write(converter_type[ret[0]] % ("ret"))
1208                         classes.write("\n")
1209                     else:
1210                         classes.write("        return ret\n")
1211                 classes.write("\n")
1212
1213     #
1214     # Generate enum constants
1215     #
1216     for type,enum in enums.items():
1217         classes.write("# %s\n" % type)
1218         items = enum.items()
1219         items = sorted(items, key=(lambda i: int(i[1])))
1220         for name,value in items:
1221             classes.write("%s = %s\n" % (name,value))
1222         classes.write("\n")
1223
1224     txt.close()
1225     classes.close()
1226
1227 buildStubs()
1228 buildWrappers()