/
niceSOFT
/
libxml2
Обзор
Документация
Войти
/
niceSOFT
/
libxml2
Код
Задачи
Вики
Пакеты
0
Релизы
0
Аналитика
Безопасность
v2.15.2
python/generator.py
1 640 строк
64 KB
Nick Wellnhofer
catalog: Deprecate low-level internal functions
20 авг 2025, 14:09
20 авг 2025, 14:09
591f19e
Код
Авторство
О чём код?
#!/usr/bin/env python3 # # generate python wrappers from the XML API description # functions = { 'xmlRegisterXPathFunction': ( 'Register a Python written function to the XPath interpreter', ['int', '1 in case of success, 0 or -1 in case of error', None], [['ctx', 'xmlXPathContext *', 'the xpathContext'], ['name', 'xmlChar *', 'the function name'], ['ns_uri', 'xmlChar *', 'the namespace or NULL'], ['f', 'pythonObject', 'the python function']], 'python', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlXPathRegisterVariable': ( 'Register a variable with the XPath context', ['int', '1 in case of success, 0 or -1 in case of error', None], [['ctx', 'xmlXPathContext *', 'the xpathContext'], ['name', 'xmlChar *', 'the variable name'], ['ns_uri', 'xmlChar *', 'the namespace or NULL'], ['value', 'pythonObject', 'the value']], 'python', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlNewNode': ( 'Create a new Node', ['xmlNode *', 'A new element node', None], [['name', 'xmlChar *', 'the node name']], 'python', None), 'xmlCreatePushParser': ( 'Create a progressive XML parser context to build either an event flow if the SAX object is not None, or a DOM tree otherwise.', ['xmlParserCtxt *', 'the parser context or None in case of error', None], [['SAX', 'pythonObject', 'the SAX callback object or None'], ['chunk', 'xmlChar *', 'the initial data'], ['size', 'int', 'the size of the initial data'], ['URI', 'xmlChar *', 'The URI used for base computations']], 'python', None), 'htmlCreatePushParser': ( 'Create a progressive HTML parser context to build either an event flow if the SAX object is not None, or a DOM tree otherwise.', ['xmlParserCtxt *', 'the parser context or None in case of error', None], [['SAX', 'pythonObject', 'the SAX callback object or None'], ['chunk', 'xmlChar *', 'the initial data'], ['size', 'int', 'the size of the initial data'], ['URI', 'xmlChar *', 'The URI used for base computations']], 'python', 'defined(LIBXML_HTML_ENABLED)'), 'xmlSAXParseFile': ( 'Interface to parse an XML file or resource pointed by an URI to build an event flow to the SAX object', ['void', None, None], [['SAX', 'pythonObject', 'the SAX callback object or None'], ['URI', 'xmlChar *', 'The URI of the resource'], ['recover', 'int', 'allow recovery in case of error']], 'python', None), 'htmlSAXParseFile': ( 'Interface to parse an HTML file or resource pointed by an URI to build an event flow to the SAX object', ['void', None, None], [['SAX', 'pythonObject', 'the SAX callback object or None'], ['URI', 'xmlChar *', 'The URI of the resource'], ['encoding', 'const char *', 'encoding or None']], 'python', 'defined(LIBXML_HTML_ENABLED)'), 'xmlCreateOutputBuffer': ( 'Create a libxml2 output buffer from a Python file', ['xmlOutputBuffer *', 'the output buffer', None], [['file', 'pythonObject', 'the Python file'], ['encoding', 'xmlChar *', 'an optional encoding']], 'python', None), 'xmlCreateInputBuffer': ( 'Create a libxml2 input buffer from a Python file', ['xmlParserInputBuffer *', 'the input buffer', None], [['file', 'pythonObject', 'the Python file'], ['encoding', 'xmlChar *', 'an optional encoding']], 'python', None), 'xmlSetEntityLoader': ( 'Set the entity resolver as a python function', ['int', '0 in case of success, -1 for error', None], [['resolver', 'pythonObject', 'the Python function']], 'python', None), 'xmlParserGetDoc': ( 'Get the document tree from a parser context.', ['xmlDoc *', 'the document tree', 'myDoc'], [['ctxt', 'xmlParserCtxt *', 'the parser context']], 'python_accessor', None), 'xmlParserGetWellFormed': ( 'Get the well formed information from a parser context.', ['int', 'the wellFormed field', 'wellFormed'], [['ctxt', 'xmlParserCtxt *', 'the parser context']], 'python_accessor', None), 'xmlParserGetIsValid': ( 'Get the validity information from a parser context.', ['int', 'the valid field', 'valid'], [['ctxt', 'xmlParserCtxt *', 'the parser context']], 'python_accessor', None), 'xmlParserSetValidate': ( 'Switch the parser to validation mode.', ['void', None, None], [['ctxt', 'xmlParserCtxt *', 'the parser context'], ['validate', 'int', '1 to activate validation']], 'python_accessor', None), 'xmlParserSetReplaceEntities': ( 'Switch the parser to replace entities.', ['void', None, None], [['ctxt', 'xmlParserCtxt *', 'the parser context'], ['replaceEntities', 'int', '1 to replace entities']], 'python_accessor', None), 'xmlParserSetPedantic': ( 'Switch the parser to be pedantic.', ['void', None, None], [['ctxt', 'xmlParserCtxt *', 'the parser context'], ['pedantic', 'int', '1 to run in pedantic mode']], 'python_accessor', None), 'xmlParserSetLoadSubset': ( 'Switch the parser to load the DTD without validating.', ['void', None, None], [['ctxt', 'xmlParserCtxt *', 'the parser context'], ['loadsubset', 'int', '1 to load the DTD']], 'python_accessor', None), 'xmlParserSetLineNumbers': ( 'Switch on the generation of line number for elements nodes.', ['void', None, None], [['ctxt', 'xmlParserCtxt *', 'the parser context'], ['linenumbers', 'int', 'unused']], 'python_accessor', None), 'xmlDebugMemory': ( 'Switch on the generation of line number for elements nodes. Also returns the number of bytes allocated and not freed by libxml2 since memory debugging was switched on.', ['int', 'returns the number of bytes allocated and not freed', None], [['activate', 'int', '1 switch on memory debugging 0 switch it off']], 'python', None), 'xmlNodeGetNs': ( 'Get the namespace of a node', ['xmlNs *', 'The namespace or None', None], [['node', 'xmlNode *', 'the node']], 'python_accessor', None), 'xmlNodeGetNsDefs': ( 'Get the namespace of a node', ['xmlNs *', 'The namespace or None', None], [['node', 'xmlNode *', 'the node']], 'python_accessor', None), 'xmlXPathParserGetContext': ( 'Get the xpathContext from an xpathParserContext', ['xmlXPathContext *', 'The XPath context', 'context'], [['ctxt', 'xmlXPathParserContext *', 'the XPath parser context']], 'python_accessor', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlXPathGetContextDoc': ( 'Get the doc from an xpathContext', ['xmlDoc *', 'The doc context', 'doc'], [['ctxt', 'xmlXPathContext *', 'the XPath context']], 'python_accessor', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlXPathGetContextNode': ( 'Get the current node from an xpathContext', ['xmlNode *', 'The node context', 'node'], [['ctxt', 'xmlXPathContext *', 'the XPath context']], 'python_accessor', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlXPathSetContextDoc': ( 'Set the doc of an xpathContext', ['void', None, None], [['ctxt', 'xmlXPathContext *', 'the XPath context'], ['doc', 'xmlDoc *', 'The doc context']], 'python_accessor', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlXPathSetContextNode': ( 'Set the current node of an xpathContext', ['void', None, None], [['ctxt', 'xmlXPathContext *', 'the XPath context'], ['node', 'xmlNode *', 'The node context']], 'python_accessor', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlXPathGetContextPosition': ( 'Get the current node from an xpathContext', ['int', 'The node context', 'proximityPosition'], [['ctxt', 'xmlXPathContext *', 'the XPath context']], 'python_accessor', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlXPathGetContextSize': ( 'Get the current node from an xpathContext', ['int', 'The node context', 'contextSize'], [['ctxt', 'xmlXPathContext *', 'the XPath context']], 'python_accessor', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlXPathGetFunction': ( 'Get the current function name xpathContext', ['const xmlChar *', 'The function name', 'function'], [['ctxt', 'xmlXPathContext *', 'the XPath context']], 'python_accessor', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlXPathGetFunctionURI': ( 'Get the current function name URI xpathContext', ['const xmlChar *', 'The function name URI', 'functionURI'], [['ctxt', 'xmlXPathContext *', 'the XPath context']], 'python_accessor', 'defined(LIBXML_XPATH_ENABLED)'), 'xmlURIGetScheme': ( 'Get the scheme part from an URI', ['const char *', 'The URI scheme', 'scheme'], [['URI', 'xmlURI *', 'the URI']], 'python_accessor', None), 'xmlURISetScheme': ( 'Set the scheme part of an URI.', ['void', None, None], [['URI', 'xmlURI *', 'the URI'], ['scheme', 'char *', 'The URI scheme part']], 'python_accessor', None), 'xmlURIGetOpaque': ( 'Get the opaque part from an URI', ['const char *', 'The URI opaque', 'opaque'], [['URI', 'xmlURI *', 'the URI']], 'python_accessor', None), 'xmlURISetOpaque': ( 'Set the opaque part of an URI.', ['void', None, None], [['URI', 'xmlURI *', 'the URI'], ['opaque', 'char *', 'The URI opaque part']], 'python_accessor', None), 'xmlURIGetAuthority': ( 'Get the authority part from an URI', ['const char *', 'The URI authority', 'authority'], [['URI', 'xmlURI *', 'the URI']], 'python_accessor', None), 'xmlURISetAuthority': ( 'Set the authority part of an URI.', ['void', None, None], [['URI', 'xmlURI *', 'the URI'], ['authority', 'char *', 'The URI authority part']], 'python_accessor', None), 'xmlURIGetServer': ( 'Get the server part from an URI', ['const char *', 'The URI server', 'server'], [['URI', 'xmlURI *', 'the URI']], 'python_accessor', None), 'xmlURISetServer': ( 'Set the server part of an URI.', ['void', None, None], [['URI', 'xmlURI *', 'the URI'], ['server', 'char *', 'The URI server part']], 'python_accessor', None), 'xmlURIGetUser': ( 'Get the user part from an URI', ['const char *', 'The URI user', 'user'], [['URI', 'xmlURI *', 'the URI']], 'python_accessor', None), 'xmlURISetUser': ( 'Set the user part of an URI.', ['void', None, None], [['URI', 'xmlURI *', 'the URI'], ['user', 'char *', 'The URI user part']], 'python_accessor', None), 'xmlURIGetPath': ( 'Get the path part from an URI', ['const char *', 'The URI path', 'path'], [['URI', 'xmlURI *', 'the URI']], 'python_accessor', None), 'xmlURISetPath': ( 'Set the path part of an URI.', ['void', None, None], [['URI', 'xmlURI *', 'the URI'], ['path', 'char *', 'The URI path part']], 'python_accessor', None), 'xmlURIGetQuery': ( 'Get the query part from an URI', ['const char *', 'The URI query', 'query'], [['URI', 'xmlURI *', 'the URI']], 'python_accessor', None), 'xmlURISetQuery': ( 'Set the query part of an URI.', ['void', None, None], [['URI', 'xmlURI *', 'the URI'], ['query', 'char *', 'The URI query part']], 'python_accessor', None), 'xmlURIGetQueryRaw': ( 'Get the raw query part from an URI (i.e. the unescaped form).', ['const char *', 'The URI query', 'query_raw'], [['URI', 'xmlURI *', 'the URI']], 'python_accessor', None), 'xmlURISetQueryRaw': ( 'Set the raw query part of an URI (i.e. the unescaped form).', ['void', None, None], [['URI', 'xmlURI *', 'the URI'], ['query_raw', 'char *', 'The raw URI query part']], 'python_accessor', None), 'xmlURIGetFragment': ( 'Get the fragment part from an URI', ['const char *', 'The URI fragment', 'fragment'], [['URI', 'xmlURI *', 'the URI']], 'python_accessor', None), 'xmlURISetFragment': ( 'Set the fragment part of an URI.', ['void', None, None], [['URI', 'xmlURI *', 'the URI'], ['fragment', 'char *', 'The URI fragment part']], 'python_accessor', None), 'xmlURIGetPort': ( 'Get the port part from an URI', ['int', 'The URI port', 'port'], [['URI', 'xmlURI *', 'the URI']], 'python_accessor', None), 'xmlURISetPort': ( 'Set the port part of an URI.', ['void', None, None], [['URI', 'xmlURI *', 'the URI'], ['port', 'int', 'The URI port part']], 'python_accessor', None), 'xmlErrorGetDomain': ( 'What part of the library raised this error', ['int', 'The error domain', 'domain'], [['Error', 'xmlError *', 'the Error']], 'python_accessor', None), 'xmlErrorGetCode': ( 'The error code, e.g. an xmlParserError', ['int', 'The error code', 'code'], [['Error', 'xmlError *', 'the Error']], 'python_accessor', None), 'xmlErrorGetMessage': ( 'human-readable informative error message', ['const char *', 'The error message', 'message'], [['Error', 'xmlError *', 'the Error']], 'python_accessor', None), 'xmlErrorGetLevel': ( 'how consequent is the error', ['int', 'The error level', 'level'], [['Error', 'xmlError *', 'the Error']], 'python_accessor', None), 'xmlErrorGetFile': ( 'the filename', ['const char *', 'The error file', 'file'], [['Error', 'xmlError *', 'the Error']], 'python_accessor', None), 'xmlErrorGetLine': ( 'the line number if available', ['int', 'The error line', 'line'], [['Error', 'xmlError *', 'the Error']], 'python_accessor', None), 'xmlPythonCleanupParser': ( "Cleanup function for the XML library. It tries to reclaim all parsing related global memory allocated for the library processing. It doesn't deallocate any document related memory. Calling this function should not prevent reusing the library but one should call xmlCleanupParser() only when the process has finished using the library or XML document built with it.", ['void', None, None], [], 'python', None), 'xmlMemoryUsed': ( 'Returns the total amount of memory allocated by libxml2', ['int', 'number of bytes allocated', None], [], 'python', None) } enums = {} # { enumType: { enumConstant: enumValue } } import os import sys import string if __name__ == "__main__": # launched as a script srcPref = os.path.dirname(sys.argv[0]) try: dstPref = sys.argv[1] except IndexError: dstPref = os.getcwd() else: # imported srcPref = os.path.dirname(__file__) dstPref = os.getcwd() ####################################################################### # # Some filtering rukes to drop functions/types which should not # be exposed as-is on the Python interface # ####################################################################### skipped_modules = { 'xmlmemory': None, 'SAX': None, 'hash': None, 'list': None, 'threads': None, # 'xpointer': None, } skipped_types = { 'int *': "usually a return type", 'xmlSAXHandler *': "not the proper interface for SAX", 'htmlSAXHandler *': "not the proper interface for SAX", 'xmlRMutex *': "thread specific, skipped", 'xmlMutex *': "thread specific, skipped", 'xmlGlobalState *': "thread specific, skipped", 'xmlList *': "internal representation not suitable for python", 'xmlBuffer *': "internal representation not suitable for python", 'FILE *': None, } ####################################################################### # # That part if purely the API acquisition phase from the # XML API description # ####################################################################### import os import xml.etree.ElementTree as etree sys.path.append(srcPref + '/../codegen') import xmlmod xmlDocDir = dstPref + '/../doc/xml' if not os.path.isdir(xmlDocDir): xmlDocDir = dstPref + '/doc/xml' if not os.path.isdir(xmlDocDir): raise Exception(f'Doxygen XML not found in {dstPref}') def extractDocs(node): text = '' if node.text is not None: text = node.text.strip() if text == 'Deprecated': text = 'DEPRECATED:' i = 0 n = len(node) for child in node: i += 1 if (child.tag != 'parameterlist' and (child.tag != 'simplesect' or child.get('kind') != 'return')): childtext = extractDocs(child) if childtext != '': if text != '': text += ' ' text += childtext tail = child.tail if tail is not None: tail = tail.strip() if tail != '': if text != '': text += ' ' text += child.tail.strip() return text for file in os.listdir(xmlDocDir): if not file.endswith('_8h.xml'): continue doc = etree.parse(xmlDocDir + '/' + file) compound = doc.find('compounddef') module = compound.find('compoundname').text if not module.endswith('.h'): continue module = module[:-2] if module in skipped_modules: continue for section in compound.findall('sectiondef'): kind = section.get('kind') if kind == 'func': for func in section.findall('memberdef'): name = func.find('name').text if name in functions: continue docs = extractDocs(func.find('detaileddescription')) rtype = etree.tostring(func.find('type'), method='text', encoding='unicode').rstrip() valid = True args = [] for arg in func.findall('param'): atype = etree.tostring(arg.find('type'), method='text', encoding='unicode').rstrip() if atype == 'void': continue aname = arg.find('declname') if aname is None: valid = False break args.append([aname.text, atype]) if not valid: continue module1, module2 = xmlmod.findModules(module, name) cond = None if module1 != '': cond = f'defined(LIBXML_{module1}_ENABLED)' if module2 != '': cond += f' && defined(LIBXML_{module2}_ENABLED)' functions[name] = (docs, [rtype], args, module, cond) elif kind == 'enum': for enum in section.findall('memberdef'): name = enum.find('name').text edict = {} enums[name] = edict prev = -1 for value in enum.findall('enumvalue'): ename = value.find('name').text init = value.find('initializer') if init is None: evalue = prev + 1 else: evalue = init.text.lstrip() if evalue[0] != '=': raise Exception(f'invalid init value {init}') evalue = eval(evalue[1:].strip()) edict[ename] = evalue prev = evalue ####################################################################### # # Table of remapping to/from the python type or class to the C # counterpart. # ####################################################################### py_types = { 'void': (None, None, None, None), 'int': ('i', None, "int", "int"), 'long': ('l', None, "long", "long"), 'double': ('d', None, "double", "double"), 'unsigned int': ('i', None, "int", "int"), 'xmlChar': ('c', None, "int", "int"), 'unsigned char *': ('z', None, "charPtr", "char *"), 'char *': ('z', None, "charPtr", "char *"), 'const char *': ('z', None, "charPtrConst", "const char *"), 'xmlChar *': ('z', None, "xmlCharPtr", "xmlChar *"), 'const xmlChar *': ('z', None, "xmlCharPtrConst", "const xmlChar *"), 'xmlNode *': ('O', "xmlNode", "xmlNodePtr", "xmlNode *"), 'const xmlNode *': ('O', "xmlNode", "xmlNodePtr", "xmlNode *"), 'xmlDtd *': ('O', "xmlNode", "xmlNodePtr", "xmlNode *"), 'const xmlDtd *': ('O', "xmlNode", "xmlNodePtr", "xmlNode *"), 'xmlAttr *': ('O', "xmlNode", "xmlNodePtr", "xmlNode *"), 'const xmlAttr *': ('O', "xmlNode", "xmlNodePtr", "xmlNode *"), 'xmlEntity *': ('O', "xmlNode", "xmlNodePtr", "xmlNode *"), 'const xmlEntity *': ('O', "xmlNode", "xmlNodePtr", "xmlNode *"), 'xmlElement *': ('O', "xmlElement", "xmlElementPtr", "xmlElement *"), 'const xmlElement *': ('O', "xmlElement", "xmlElementPtr", "xmlElement *"), 'xmlAttribute *': ('O', "xmlAttribute", "xmlAttributePtr", "xmlAttribute *"), 'const xmlAttribute *': ('O', "xmlAttribute", "xmlAttributePtr", "xmlAttribute *"), 'xmlNs *': ('O', "xmlNode", "xmlNsPtr", "xmlNs *"), 'const xmlNs *': ('O', "xmlNode", "xmlNsPtr", "xmlNs *"), 'xmlDoc *': ('O', "xmlNode", "xmlDocPtr", "xmlDoc *"), 'const xmlDoc *': ('O', "xmlNode", "xmlDocPtr", "xmlDoc *"), 'htmlDoc *': ('O', "xmlNode", "xmlDocPtr", "xmlDoc *"), 'const htmlDoc *': ('O', "xmlNode", "xmlDocPtr", "xmlDoc *"), 'htmlNode *': ('O', "xmlNode", "xmlNodePtr", "xmlNode *"), 'const htmlNode *': ('O', "xmlNode", "xmlNodePtr", "xmlNode *"), 'xmlXPathContext *': ('O', "xmlXPathContext", "xmlXPathContextPtr", "xmlXPathContext *"), 'xmlXPathParserContext *': ('O', "xmlXPathParserContext", "xmlXPathParserContextPtr", "xmlXPathParserContext *"), 'xmlParserCtxt *': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxt *"), 'htmlParserCtxt *': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxt *"), 'xmlValidCtxt *': ('O', "ValidCtxt", "xmlValidCtxtPtr", "xmlValidCtxt *"), 'xmlCatalog *': ('O', "catalog", "xmlCatalogPtr", "xmlCatalog *"), 'FILE *': ('O', "File", "FILEPtr", "FILE *"), 'xmlURI *': ('O', "URI", "xmlURIPtr", "xmlURI *"), 'const xmlError *': ('O', "Error", "xmlErrorPtr", "const xmlError *"), 'xmlError *': ('O', "Error", "xmlErrorPtr", "xmlError *"), 'xmlOutputBuffer *': ('O', "outputBuffer", "xmlOutputBufferPtr", "xmlOutputBuffer *"), 'xmlParserInputBuffer *': ('O', "inputBuffer", "xmlParserInputBufferPtr", "xmlParserInputBuffer *"), 'xmlRegexp *': ('O', "xmlReg", "xmlRegexpPtr", "xmlRegexp *"), 'xmlTextReaderLocatorPtr': ('O', "xmlTextReaderLocator", "xmlTextReaderLocatorPtr", "xmlTextReaderLocatorPtr"), 'xmlTextReader *': ('O', "xmlTextReader", "xmlTextReaderPtr", "xmlTextReader *"), 'xmlRelaxNG *': ('O', "relaxNgSchema", "xmlRelaxNGPtr", "xmlRelaxNG *"), 'xmlRelaxNGParserCtxt *': ('O', "relaxNgParserCtxt", "xmlRelaxNGParserCtxtPtr", "xmlRelaxNGParserCtxt *"), 'xmlRelaxNGValidCtxt *': ('O', "relaxNgValidCtxt", "xmlRelaxNGValidCtxtPtr", "xmlRelaxNGValidCtxt *"), 'xmlSchema *': ('O', "Schema", "xmlSchemaPtr", "xmlSchema *"), 'xmlSchemaParserCtxt *': ('O', "SchemaParserCtxt", "xmlSchemaParserCtxtPtr", "xmlSchemaParserCtxt *"), 'xmlSchemaValidCtxt *': ('O', "SchemaValidCtxt", "xmlSchemaValidCtxtPtr", "xmlSchemaValidCtxt *"), } py_return_types = { 'xmlXPathObject *': ('O', "foo", "xmlXPathObjectPtr", "xmlXPathObject *"), } unknown_types = {} foreign_encoding_args = ( 'htmlCreateMemoryParserCtxt', 'htmlCtxtReadMemory', 'htmlParseChunk', 'htmlReadMemory', 'xmlCreateMemoryParserCtxt', 'xmlCtxtReadMemory', 'xmlCtxtResetPush', 'xmlParseChunk', 'xmlParseMemory', 'xmlReadMemory', 'xmlRecoverMemory', ) ####################################################################### # # This part writes the C <-> Python stubs libxml2-py.[ch] and # the table libxml2-export.c to add when registrering the Python module # ####################################################################### # Class methods which are written by hand in libxml.c but the Python-level # code is still automatically generated (so they are not in skip_function()). skip_impl = ( 'xmlSaveFileTo', 'xmlSaveFormatFileTo', ) deprecated_funcs = { 'htmlAutoCloseTag': True, 'htmlDefaultSAXHandlerInit': True, 'htmlHandleOmittedElem': True, 'htmlInitAutoClose': True, 'htmlIsAutoClosed': True, 'htmlIsBooleanAttr': True, 'htmlIsScriptAttribute': True, 'htmlParseCharRef': True, 'htmlParseElement': True, 'xmlACatalogAdd': True, 'xmlACatalogDump': True, 'xmlACatalogRemove': True, 'xmlACatalogResolve': True, 'xmlACatalogResolvePublic': True, 'xmlACatalogResolveSystem': True, 'xmlACatalogResolveURI': True, 'xmlAddEncodingAlias': True, 'xmlByteConsumed': True, 'xmlCatalogConvert': True, 'xmlCatalogGetPublic': True, 'xmlCatalogGetSystem': True, 'xmlCatalogIsEmpty': True, 'xmlCheckFilename': True, 'xmlCheckLanguageID': True, 'xmlCleanupCharEncodingHandlers': True, 'xmlCleanupEncodingAliases': True, 'xmlCleanupGlobals': True, 'xmlClearParserCtxt': True, 'xmlConvertSGMLCatalog': True, 'xmlCopyChar': True, 'xmlCopyCharMultiByte': True, 'xmlCreateEntityParserCtxt': True, 'xmlDefaultSAXHandlerInit': True, 'xmlDelEncodingAlias': True, 'xmlDictCleanup': True, 'xmlFileMatch': True, 'xmlFreeCatalog': True, 'xmlGetCompressMode': True, 'xmlGetEncodingAlias': True, 'xmlInitCharEncodingHandlers': True, 'xmlInitGlobals': True, 'xmlInitializeDict': True, 'xmlIOFTPMatch': True, 'xmlIOHTTPMatch': True, 'xmlIsBaseChar': True, 'xmlIsBlank': True, 'xmlIsChar': True, 'xmlIsCombining': True, 'xmlIsDigit': True, 'xmlIsExtender': True, 'xmlIsIdeographic': True, 'xmlIsLetter': True, 'xmlIsMixedElement': True, 'xmlIsPubidChar': True, 'xmlIsRef': True, 'xmlKeepBlanksDefault': True, 'xmlLineNumbersDefault': True, 'xmlLoadACatalog': True, 'xmlLoadSGMLSuperCatalog': True, 'xmlNanoHTTPCleanup': True, 'xmlNanoHTTPInit': True, 'xmlNanoHTTPScanProxy': True, 'xmlNewCatalog': True, 'xmlNextChar': True, 'xmlNormalizeWindowsPath': True, 'xmlParseAttValue': True, 'xmlParseAttributeListDecl': True, 'xmlParseCDSect': True, 'xmlParseCatalogFile': True, 'xmlParseCharData': True, 'xmlParseCharRef': True, 'xmlParseComment': True, 'xmlParseDocTypeDecl': True, 'xmlParseElement': True, 'xmlParseElementDecl': True, 'xmlParseEncName': True, 'xmlParseEncodingDecl': True, 'xmlParseEndTag': True, 'xmlParseEntity': True, 'xmlParseEntityDecl': True, 'xmlParseEntityRef': True, 'xmlParseExtParsedEnt': True, 'xmlParseExternalSubset': True, 'xmlParseMarkupDecl': True, 'xmlParseMisc': True, 'xmlParseName': True, 'xmlParseNmtoken': True, 'xmlParseNotationDecl': True, 'xmlParsePEReference': True, 'xmlParsePI': True, 'xmlParsePITarget': True, 'xmlParsePubidLiteral': True, 'xmlParseReference': True, 'xmlParseSDDecl': True, 'xmlParseStartTag': True, 'xmlParseSystemLiteral': True, 'xmlParseTextDecl': True, 'xmlParseVersionInfo': True, 'xmlParseVersionNum': True, 'xmlParseXMLDecl': True, 'xmlParserHandlePEReference': True, 'xmlParserInputBufferGrow': True, 'xmlParserInputBufferPush': True, 'xmlParserInputBufferRead': True, 'xmlParserSetLineNumbers': True, 'xmlParserSetLoadSubset': True, 'xmlParserSetPedantic': True, 'xmlParserSetReplaceEntities': True, 'xmlParserSetValidate': True, 'xmlPedanticParserDefault': True, 'xmlPopInput': True, 'xmlRecoverDoc': True, 'xmlRecoverFile': True, 'xmlRecoverMemory': True, 'xmlRegexpPrint': True, 'xmlRegisterHTTPPostCallbacks': True, 'xmlRelaxNGCleanupTypes': True, 'xmlRelaxNGInitTypes': True, 'xmlRemoveRef': True, 'xmlSAXDefaultVersion': True, 'xmlSchemaCleanupTypes': True, 'xmlSchemaInitTypes': True, 'xmlSetCompressMode': True, 'xmlSetupParserForBuffer': True, 'xmlSkipBlankChars': True, 'xmlStringDecodeEntities': True, 'xmlStringLenDecodeEntities': True, 'xmlSubstituteEntitiesDefault': True, 'xmlThrDefDoValidityCheckingDefaultValue': True, 'xmlThrDefGetWarningsDefaultValue': True, 'xmlThrDefIndentTreeOutput': True, 'xmlThrDefKeepBlanksDefaultValue': True, 'xmlThrDefLineNumbersDefaultValue': True, 'xmlThrDefLoadExtDtdDefaultValue': True, 'xmlThrDefPedanticParserDefaultValue': True, 'xmlThrDefSaveNoEmptyTags': True, 'xmlThrDefSubstituteEntitiesDefaultValue': True, 'xmlThrDefTreeIndentString': True, 'xmlValidCtxtNormalizeAttributeValue': True, 'xmlValidNormalizeAttributeValue': True, 'xmlValidateAttributeValue': True, 'xmlValidateDocumentFinal': True, 'xmlValidateDtdFinal': True, 'xmlValidateNotationUse': True, 'xmlValidateOneAttribute': True, 'xmlValidateOneElement': True, 'xmlValidateOneNamespace': True, 'xmlValidatePopElement': True, 'xmlValidatePushCData': True, 'xmlValidatePushElement': True, 'xmlValidateRoot': True, 'xmlValidate': True, 'xmlXPathEvalExpr': True, 'xmlXPathInit': True, 'xmlXPtrEvalRangePredicate': True, 'xmlXPtrNewCollapsedRange': True, 'xmlXPtrNewContext': True, 'xmlXPtrNewLocationSetNodes': True, 'xmlXPtrNewRange': True, 'xmlXPtrNewRangeNodes': True, 'xmlXPtrRangeToFunction': True, } def skip_function(name): if name[0:12] == "xmlXPathWrap": return 1 if name == "xmlFreeParserCtxt": return 1 if name == "xmlCleanupParser": return 1 if name == "xmlFreeTextReader": return 1 # if name[0:11] == "xmlXPathNew": # return 1 # the next function is defined in libxml.c if name == "xmlRelaxNGFreeValidCtxt": return 1 if name == "xmlFreeValidCtxt": return 1 if name == "xmlSchemaFreeValidCtxt": return 1 if name[0:5] == "__xml": return 1 # # Those are skipped because the Const version is used of the bindings # instead. # if name == "xmlTextReaderBaseUri": return 1 if name == "xmlTextReaderLocalName": return 1 if name == "xmlTextReaderName": return 1 if name == "xmlTextReaderNamespaceUri": return 1 if name == "xmlTextReaderPrefix": return 1 if name == "xmlTextReaderXmlLang": return 1 if name == "xmlTextReaderValue": return 1 if name == "xmlOutputBufferClose": # handled by by the superclass return 1 if name == "xmlOutputBufferFlush": # handled by by the superclass return 1 if name == "xmlErrMemory": return 1 if name == "xmlValidBuildContentModel": return 1 if name == "xmlValidateElementDecl": return 1 if name == "xmlValidateAttributeDecl": return 1 if name == "xmlPopInputCallbacks": return 1 return 0 def print_function_wrapper(name, output, export, include): global py_types global unknown_types global functions global skipped_modules try: (desc, ret, args, file, cond) = functions[name] except: print("failed to get function %s infos") return if file in skipped_modules: return 0 if skip_function(name) == 1: return 0 if name in skip_impl: # Don't delete the function entry in the caller. return 1 if name.startswith('xmlUCSIs'): is_deprecated = name != 'xmlUCSIsBlock' and name != 'xmlUCSIsCat' else: is_deprecated = name in deprecated_funcs c_call = "" format="" format_args="" c_args="" c_return="" c_convert="" c_release="" num_bufs=0 for arg in args: # This should be correct if arg[1][0:6] == "const ": arg[1] = arg[1][6:] c_args = c_args + " %s %s;\n" % (arg[1], arg[0]) if arg[1] in py_types: (f, t, n, c) = py_types[arg[1]] if (f == 'z') and (name in foreign_encoding_args) and (num_bufs == 0): f = 's#' if f != None: format = format + f if t != None: format_args = format_args + ", &pyobj_%s" % (arg[0]) c_args = c_args + " PyObject *pyobj_%s;\n" % (arg[0]) c_convert = c_convert + \ " %s = (%s) Py%s_Get(pyobj_%s);\n" % (arg[0], arg[1], t, arg[0]) else: format_args = format_args + ", &%s" % (arg[0]) if f == 's#': format_args = format_args + ", &py_buffsize%d" % num_bufs c_args = c_args + " Py_ssize_t py_buffsize%d;\n" % num_bufs num_bufs = num_bufs + 1 if c_call != "": c_call = c_call + ", " c_call = c_call + "%s" % (arg[0]) if t == "File": c_release = c_release + \ " PyFile_Release(%s);\n" % (arg[0]) else: if arg[1] in skipped_types: return 0 if arg[1] in unknown_types: lst = unknown_types[arg[1]] lst.append(name) else: unknown_types[arg[1]] = [name] return -1 if format != "": format = format + ":%s" % (name) if ret[0] == 'void': if file == "python_accessor": if args[1][1] == "char *" or args[1][1] == "xmlChar *": c_call = "\n if (%s->%s != NULL) xmlFree(%s->%s);\n" % ( args[0][0], args[1][0], args[0][0], args[1][0]) c_call = c_call + " %s->%s = (%s)xmlStrdup((const xmlChar *)%s);\n" % (args[0][0], args[1][0], args[1][1], args[1][0]) else: c_call = "\n %s->%s = %s;\n" % (args[0][0], args[1][0], args[1][0]) else: c_call = "\n %s(%s);\n" % (name, c_call) ret_convert = " Py_INCREF(Py_None);\n return(Py_None);\n" elif ret[0] in py_types: (f, t, n, c) = py_types[ret[0]] c_return = c_return + " %s c_retval;\n" % (ret[0]) if file == "python_accessor" and ret[2] != None: c_call = "\n c_retval = %s->%s;\n" % (args[0][0], ret[2]) else: c_call = "\n c_retval = %s(%s);\n" % (name, c_call) ret_convert = " py_retval = libxml_%sWrap((%s) c_retval);\n" % (n,c) ret_convert = ret_convert + " return(py_retval);\n" elif ret[0] in py_return_types: (f, t, n, c) = py_return_types[ret[0]] c_return = c_return + " %s c_retval;\n" % (ret[0]) c_call = "\n c_retval = %s(%s);\n" % (name, c_call) ret_convert = " py_retval = libxml_%sWrap((%s) c_retval);\n" % (n,c) ret_convert = ret_convert + " return(py_retval);\n" else: if ret[0] in skipped_types: return 0 if ret[0] in unknown_types: lst = unknown_types[ret[0]] lst.append(name) else: unknown_types[ret[0]] = [name] return -1 if cond != None and cond != "": include.write("#if %s\n" % cond) export.write("#if %s\n" % cond) output.write("#if %s\n" % cond) include.write("PyObject * ") include.write("libxml_%s(PyObject *self, PyObject *args);\n" % (name)) export.write(" { \"%s\", libxml_%s, METH_VARARGS, NULL },\n" % (name, name)) if file == "python": # Those have been manually generated if cond != None and cond != "": include.write("#endif\n") export.write("#endif\n") output.write("#endif\n") return 1 if file == "python_accessor" and ret[0] != "void" and ret[2] is None: # Those have been manually generated if cond != None and cond != "": include.write("#endif\n") export.write("#endif\n") output.write("#endif\n") return 1 if is_deprecated: output.write("XML_IGNORE_DEPRECATION_WARNINGS\n") output.write("PyObject *\n") output.write("libxml_%s(PyObject *self ATTRIBUTE_UNUSED," % (name)) output.write(" PyObject *args") if format == "": output.write(" ATTRIBUTE_UNUSED") output.write(") {\n") if ret[0] != 'void': output.write(" PyObject *py_retval;\n") if c_return != "": output.write(c_return) if c_args != "": output.write(c_args) if is_deprecated: output.write("\n if (libxml_deprecationWarning(\"%s\") == -1)\n" % name) output.write(" return(NULL);\n") if format != "": output.write("\n if (!PyArg_ParseTuple(args, \"%s\"%s))\n" % (format, format_args)) output.write(" return(NULL);\n") if c_convert != "": output.write(c_convert) output.write(c_call) if c_release != "": output.write(c_release) output.write(ret_convert) output.write("}\n") if is_deprecated: output.write("XML_POP_WARNINGS\n") output.write("\n") if cond != None and cond != "": include.write("#endif /* %s */\n" % cond) export.write("#endif /* %s */\n" % cond) output.write("#endif /* %s */\n" % cond) return 1 def buildStubs(): global py_types global py_return_types global unknown_types py_types['pythonObject'] = ('O', "pythonObject", "pythonObject", "pythonObject") nb_wrap = 0 failed = 0 skipped = 0 include = open(os.path.join(dstPref, "libxml2-py.h"), "w") include.write("/* Generated */\n\n") export = open(os.path.join(dstPref, "libxml2-export.c"), "w") export.write("/* Generated */\n\n") wrapper = open(os.path.join(dstPref, "libxml2-py.c"), "w") wrapper.write("/* Generated */\n\n") wrapper.write("#define PY_SSIZE_T_CLEAN\n") wrapper.write("#include <Python.h>\n") wrapper.write("#include <libxml/xmlversion.h>\n") wrapper.write("#include <libxml/tree.h>\n") wrapper.write("#include <libxml/xmlschemastypes.h>\n") wrapper.write("#include \"libxml_wrap.h\"\n") wrapper.write("#include \"libxml2-py.h\"\n\n") for function in sorted(functions.keys()): ret = print_function_wrapper(function, wrapper, export, include) if ret < 0: failed = failed + 1 del functions[function] if ret == 0: skipped = skipped + 1 del functions[function] if ret == 1: nb_wrap = nb_wrap + 1 include.close() export.close() wrapper.close() # print("Generated %d wrapper functions, %d failed, %d skipped" % (nb_wrap, # failed, skipped)) # print("Missing type converters: ") # for type in list(unknown_types.keys()): # print("%s:%d " % (type, len(unknown_types[type]))) # print() ####################################################################### # # This part writes part of the Python front-end classes based on # mapping rules between types and classes and also based on function # renaming to get consistent function names at the Python level # ####################################################################### # # The type automatically remapped to generated classes # classes_type = { "xmlNode *": ("._o", "xmlNode(_obj=%s)", "xmlNode"), "xmlDoc *": ("._o", "xmlDoc(_obj=%s)", "xmlDoc"), "htmlDoc *": ("._o", "xmlDoc(_obj=%s)", "xmlDoc"), "htmlxmlDoc * *": ("._o", "xmlDoc(_obj=%s)", "xmlDoc"), "xmlAttr *": ("._o", "xmlAttr(_obj=%s)", "xmlAttr"), "xmlNs *": ("._o", "xmlNs(_obj=%s)", "xmlNs"), "xmlDtd *": ("._o", "xmlDtd(_obj=%s)", "xmlDtd"), "xmlEntity *": ("._o", "xmlEntity(_obj=%s)", "xmlEntity"), "xmlElement *": ("._o", "xmlElement(_obj=%s)", "xmlElement"), "xmlAttribute *": ("._o", "xmlAttribute(_obj=%s)", "xmlAttribute"), "xmlXPathContext *": ("._o", "xpathContext(_obj=%s)", "xpathContext"), "xmlXPathParserContext *": ("._o", "xpathParserContext(_obj=%s)", "xpathParserContext"), "xmlParserCtxt *": ("._o", "parserCtxt(_obj=%s)", "parserCtxt"), "htmlParserCtxt *": ("._o", "parserCtxt(_obj=%s)", "parserCtxt"), "xmlValidCtxt *": ("._o", "ValidCtxt(_obj=%s)", "ValidCtxt"), "xmlCatalog *": ("._o", "catalog(_obj=%s)", "catalog"), "xmlURI *": ("._o", "URI(_obj=%s)", "URI"), "const xmlError *": ("._o", "Error(_obj=%s)", "Error"), "xmlError *": ("._o", "Error(_obj=%s)", "Error"), "xmlOutputBuffer *": ("._o", "outputBuffer(_obj=%s)", "outputBuffer"), "xmlParserInputBuffer *": ("._o", "inputBuffer(_obj=%s)", "inputBuffer"), "xmlRegexp *": ("._o", "xmlReg(_obj=%s)", "xmlReg"), "xmlTextReaderLocatorPtr": ("._o", "xmlTextReaderLocator(_obj=%s)", "xmlTextReaderLocator"), "xmlTextReader *": ("._o", "xmlTextReader(_obj=%s)", "xmlTextReader"), 'xmlRelaxNG *': ('._o', "relaxNgSchema(_obj=%s)", "relaxNgSchema"), 'xmlRelaxNGParserCtxt *': ('._o', "relaxNgParserCtxt(_obj=%s)", "relaxNgParserCtxt"), 'xmlRelaxNGValidCtxt *': ('._o', "relaxNgValidCtxt(_obj=%s)", "relaxNgValidCtxt"), 'xmlSchema *': ("._o", "Schema(_obj=%s)", "Schema"), 'xmlSchemaParserCtxt *': ("._o", "SchemaParserCtxt(_obj=%s)", "SchemaParserCtxt"), 'xmlSchemaValidCtxt *': ("._o", "SchemaValidCtxt(_obj=%s)", "SchemaValidCtxt"), } converter_type = { "xmlXPathObject *": "xpathObjectRet(%s)", } primary_classes = ["xmlNode", "xmlDoc"] classes_ancestor = { "xmlNode" : "xmlCore", "xmlDtd" : "xmlNode", "xmlDoc" : "xmlNode", "xmlAttr" : "xmlNode", "xmlNs" : "xmlNode", "xmlEntity" : "xmlNode", "xmlElement" : "xmlNode", "xmlAttribute" : "xmlNode", "outputBuffer": "ioWriteWrapper", "inputBuffer": "ioReadWrapper", "parserCtxt": "parserCtxtCore", "xmlTextReader": "xmlTextReaderCore", "ValidCtxt": "ValidCtxtCore", "SchemaValidCtxt": "SchemaValidCtxtCore", "relaxNgValidCtxt": "relaxNgValidCtxtCore", } classes_destructors = { "parserCtxt": "xmlFreeParserCtxt", "catalog": "xmlFreeCatalog", "URI": "xmlFreeURI", # "outputBuffer": "xmlOutputBufferClose", "inputBuffer": "xmlFreeParserInputBuffer", "xmlReg": "xmlRegFreeRegexp", "xmlTextReader": "xmlFreeTextReader", "relaxNgSchema": "xmlRelaxNGFree", "relaxNgParserCtxt": "xmlRelaxNGFreeParserCtxt", "relaxNgValidCtxt": "xmlRelaxNGFreeValidCtxt", "Schema": "xmlSchemaFree", "SchemaParserCtxt": "xmlSchemaFreeParserCtxt", "SchemaValidCtxt": "xmlSchemaFreeValidCtxt", "ValidCtxt": "xmlFreeValidCtxt", } functions_noexcept = { "xmlHasProp": 1, "xmlHasNsProp": 1, "xmlDocSetRootElement": 1, "xmlNodeGetNs": 1, "xmlNodeGetNsDefs": 1, "xmlNextElementSibling": 1, "xmlPreviousElementSibling": 1, "xmlFirstElementChild": 1, "xmlLastElementChild": 1, } reference_keepers = { "xmlTextReader": [('inputBuffer', 'input')], "relaxNgValidCtxt": [('relaxNgSchema', 'schema')], "SchemaValidCtxt": [('Schema', 'schema')], } function_classes = {} function_classes["None"] = [] def nameFixup(name, classe, type, file): listname = classe + "List" ll = len(listname) l = len(classe) if name[0:l] == listname: func = name[l:] func = func[0:1].lower() + func[1:] elif name[0:12] == "xmlParserGet" and file == "python_accessor": func = name[12:] func = func[0:1].lower() + func[1:] elif name[0:12] == "xmlParserSet" and file == "python_accessor": func = name[12:] func = func[0:1].lower() + func[1:] elif name[0:10] == "xmlNodeGet" and file == "python_accessor": func = name[10:] func = func[0:1].lower() + func[1:] elif name[0:9] == "xmlURIGet" and file == "python_accessor": func = name[9:] func = func[0:1].lower() + func[1:] elif name[0:9] == "xmlURISet" and file == "python_accessor": func = name[6:] func = func[0:1].lower() + func[1:] elif name[0:11] == "xmlErrorGet" and file == "python_accessor": func = name[11:] func = func[0:1].lower() + func[1:] elif name[0:17] == "xmlXPathParserGet" and file == "python_accessor": func = name[17:] func = func[0:1].lower() + func[1:] elif name[0:11] == "xmlXPathGet" and file == "python_accessor": func = name[11:] func = func[0:1].lower() + func[1:] elif name[0:11] == "xmlXPathSet" and file == "python_accessor": func = name[8:] func = func[0:1].lower() + func[1:] elif name[0:15] == "xmlOutputBuffer" and file != "python": func = name[15:] func = func[0:1].lower() + func[1:] elif name[0:20] == "xmlParserInputBuffer" and file != "python": func = name[20:] func = func[0:1].lower() + func[1:] elif name[0:9] == "xmlRegexp" and file == "xmlregexp": func = "regexp" + name[9:] elif name[0:6] == "xmlReg" and file == "xmlregexp": func = "regexp" + name[6:] elif name[0:20] == "xmlTextReaderLocator" and file == "xmlreader": func = name[20:] elif name[0:18] == "xmlTextReaderConst" and file == "xmlreader": func = name[18:] elif name[0:13] == "xmlTextReader" and file == "xmlreader": func = name[13:] elif name[0:12] == "xmlReaderNew" and file == "xmlreader": func = name[9:] elif name[0:11] == "xmlACatalog": func = name[11:] func = func[0:1].lower() + func[1:] elif name[0:l] == classe: func = name[l:] func = func[0:1].lower() + func[1:] elif name[0:7] == "libxml_": func = name[7:] func = func[0:1].lower() + func[1:] elif name[0:6] == "xmlGet": func = name[6:] func = func[0:1].lower() + func[1:] elif name[0:3] == "xml": func = name[3:] func = func[0:1].lower() + func[1:] else: func = name if func[0:5] == "xPath": func = "xpath" + func[5:] elif func[0:4] == "xPtr": func = "xpointer" + func[4:] elif func[0:8] == "xInclude": func = "xinclude" + func[8:] elif func[0:2] == "iD": func = "ID" + func[2:] elif func[0:3] == "uRI": func = "URI" + func[3:] elif func[0:4] == "uTF8": func = "UTF8" + func[4:] elif func[0:3] == 'sAX': func = "SAX" + func[3:] return func def functionCompare(info1, info2): (index1, func1, name1, ret1, args1, file1) = info1 (index2, func2, name2, ret2, args2, file2) = info2 if file1 == file2: if func1 < func2: return -1 if func1 > func2: return 1 if file1 == "python_accessor": return -1 if file2 == "python_accessor": return 1 if file1 < file2: return -1 if file1 > file2: return 1 return 0 def cmp_to_key(mycmp): 'Convert a cmp= function into a key= function' class K(object): def __init__(self, obj, *args): self.obj = obj def __lt__(self, other): return mycmp(self.obj, other.obj) < 0 def __gt__(self, other): return mycmp(self.obj, other.obj) > 0 def __eq__(self, other): return mycmp(self.obj, other.obj) == 0 def __le__(self, other): return mycmp(self.obj, other.obj) <= 0 def __ge__(self, other): return mycmp(self.obj, other.obj) >= 0 def __ne__(self, other): return mycmp(self.obj, other.obj) != 0 return K def writeDoc(name, args, indent, output): if functions[name][0] is None or functions[name][0] == "": return val = functions[name][0] val = val.replace("NULL", "None") val = val.replace("\\", "\\\\") output.write(indent) output.write('"""') while len(val) > 60: if val[0] == " ": val = val[1:] continue str = val[0:60] i = str.rfind(" ") if i < 0: i = 60 str = val[0:i] val = val[i:] output.write(str) output.write('\n ') output.write(indent) output.write(val) output.write(' """\n') def buildWrappers(): global ctypes global py_types global py_return_types global unknown_types global functions global function_classes global classes_type global classes_list global converter_type global primary_classes global converter_type global classes_ancestor global converter_type global primary_classes global classes_ancestor global classes_destructors global functions_noexcept for type in classes_type.keys(): function_classes[classes_type[type][2]] = [] # # Build the list of C types to look for ordered to start # with primary classes # ctypes = [] classes_list = [] ctypes_processed = {} classes_processed = {} for classe in primary_classes: classes_list.append(classe) classes_processed[classe] = () for type in classes_type.keys(): tinfo = classes_type[type] if tinfo[2] == classe: ctypes.append(type) ctypes_processed[type] = () for type in sorted(classes_type.keys()): if type in ctypes_processed: continue tinfo = classes_type[type] if tinfo[2] not in classes_processed: classes_list.append(tinfo[2]) classes_processed[tinfo[2]] = () ctypes.append(type) ctypes_processed[type] = () for name in functions.keys(): found = 0 (desc, ret, args, file, cond) = functions[name] for type in ctypes: classe = classes_type[type][2] if name[0:3] == "xml" and len(args) >= 1 and args[0][1] == type: found = 1 func = nameFixup(name, classe, type, file) info = (0, func, name, ret, args, file) function_classes[classe].append(info) elif name[0:3] == "xml" and len(args) >= 2 and args[1][1] == type \ and file != "python_accessor": found = 1 func = nameFixup(name, classe, type, file) info = (1, func, name, ret, args, file) function_classes[classe].append(info) elif name[0:4] == "html" and len(args) >= 1 and args[0][1] == type: found = 1 func = nameFixup(name, classe, type, file) info = (0, func, name, ret, args, file) function_classes[classe].append(info) elif name[0:4] == "html" and len(args) >= 2 and args[1][1] == type \ and file != "python_accessor": found = 1 func = nameFixup(name, classe, type, file) info = (1, func, name, ret, args, file) function_classes[classe].append(info) if found == 1: continue if name[0:8] == "xmlXPath": continue if name[0:6] == "xmlStr": continue if name[0:10] == "xmlCharStr": continue func = nameFixup(name, "None", file, file) info = (0, func, name, ret, args, file) function_classes['None'].append(info) libxml_content = "" try: with open(os.path.join(srcPref, "libxml.py"), "r") as libxml_file: libxml_content = libxml_file.read() except IOError as msg: print("Error reading libxml.py:", msg) sys.exit(1) classes = open(os.path.join(dstPref, "libxml2.py"), "w") classes.write(libxml_content) if "None" in function_classes: flist = function_classes["None"] flist = sorted(flist, key=cmp_to_key(functionCompare)) oldfile = "" for info in flist: (index, func, name, ret, args, file) = info if file != oldfile: classes.write("#\n# Functions from module %s\n#\n\n" % file) oldfile = file classes.write("def %s(" % func) n = 0 for arg in args: if n != 0: classes.write(", ") classes.write("%s" % arg[0]) n = n + 1 classes.write("):\n") writeDoc(name, args, ' ', classes) for arg in args: if arg[1] in classes_type: classes.write(" if %s is None: %s__o = None\n" % (arg[0], arg[0])) classes.write(" else: %s__o = %s%s\n" % (arg[0], arg[0], classes_type[arg[1]][0])) if arg[1] in py_types: (f, t, n, c) = py_types[arg[1]] if t == "File": classes.write(" if %s is not None: %s.flush()\n" % ( arg[0], arg[0])) if ret[0] != "void": classes.write(" ret = ") else: classes.write(" ") classes.write("libxml2mod.%s(" % name) n = 0 for arg in args: if n != 0: classes.write(", ") classes.write("%s" % arg[0]) if arg[1] in classes_type: classes.write("__o") n = n + 1 classes.write(")\n") # This may be needed to reposition the I/O, but likely to cause more harm # than good. Those changes in Python3 really break the model. # for arg in args: # if arg[1] in py_types: # (f, t, n, c) = py_types[arg[1]] # if t == "File": # classes.write(" if %s is not None: %s.seek(0,0)\n"%( # arg[0], arg[0])) if ret[0] != "void": if ret[0] in classes_type: # # Raise an exception # if name in functions_noexcept: classes.write(" if ret is None:return None\n") elif name.find("URI") >= 0: classes.write( " if ret is None:raise uriError('%s() failed')\n" % (name)) elif name.find("XPath") >= 0: classes.write( " if ret is None:raise xpathError('%s() failed')\n" % (name)) elif name.find("Parse") >= 0: classes.write( " if ret is None:raise parserError('%s() failed')\n" % (name)) else: classes.write( " if ret is None:raise treeError('%s() failed')\n" % (name)) classes.write(" return ") classes.write(classes_type[ret[0]][1] % ("ret")) classes.write("\n") else: classes.write(" return ret\n") classes.write("\n") for classname in classes_list: if classname == "None": pass else: if classname in classes_ancestor: classes.write("class %s(%s):\n" % (classname, classes_ancestor[classname])) classes.write(" def __init__(self, _obj=None):\n") if classes_ancestor[classname] == "xmlCore" or \ classes_ancestor[classname] == "xmlNode": classes.write(" if checkWrapper(_obj) != 0:") classes.write(" raise TypeError") classes.write("('%s got a wrong wrapper object type')\n" % \ classname) if classname in reference_keepers: rlist = reference_keepers[classname] for ref in rlist: classes.write(" self.%s = None\n" % ref[1]) classes.write(" self._o = _obj\n") classes.write(" %s.__init__(self, _obj=_obj)\n\n" % ( classes_ancestor[classname])) if classes_ancestor[classname] == "xmlCore" or \ classes_ancestor[classname] == "xmlNode": classes.write(" def __repr__(self):\n") format = "<%s (%%s) object at 0x%%x>" % (classname) classes.write(" return \"%s\" %% (self.name, int(pos_id (self)))\n\n" % ( format)) else: classes.write("class %s:\n" % (classname)) classes.write(" def __init__(self, _obj=None):\n") if classname in reference_keepers: list = reference_keepers[classname] for ref in list: classes.write(" self.%s = None\n" % ref[1]) classes.write(" if _obj != None:self._o = _obj;return\n") classes.write(" self._o = None\n\n") destruct=None if classname in classes_destructors: classes.write(" def __del__(self):\n") classes.write(" if self._o != None:\n") classes.write(" libxml2mod.%s(self._o)\n" % classes_destructors[classname]) classes.write(" self._o = None\n\n") destruct=classes_destructors[classname] flist = function_classes[classname] flist = sorted(flist, key=cmp_to_key(functionCompare)) oldfile = "" for info in flist: (index, func, name, ret, args, file) = info # # Do not provide as method the destructors for the class # to avoid double free # if name == destruct: continue if file != oldfile: if file == "python_accessor": classes.write(" # accessors for %s\n" % (classname)) else: classes.write(" #\n") classes.write(" # %s functions from module %s\n" % ( classname, file)) classes.write(" #\n\n") oldfile = file classes.write(" def %s(self" % func) n = 0 for arg in args: if n != index: classes.write(", %s" % arg[0]) n = n + 1 classes.write("):\n") writeDoc(name, args, ' ', classes) n = 0 for arg in args: if arg[1] in classes_type: if n != index: classes.write(" if %s is None: %s__o = None\n" % (arg[0], arg[0])) classes.write(" else: %s__o = %s%s\n" % (arg[0], arg[0], classes_type[arg[1]][0])) n = n + 1 if ret[0] != "void": classes.write(" ret = ") else: classes.write(" ") classes.write("libxml2mod.%s(" % name) n = 0 for arg in args: if n != 0: classes.write(", ") if n != index: classes.write("%s" % arg[0]) if arg[1] in classes_type: classes.write("__o") else: classes.write("self") if arg[1] in classes_type: classes.write(classes_type[arg[1]][0]) n = n + 1 classes.write(")\n") if ret[0] != "void": if ret[0] in classes_type: # # Raise an exception # if name in functions_noexcept: classes.write( " if ret is None:return None\n") elif name.find("URI") >= 0: classes.write( " if ret is None:raise uriError('%s() failed')\n" % (name)) elif name.find("XPath") >= 0: classes.write( " if ret is None:raise xpathError('%s() failed')\n" % (name)) elif name.find("Parse") >= 0: classes.write( " if ret is None:raise parserError('%s() failed')\n" % (name)) else: classes.write( " if ret is None:raise treeError('%s() failed')\n" % (name)) # # generate the returned class wrapper for the object # classes.write(" __tmp = ") classes.write(classes_type[ret[0]][1] % ("ret")) classes.write("\n") # # Sometime one need to keep references of the source # class in the returned class object. # See reference_keepers for the list # tclass = classes_type[ret[0]][2] if tclass in reference_keepers: list = reference_keepers[tclass] for pref in list: if pref[0] == classname: classes.write(" __tmp.%s = self\n" % pref[1]) # # return the class # classes.write(" return __tmp\n") elif ret[0] in converter_type: # # Raise an exception # if name in functions_noexcept: classes.write( " if ret is None:return None") elif name.find("URI") >= 0: classes.write( " if ret is None:raise uriError('%s() failed')\n" % (name)) elif name.find("XPath") >= 0: classes.write( " if ret is None:raise xpathError('%s() failed')\n" % (name)) elif name.find("Parse") >= 0: classes.write( " if ret is None:raise parserError('%s() failed')\n" % (name)) else: classes.write( " if ret is None:raise treeError('%s() failed')\n" % (name)) classes.write(" return ") classes.write(converter_type[ret[0]] % ("ret")) classes.write("\n") else: classes.write(" return ret\n") classes.write("\n") # # Generate enum constants # for type in sorted(enums.keys()): enum = enums[type] classes.write("# %s\n" % type) items = enum.items() items = sorted(items, key=(lambda i: int(i[1]))) for name,value in items: classes.write("%s = %s\n" % (name,value)) classes.write("\n") classes.close() buildStubs() buildWrappers()