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 "xmlDoc *": ("._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() 1229
