├── .idea ├── .gitignore ├── PythonYoutubeScrapper.iml ├── inspectionProfiles │ └── profiles_settings.xml ├── misc.xml ├── modules.xml └── vcs.xml ├── GUI.py ├── README.md ├── __main__.py ├── __pycache__ ├── GUI.cpython-310.pyc └── scrap.cpython-310.pyc ├── lxml-4.8.0.dist-info ├── INSTALLER ├── LICENSE.txt ├── LICENSES.txt ├── METADATA ├── RECORD ├── REQUESTED ├── WHEEL └── top_level.txt ├── lxml ├── ElementInclude.py ├── __init__.py ├── __pycache__ │ ├── ElementInclude.cpython-310.pyc │ ├── __init__.cpython-310.pyc │ ├── _elementpath.cpython-310.pyc │ ├── builder.cpython-310.pyc │ ├── cssselect.cpython-310.pyc │ ├── doctestcompare.cpython-310.pyc │ ├── pyclasslookup.cpython-310.pyc │ ├── sax.cpython-310.pyc │ └── usedoctest.cpython-310.pyc ├── _elementpath.cp310-win_amd64.pyd ├── _elementpath.py ├── builder.cp310-win_amd64.pyd ├── builder.py ├── cssselect.py ├── doctestcompare.py ├── etree.cp310-win_amd64.pyd ├── etree.h ├── etree_api.h ├── html │ ├── ElementSoup.py │ ├── __init__.py │ ├── __pycache__ │ │ ├── ElementSoup.cpython-310.pyc │ │ ├── __init__.cpython-310.pyc │ │ ├── _diffcommand.cpython-310.pyc │ │ ├── _html5builder.cpython-310.pyc │ │ ├── _setmixin.cpython-310.pyc │ │ ├── builder.cpython-310.pyc │ │ ├── clean.cpython-310.pyc │ │ ├── defs.cpython-310.pyc │ │ ├── diff.cpython-310.pyc │ │ ├── formfill.cpython-310.pyc │ │ ├── html5parser.cpython-310.pyc │ │ ├── soupparser.cpython-310.pyc │ │ └── usedoctest.cpython-310.pyc │ ├── _diffcommand.py │ ├── _html5builder.py │ ├── _setmixin.py │ ├── builder.py │ ├── clean.cp310-win_amd64.pyd │ ├── clean.py │ ├── defs.py │ ├── diff.cp310-win_amd64.pyd │ ├── diff.py │ ├── formfill.py │ ├── html5parser.py │ ├── soupparser.py │ └── usedoctest.py ├── includes │ ├── __init__.pxd │ ├── __init__.py │ ├── __pycache__ │ │ └── __init__.cpython-310.pyc │ ├── c14n.pxd │ ├── config.pxd │ ├── dtdvalid.pxd │ ├── etree_defs.h │ ├── etreepublic.pxd │ ├── extlibs │ │ ├── __init__.py │ │ ├── __pycache__ │ │ │ └── __init__.cpython-310.pyc │ │ ├── zconf.h │ │ └── zlib.h │ ├── htmlparser.pxd │ ├── libexslt │ │ ├── __init__.py │ │ ├── __pycache__ │ │ │ └── __init__.cpython-310.pyc │ │ ├── exslt.h │ │ ├── exsltconfig.h │ │ ├── exsltexports.h │ │ └── libexslt.h │ ├── libxml │ │ ├── DOCBparser.h │ │ ├── HTMLparser.h │ │ ├── HTMLtree.h │ │ ├── SAX.h │ │ ├── SAX2.h │ │ ├── __init__.py │ │ ├── __pycache__ │ │ │ └── __init__.cpython-310.pyc │ │ ├── c14n.h │ │ ├── catalog.h │ │ ├── chvalid.h │ │ ├── debugXML.h │ │ ├── dict.h │ │ ├── encoding.h │ │ ├── entities.h │ │ ├── globals.h │ │ ├── hash.h │ │ ├── list.h │ │ ├── nanoftp.h │ │ ├── nanohttp.h │ │ ├── parser.h │ │ ├── parserInternals.h │ │ ├── pattern.h │ │ ├── relaxng.h │ │ ├── schemasInternals.h │ │ ├── schematron.h │ │ ├── threads.h │ │ ├── tree.h │ │ ├── uri.h │ │ ├── valid.h │ │ ├── xinclude.h │ │ ├── xlink.h │ │ ├── xmlIO.h │ │ ├── xmlautomata.h │ │ ├── xmlerror.h │ │ ├── xmlexports.h │ │ ├── xmlmemory.h │ │ ├── xmlmodule.h │ │ ├── xmlreader.h │ │ ├── xmlregexp.h │ │ ├── xmlsave.h │ │ ├── xmlschemas.h │ │ ├── xmlschemastypes.h │ │ ├── xmlstring.h │ │ ├── xmlunicode.h │ │ ├── xmlversion.h │ │ ├── xmlwriter.h │ │ ├── xpath.h │ │ ├── xpathInternals.h │ │ └── xpointer.h │ ├── libxslt │ │ ├── __init__.py │ │ ├── __pycache__ │ │ │ └── __init__.cpython-310.pyc │ │ ├── attributes.h │ │ ├── documents.h │ │ ├── extensions.h │ │ ├── extra.h │ │ ├── functions.h │ │ ├── imports.h │ │ ├── keys.h │ │ ├── libxslt.h │ │ ├── namespaces.h │ │ ├── numbersInternals.h │ │ ├── preproc.h │ │ ├── security.h │ │ ├── templates.h │ │ ├── transform.h │ │ ├── trio.h │ │ ├── triodef.h │ │ ├── variables.h │ │ ├── win32config.h │ │ ├── xslt.h │ │ ├── xsltInternals.h │ │ ├── xsltconfig.h │ │ ├── xsltexports.h │ │ ├── xsltlocale.h │ │ └── xsltutils.h │ ├── lxml-version.h │ ├── relaxng.pxd │ ├── schematron.pxd │ ├── tree.pxd │ ├── uri.pxd │ ├── xinclude.pxd │ ├── xmlerror.pxd │ ├── xmlparser.pxd │ ├── xmlschema.pxd │ ├── xpath.pxd │ └── xslt.pxd ├── isoschematron │ ├── __init__.py │ ├── __pycache__ │ │ └── __init__.cpython-310.pyc │ └── resources │ │ ├── rng │ │ └── iso-schematron.rng │ │ └── xsl │ │ ├── RNG2Schtrn.xsl │ │ ├── XSD2Schtrn.xsl │ │ └── iso-schematron-xslt1 │ │ ├── iso_abstract_expand.xsl │ │ ├── iso_dsdl_include.xsl │ │ ├── iso_schematron_message.xsl │ │ ├── iso_schematron_skeleton_for_xslt1.xsl │ │ ├── iso_svrl_for_xslt1.xsl │ │ └── readme.txt ├── lxml.etree.h ├── lxml.etree_api.h ├── objectify.cp310-win_amd64.pyd ├── pyclasslookup.py ├── sax.cp310-win_amd64.pyd ├── sax.py └── usedoctest.py └── scrap.py /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | -------------------------------------------------------------------------------- /.idea/PythonYoutubeScrapper.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/inspectionProfiles/profiles_settings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 6 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /GUI.py: -------------------------------------------------------------------------------- 1 | from tkinter import * 2 | from tkinter.scrolledtext import ScrolledText 3 | from tkinter.ttk import * 4 | import scrap as sp 5 | from multiprocessing import Pool 6 | import tqdm 7 | from multiprocessing import cpu_count 8 | import csv 9 | from tkinter.filedialog import asksaveasfile 10 | from os import system, name 11 | from time import sleep 12 | 13 | def scrape(link): 14 | data = sp.Scrap(link, "video") 15 | data = data.run_video_scrapper() 16 | return data 17 | 18 | 19 | class GUI: 20 | # Backend For Requests 21 | def scrapePool(self): 22 | self.links = list(set(self.links)) 23 | with Pool(processes=cpu_count()) as pool, tqdm.tqdm( 24 | total=len(self.links)) as pbar: # create Pool of processes (only 2 in this example) and tqdm Progress bar 25 | self.list = [] # into this list I will store the urls returned from parse() function 26 | for data in pool.imap_unordered(scrape, 27 | self.links): # send urls from all_urls list to parse() function (it will be done concurently in process pool). The results returned will be unordered (returned when they are available, without waiting for other processes) 28 | if data != "": 29 | self.list.append(data) # update all_data list 30 | pbar.update() 31 | 32 | 33 | # Backend For Channel Videos` 34 | def channel_scrape(self, link): 35 | data = sp.Scrap(link) 36 | return data.get_chanel_videos() 37 | 38 | # Create Label 39 | def main_label(self): 40 | label = Label(self.gui, text="Enter Link Please", font=("Arial", 20)) 41 | label.pack() 42 | 43 | def radio(self): 44 | self.type = StringVar(None, "video") 45 | radiobutton_1 = Radiobutton(self.gui, text='Videos', variable=self.type, value="video") 46 | radiobutton_1.pack() 47 | radiobutton_2 = Radiobutton(self.gui, text='Channels', variable=self.type, value="channel") 48 | radiobutton_2.pack() 49 | 50 | # Create Input & Button 51 | def input(self): 52 | style = Style() 53 | style.configure('W.TButton', font= 54 | ('calibri', 10, 'bold', 'underline'), 55 | foreground='red') 56 | self.yt_link = ScrolledText(self.gui, height=15) 57 | self.yt_link.pack() 58 | self.save_btn = Button(self.gui, text='Generate CSV', style = 'W.TButton', command=self.save) 59 | self.save_btn.pack(pady=10) 60 | 61 | def run(self): 62 | self.gui.mainloop() 63 | 64 | def save(self): 65 | self.saveText = self.yt_link.get('1.0', END) # Get all text in widget. 66 | self.radioType = self.type.get() 67 | self.yt_link.configure(state=DISABLED) 68 | self.save_btn.configure(state=DISABLED) 69 | if self.type.get() == "video": 70 | self.links = self.saveText.split("\n") 71 | self.links = [i for i in self.links if i] 72 | self.scrapePool() 73 | self.csv_export() 74 | self.finish_process() 75 | else: 76 | self.links = self.saveText.split("\n") 77 | self.links = self.links[0] 78 | self.links = self.channel_scrape(self.links) 79 | self.scrapePool() 80 | self.csv_export() 81 | self.finish_process() 82 | print("DONE! Clearing screen in 3 Seconds!") 83 | sleep(3) 84 | _ = system('cls') 85 | 86 | def csv_export(self): 87 | data = [("csv file(*.csv)", "*.csv")] 88 | try: 89 | file = asksaveasfile(filetypes=data, defaultextension=data) 90 | 91 | keys = self.list[0].keys() 92 | 93 | with open(file.name, 'w', newline='', encoding="utf-8") as csvfile: 94 | dict_writer = csv.DictWriter(csvfile, keys) 95 | dict_writer.writeheader() 96 | dict_writer.writerows(self.list) 97 | except: 98 | pass 99 | 100 | 101 | def finish_process(self): 102 | self.yt_link.configure(state=NORMAL) 103 | self.save_btn.configure(state=NORMAL) 104 | self.yt_link.delete("1.0", END) 105 | self.list = [] 106 | self.links = [] 107 | 108 | 109 | def __init__(self): 110 | self.gui = Tk() 111 | self.gui.title("Youtube Scrapper") 112 | self.gui.geometry("800x400") 113 | self.main_label() 114 | self.radio() 115 | self.input() 116 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # PythonYoutubeScrapper 2 | Youtube Scrapper in Python using Bs4 3 | -------------------------------------------------------------------------------- /__main__.py: -------------------------------------------------------------------------------- 1 | import scrap as sp 2 | import GUI 3 | from multiprocessing import freeze_support 4 | 5 | def main(): 6 | freeze_support() 7 | gui = GUI.GUI() 8 | gui.run() 9 | 10 | 11 | if __name__ == "__main__": 12 | main() -------------------------------------------------------------------------------- /__pycache__/GUI.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/__pycache__/GUI.cpython-310.pyc -------------------------------------------------------------------------------- /__pycache__/scrap.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/__pycache__/scrap.cpython-310.pyc -------------------------------------------------------------------------------- /lxml-4.8.0.dist-info/INSTALLER: -------------------------------------------------------------------------------- 1 | pip 2 | -------------------------------------------------------------------------------- /lxml-4.8.0.dist-info/LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 2004 Infrae. All rights reserved. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | 1. Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | 10 | 2. Redistributions in binary form must reproduce the above copyright 11 | notice, this list of conditions and the following disclaimer in 12 | the documentation and/or other materials provided with the 13 | distribution. 14 | 15 | 3. Neither the name of Infrae nor the names of its contributors may 16 | be used to endorse or promote products derived from this software 17 | without specific prior written permission. 18 | 19 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INFRAE OR 23 | CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 24 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 25 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 26 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 27 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 28 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 29 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 | -------------------------------------------------------------------------------- /lxml-4.8.0.dist-info/LICENSES.txt: -------------------------------------------------------------------------------- 1 | lxml is copyright Infrae and distributed under the BSD license (see 2 | doc/licenses/BSD.txt), with the following exceptions: 3 | 4 | Some code, such a selftest.py, selftest2.py and 5 | src/lxml/_elementpath.py are derived from ElementTree and 6 | cElementTree. See doc/licenses/elementtree.txt for the license text. 7 | 8 | lxml.cssselect and lxml.html are copyright Ian Bicking and distributed 9 | under the BSD license (see doc/licenses/BSD.txt). 10 | 11 | test.py, the test-runner script, is GPL and copyright Shuttleworth 12 | Foundation. See doc/licenses/GPL.txt. It is believed the unchanged 13 | inclusion of test.py to run the unit test suite falls under the 14 | "aggregation" clause of the GPL and thus does not affect the license 15 | of the rest of the package. 16 | 17 | The isoschematron implementation uses several XSL and RelaxNG resources: 18 | * The (XML syntax) RelaxNG schema for schematron, copyright International 19 | Organization for Standardization (see 20 | src/lxml/isoschematron/resources/rng/iso-schematron.rng for the license 21 | text) 22 | * The skeleton iso-schematron-xlt1 pure-xslt schematron implementation 23 | xsl stylesheets, copyright Rick Jelliffe and Academia Sinica Computing 24 | Center, Taiwan (see the xsl files here for the license text: 25 | src/lxml/isoschematron/resources/xsl/iso-schematron-xslt1/) 26 | * The xsd/rng schema schematron extraction xsl transformations are unlicensed 27 | and copyright the respective authors as noted (see 28 | src/lxml/isoschematron/resources/xsl/RNG2Schtrn.xsl and 29 | src/lxml/isoschematron/resources/xsl/XSD2Schtrn.xsl) 30 | -------------------------------------------------------------------------------- /lxml-4.8.0.dist-info/METADATA: -------------------------------------------------------------------------------- 1 | Metadata-Version: 2.1 2 | Name: lxml 3 | Version: 4.8.0 4 | Summary: Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API. 5 | Home-page: https://lxml.de/ 6 | Author: lxml dev team 7 | Author-email: lxml-dev@lxml.de 8 | Maintainer: lxml dev team 9 | Maintainer-email: lxml-dev@lxml.de 10 | License: BSD 11 | Project-URL: Source, https://github.com/lxml/lxml 12 | Platform: UNKNOWN 13 | Classifier: Development Status :: 5 - Production/Stable 14 | Classifier: Intended Audience :: Developers 15 | Classifier: Intended Audience :: Information Technology 16 | Classifier: License :: OSI Approved :: BSD License 17 | Classifier: Programming Language :: Cython 18 | Classifier: Programming Language :: Python :: 2 19 | Classifier: Programming Language :: Python :: 2.7 20 | Classifier: Programming Language :: Python :: 3 21 | Classifier: Programming Language :: Python :: 3.5 22 | Classifier: Programming Language :: Python :: 3.6 23 | Classifier: Programming Language :: Python :: 3.7 24 | Classifier: Programming Language :: Python :: 3.8 25 | Classifier: Programming Language :: Python :: 3.9 26 | Classifier: Programming Language :: Python :: 3.10 27 | Classifier: Programming Language :: C 28 | Classifier: Operating System :: OS Independent 29 | Classifier: Topic :: Text Processing :: Markup :: HTML 30 | Classifier: Topic :: Text Processing :: Markup :: XML 31 | Classifier: Topic :: Software Development :: Libraries :: Python Modules 32 | Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, != 3.4.* 33 | License-File: LICENSE.txt 34 | License-File: LICENSES.txt 35 | Provides-Extra: cssselect 36 | Requires-Dist: cssselect (>=0.7) ; extra == 'cssselect' 37 | Provides-Extra: html5 38 | Requires-Dist: html5lib ; extra == 'html5' 39 | Provides-Extra: htmlsoup 40 | Requires-Dist: BeautifulSoup4 ; extra == 'htmlsoup' 41 | Provides-Extra: source 42 | Requires-Dist: Cython (>=0.29.7) ; extra == 'source' 43 | 44 | lxml is a Pythonic, mature binding for the libxml2 and libxslt libraries. It 45 | provides safe and convenient access to these libraries using the ElementTree 46 | API. 47 | 48 | It extends the ElementTree API significantly to offer support for XPath, 49 | RelaxNG, XML Schema, XSLT, C14N and much more. 50 | 51 | To contact the project, go to the `project home page 52 | `_ or see our bug tracker at 53 | https://launchpad.net/lxml 54 | 55 | In case you want to use the current in-development version of lxml, 56 | you can get it from the github repository at 57 | https://github.com/lxml/lxml . Note that this requires Cython to 58 | build the sources, see the build instructions on the project home 59 | page. To the same end, running ``easy_install lxml==dev`` will 60 | install lxml from 61 | https://github.com/lxml/lxml/tarball/master#egg=lxml-dev if you have 62 | an appropriate version of Cython installed. 63 | 64 | 65 | After an official release of a new stable series, bug fixes may become 66 | available at 67 | https://github.com/lxml/lxml/tree/lxml-4.8 . 68 | Running ``easy_install lxml==4.8bugfix`` will install 69 | the unreleased branch state from 70 | https://github.com/lxml/lxml/tarball/lxml-4.8#egg=lxml-4.8bugfix 71 | as soon as a maintenance branch has been established. Note that this 72 | requires Cython to be installed at an appropriate version for the build. 73 | 74 | 4.8.0 (2022-02-17) 75 | ================== 76 | 77 | Features added 78 | -------------- 79 | 80 | * GH#337: Path-like objects are now supported throughout the API instead of just strings. 81 | Patch by Henning Janssen. 82 | 83 | * The ``ElementMaker`` now supports ``QName`` values as tags, which always override 84 | the default namespace of the factory. 85 | 86 | Bugs fixed 87 | ---------- 88 | 89 | * GH#338: In lxml.objectify, the XSI float annotation "nan" and "inf" were spelled in 90 | lower case, whereas XML Schema datatypes define them as "NaN" and "INF" respectively. 91 | Patch by Tobias Deiminger. 92 | 93 | Other changes 94 | ------------- 95 | 96 | * Built with Cython 0.29.28. 97 | 98 | 99 | 100 | 101 | -------------------------------------------------------------------------------- /lxml-4.8.0.dist-info/REQUESTED: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml-4.8.0.dist-info/REQUESTED -------------------------------------------------------------------------------- /lxml-4.8.0.dist-info/WHEEL: -------------------------------------------------------------------------------- 1 | Wheel-Version: 1.0 2 | Generator: bdist_wheel (0.37.1) 3 | Root-Is-Purelib: false 4 | Tag: cp310-cp310-win_amd64 5 | 6 | -------------------------------------------------------------------------------- /lxml-4.8.0.dist-info/top_level.txt: -------------------------------------------------------------------------------- 1 | lxml 2 | -------------------------------------------------------------------------------- /lxml/__init__.py: -------------------------------------------------------------------------------- 1 | # this is a package 2 | 3 | __version__ = "4.8.0" 4 | 5 | 6 | def get_include(): 7 | """ 8 | Returns a list of header include paths (for lxml itself, libxml2 9 | and libxslt) needed to compile C code against lxml if it was built 10 | with statically linked libraries. 11 | """ 12 | import os 13 | lxml_path = __path__[0] 14 | include_path = os.path.join(lxml_path, 'includes') 15 | includes = [include_path, lxml_path] 16 | 17 | for name in os.listdir(include_path): 18 | path = os.path.join(include_path, name) 19 | if os.path.isdir(path): 20 | includes.append(path) 21 | 22 | return includes 23 | 24 | -------------------------------------------------------------------------------- /lxml/__pycache__/ElementInclude.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/__pycache__/ElementInclude.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/__pycache__/__init__.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/__pycache__/__init__.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/__pycache__/_elementpath.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/__pycache__/_elementpath.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/__pycache__/builder.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/__pycache__/builder.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/__pycache__/cssselect.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/__pycache__/cssselect.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/__pycache__/doctestcompare.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/__pycache__/doctestcompare.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/__pycache__/pyclasslookup.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/__pycache__/pyclasslookup.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/__pycache__/sax.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/__pycache__/sax.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/__pycache__/usedoctest.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/__pycache__/usedoctest.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/_elementpath.cp310-win_amd64.pyd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/_elementpath.cp310-win_amd64.pyd -------------------------------------------------------------------------------- /lxml/builder.cp310-win_amd64.pyd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/builder.cp310-win_amd64.pyd -------------------------------------------------------------------------------- /lxml/cssselect.py: -------------------------------------------------------------------------------- 1 | """CSS Selectors based on XPath. 2 | 3 | This module supports selecting XML/HTML tags based on CSS selectors. 4 | See the `CSSSelector` class for details. 5 | 6 | This is a thin wrapper around cssselect 0.7 or later. 7 | """ 8 | 9 | from __future__ import absolute_import 10 | 11 | from . import etree 12 | try: 13 | import cssselect as external_cssselect 14 | except ImportError: 15 | raise ImportError( 16 | 'cssselect does not seem to be installed. ' 17 | 'See http://packages.python.org/cssselect/') 18 | 19 | 20 | SelectorSyntaxError = external_cssselect.SelectorSyntaxError 21 | ExpressionError = external_cssselect.ExpressionError 22 | SelectorError = external_cssselect.SelectorError 23 | 24 | 25 | __all__ = ['SelectorSyntaxError', 'ExpressionError', 'SelectorError', 26 | 'CSSSelector'] 27 | 28 | 29 | class LxmlTranslator(external_cssselect.GenericTranslator): 30 | """ 31 | A custom CSS selector to XPath translator with lxml-specific extensions. 32 | """ 33 | def xpath_contains_function(self, xpath, function): 34 | # Defined there, removed in later drafts: 35 | # http://www.w3.org/TR/2001/CR-css3-selectors-20011113/#content-selectors 36 | if function.argument_types() not in (['STRING'], ['IDENT']): 37 | raise ExpressionError( 38 | "Expected a single string or ident for :contains(), got %r" 39 | % function.arguments) 40 | value = function.arguments[0].value 41 | return xpath.add_condition( 42 | 'contains(__lxml_internal_css:lower-case(string(.)), %s)' 43 | % self.xpath_literal(value.lower())) 44 | 45 | 46 | class LxmlHTMLTranslator(LxmlTranslator, external_cssselect.HTMLTranslator): 47 | """ 48 | lxml extensions + HTML support. 49 | """ 50 | 51 | 52 | def _make_lower_case(context, s): 53 | return s.lower() 54 | 55 | ns = etree.FunctionNamespace('http://codespeak.net/lxml/css/') 56 | ns.prefix = '__lxml_internal_css' 57 | ns['lower-case'] = _make_lower_case 58 | 59 | 60 | class CSSSelector(etree.XPath): 61 | """A CSS selector. 62 | 63 | Usage:: 64 | 65 | >>> from lxml import etree, cssselect 66 | >>> select = cssselect.CSSSelector("a tag > child") 67 | 68 | >>> root = etree.XML("TEXT") 69 | >>> [ el.tag for el in select(root) ] 70 | ['child'] 71 | 72 | To use CSS namespaces, you need to pass a prefix-to-namespace 73 | mapping as ``namespaces`` keyword argument:: 74 | 75 | >>> rdfns = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#' 76 | >>> select_ns = cssselect.CSSSelector('root > rdf|Description', 77 | ... namespaces={'rdf': rdfns}) 78 | 79 | >>> rdf = etree.XML(( 80 | ... '' 81 | ... 'blah' 82 | ... '') % rdfns) 83 | >>> [(el.tag, el.text) for el in select_ns(rdf)] 84 | [('{http://www.w3.org/1999/02/22-rdf-syntax-ns#}Description', 'blah')] 85 | 86 | """ 87 | def __init__(self, css, namespaces=None, translator='xml'): 88 | if translator == 'xml': 89 | translator = LxmlTranslator() 90 | elif translator == 'html': 91 | translator = LxmlHTMLTranslator() 92 | elif translator == 'xhtml': 93 | translator = LxmlHTMLTranslator(xhtml=True) 94 | path = translator.css_to_xpath(css) 95 | etree.XPath.__init__(self, path, namespaces=namespaces) 96 | self.css = css 97 | 98 | def __repr__(self): 99 | return '<%s %s for %r>' % ( 100 | self.__class__.__name__, 101 | hex(abs(id(self)))[2:], 102 | self.css) 103 | -------------------------------------------------------------------------------- /lxml/etree.cp310-win_amd64.pyd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/etree.cp310-win_amd64.pyd -------------------------------------------------------------------------------- /lxml/html/ElementSoup.py: -------------------------------------------------------------------------------- 1 | __doc__ = """Legacy interface to the BeautifulSoup HTML parser. 2 | """ 3 | 4 | __all__ = ["parse", "convert_tree"] 5 | 6 | from .soupparser import convert_tree, parse as _parse 7 | 8 | def parse(file, beautifulsoup=None, makeelement=None): 9 | root = _parse(file, beautifulsoup=beautifulsoup, makeelement=makeelement) 10 | return root.getroot() 11 | -------------------------------------------------------------------------------- /lxml/html/__pycache__/ElementSoup.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/ElementSoup.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/__init__.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/__init__.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/_diffcommand.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/_diffcommand.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/_html5builder.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/_html5builder.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/_setmixin.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/_setmixin.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/builder.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/builder.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/clean.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/clean.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/defs.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/defs.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/diff.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/diff.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/formfill.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/formfill.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/html5parser.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/html5parser.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/soupparser.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/soupparser.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/__pycache__/usedoctest.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/__pycache__/usedoctest.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/html/_diffcommand.py: -------------------------------------------------------------------------------- 1 | from __future__ import absolute_import 2 | 3 | import optparse 4 | import sys 5 | import re 6 | import os 7 | from .diff import htmldiff 8 | 9 | description = """\ 10 | """ 11 | 12 | parser = optparse.OptionParser( 13 | usage="%prog [OPTIONS] FILE1 FILE2\n" 14 | "%prog --annotate [OPTIONS] INFO1 FILE1 INFO2 FILE2 ...", 15 | description=description, 16 | ) 17 | 18 | parser.add_option( 19 | '-o', '--output', 20 | metavar="FILE", 21 | dest="output", 22 | default="-", 23 | help="File to write the difference to", 24 | ) 25 | 26 | parser.add_option( 27 | '-a', '--annotation', 28 | action="store_true", 29 | dest="annotation", 30 | help="Do an annotation") 31 | 32 | def main(args=None): 33 | if args is None: 34 | args = sys.argv[1:] 35 | options, args = parser.parse_args(args) 36 | if options.annotation: 37 | return annotate(options, args) 38 | if len(args) != 2: 39 | print('Error: you must give two files') 40 | parser.print_help() 41 | sys.exit(1) 42 | file1, file2 = args 43 | input1 = read_file(file1) 44 | input2 = read_file(file2) 45 | body1 = split_body(input1)[1] 46 | pre, body2, post = split_body(input2) 47 | result = htmldiff(body1, body2) 48 | result = pre + result + post 49 | if options.output == '-': 50 | if not result.endswith('\n'): 51 | result += '\n' 52 | sys.stdout.write(result) 53 | else: 54 | with open(options.output, 'wb') as f: 55 | f.write(result) 56 | 57 | def read_file(filename): 58 | if filename == '-': 59 | c = sys.stdin.read() 60 | elif not os.path.exists(filename): 61 | raise OSError( 62 | "Input file %s does not exist" % filename) 63 | else: 64 | with open(filename, 'rb') as f: 65 | c = f.read() 66 | return c 67 | 68 | body_start_re = re.compile( 69 | r"", re.I|re.S) 70 | body_end_re = re.compile( 71 | r"", re.I|re.S) 72 | 73 | def split_body(html): 74 | pre = post = '' 75 | match = body_start_re.search(html) 76 | if match: 77 | pre = html[:match.end()] 78 | html = html[match.end():] 79 | match = body_end_re.search(html) 80 | if match: 81 | post = html[match.start():] 82 | html = html[:match.start()] 83 | return pre, html, post 84 | 85 | def annotate(options, args): 86 | print("Not yet implemented") 87 | sys.exit(1) 88 | 89 | -------------------------------------------------------------------------------- /lxml/html/_html5builder.py: -------------------------------------------------------------------------------- 1 | """ 2 | Legacy module - don't use in new code! 3 | 4 | html5lib now has its own proper implementation. 5 | 6 | This module implements a tree builder for html5lib that generates lxml 7 | html element trees. This module uses camelCase as it follows the 8 | html5lib style guide. 9 | """ 10 | 11 | from html5lib.treebuilders import _base, etree as etree_builders 12 | from lxml import html, etree 13 | 14 | 15 | class DocumentType(object): 16 | 17 | def __init__(self, name, publicId, systemId): 18 | self.name = name 19 | self.publicId = publicId 20 | self.systemId = systemId 21 | 22 | class Document(object): 23 | 24 | def __init__(self): 25 | self._elementTree = None 26 | self.childNodes = [] 27 | 28 | def appendChild(self, element): 29 | self._elementTree.getroot().addnext(element._element) 30 | 31 | 32 | class TreeBuilder(_base.TreeBuilder): 33 | documentClass = Document 34 | doctypeClass = DocumentType 35 | elementClass = None 36 | commentClass = None 37 | fragmentClass = Document 38 | 39 | def __init__(self, *args, **kwargs): 40 | html_builder = etree_builders.getETreeModule(html, fullTree=False) 41 | etree_builder = etree_builders.getETreeModule(etree, fullTree=False) 42 | self.elementClass = html_builder.Element 43 | self.commentClass = etree_builder.Comment 44 | _base.TreeBuilder.__init__(self, *args, **kwargs) 45 | 46 | def reset(self): 47 | _base.TreeBuilder.reset(self) 48 | self.rootInserted = False 49 | self.initialComments = [] 50 | self.doctype = None 51 | 52 | def getDocument(self): 53 | return self.document._elementTree 54 | 55 | def getFragment(self): 56 | fragment = [] 57 | element = self.openElements[0]._element 58 | if element.text: 59 | fragment.append(element.text) 60 | fragment.extend(element.getchildren()) 61 | if element.tail: 62 | fragment.append(element.tail) 63 | return fragment 64 | 65 | def insertDoctype(self, name, publicId, systemId): 66 | doctype = self.doctypeClass(name, publicId, systemId) 67 | self.doctype = doctype 68 | 69 | def insertComment(self, data, parent=None): 70 | if not self.rootInserted: 71 | self.initialComments.append(data) 72 | else: 73 | _base.TreeBuilder.insertComment(self, data, parent) 74 | 75 | def insertRoot(self, name): 76 | buf = [] 77 | if self.doctype and self.doctype.name: 78 | buf.append('') 83 | buf.append('') 84 | root = html.fromstring(''.join(buf)) 85 | 86 | # Append the initial comments: 87 | for comment in self.initialComments: 88 | root.addprevious(etree.Comment(comment)) 89 | 90 | # Create the root document and add the ElementTree to it 91 | self.document = self.documentClass() 92 | self.document._elementTree = root.getroottree() 93 | 94 | # Add the root element to the internal child/open data structures 95 | root_element = self.elementClass(name) 96 | root_element._element = root 97 | self.document.childNodes.append(root_element) 98 | self.openElements.append(root_element) 99 | 100 | self.rootInserted = True 101 | -------------------------------------------------------------------------------- /lxml/html/_setmixin.py: -------------------------------------------------------------------------------- 1 | try: 2 | from collections.abc import MutableSet 3 | except ImportError: 4 | from collections import MutableSet 5 | 6 | 7 | class SetMixin(MutableSet): 8 | 9 | """ 10 | Mix-in for sets. You must define __iter__, add, remove 11 | """ 12 | 13 | def __len__(self): 14 | length = 0 15 | for item in self: 16 | length += 1 17 | return length 18 | 19 | def __contains__(self, item): 20 | for has_item in self: 21 | if item == has_item: 22 | return True 23 | return False 24 | 25 | issubset = MutableSet.__le__ 26 | issuperset = MutableSet.__ge__ 27 | 28 | union = MutableSet.__or__ 29 | intersection = MutableSet.__and__ 30 | difference = MutableSet.__sub__ 31 | symmetric_difference = MutableSet.__xor__ 32 | 33 | def copy(self): 34 | return set(self) 35 | 36 | def update(self, other): 37 | self |= other 38 | 39 | def intersection_update(self, other): 40 | self &= other 41 | 42 | def difference_update(self, other): 43 | self -= other 44 | 45 | def symmetric_difference_update(self, other): 46 | self ^= other 47 | 48 | def discard(self, item): 49 | try: 50 | self.remove(item) 51 | except KeyError: 52 | pass 53 | 54 | @classmethod 55 | def _from_iterable(cls, it): 56 | return set(it) 57 | -------------------------------------------------------------------------------- /lxml/html/builder.py: -------------------------------------------------------------------------------- 1 | # -------------------------------------------------------------------- 2 | # The ElementTree toolkit is 3 | # Copyright (c) 1999-2004 by Fredrik Lundh 4 | # -------------------------------------------------------------------- 5 | 6 | """ 7 | A set of HTML generator tags for building HTML documents. 8 | 9 | Usage:: 10 | 11 | >>> from lxml.html.builder import * 12 | >>> html = HTML( 13 | ... HEAD( TITLE("Hello World") ), 14 | ... BODY( CLASS("main"), 15 | ... H1("Hello World !") 16 | ... ) 17 | ... ) 18 | 19 | >>> import lxml.etree 20 | >>> print lxml.etree.tostring(html, pretty_print=True) 21 | 22 | 23 | Hello World 24 | 25 | 26 |

Hello World !

27 | 28 | 29 | 30 | """ 31 | 32 | from lxml.builder import ElementMaker 33 | from lxml.html import html_parser 34 | 35 | E = ElementMaker(makeelement=html_parser.makeelement) 36 | 37 | # elements 38 | A = E.a #: anchor 39 | ABBR = E.abbr #: abbreviated form (e.g., WWW, HTTP, etc.) 40 | ACRONYM = E.acronym #: 41 | ADDRESS = E.address #: information on author 42 | APPLET = E.applet #: Java applet (DEPRECATED) 43 | AREA = E.area #: client-side image map area 44 | B = E.b #: bold text style 45 | BASE = E.base #: document base URI 46 | BASEFONT = E.basefont #: base font size (DEPRECATED) 47 | BDO = E.bdo #: I18N BiDi over-ride 48 | BIG = E.big #: large text style 49 | BLOCKQUOTE = E.blockquote #: long quotation 50 | BODY = E.body #: document body 51 | BR = E.br #: forced line break 52 | BUTTON = E.button #: push button 53 | CAPTION = E.caption #: table caption 54 | CENTER = E.center #: shorthand for DIV align=center (DEPRECATED) 55 | CITE = E.cite #: citation 56 | CODE = E.code #: computer code fragment 57 | COL = E.col #: table column 58 | COLGROUP = E.colgroup #: table column group 59 | DD = E.dd #: definition description 60 | DEL = getattr(E, 'del') #: deleted text 61 | DFN = E.dfn #: instance definition 62 | DIR = E.dir #: directory list (DEPRECATED) 63 | DIV = E.div #: generic language/style container 64 | DL = E.dl #: definition list 65 | DT = E.dt #: definition term 66 | EM = E.em #: emphasis 67 | FIELDSET = E.fieldset #: form control group 68 | FONT = E.font #: local change to font (DEPRECATED) 69 | FORM = E.form #: interactive form 70 | FRAME = E.frame #: subwindow 71 | FRAMESET = E.frameset #: window subdivision 72 | H1 = E.h1 #: heading 73 | H2 = E.h2 #: heading 74 | H3 = E.h3 #: heading 75 | H4 = E.h4 #: heading 76 | H5 = E.h5 #: heading 77 | H6 = E.h6 #: heading 78 | HEAD = E.head #: document head 79 | HR = E.hr #: horizontal rule 80 | HTML = E.html #: document root element 81 | I = E.i #: italic text style 82 | IFRAME = E.iframe #: inline subwindow 83 | IMG = E.img #: Embedded image 84 | INPUT = E.input #: form control 85 | INS = E.ins #: inserted text 86 | ISINDEX = E.isindex #: single line prompt (DEPRECATED) 87 | KBD = E.kbd #: text to be entered by the user 88 | LABEL = E.label #: form field label text 89 | LEGEND = E.legend #: fieldset legend 90 | LI = E.li #: list item 91 | LINK = E.link #: a media-independent link 92 | MAP = E.map #: client-side image map 93 | MENU = E.menu #: menu list (DEPRECATED) 94 | META = E.meta #: generic metainformation 95 | NOFRAMES = E.noframes #: alternate content container for non frame-based rendering 96 | NOSCRIPT = E.noscript #: alternate content container for non script-based rendering 97 | OBJECT = E.object #: generic embedded object 98 | OL = E.ol #: ordered list 99 | OPTGROUP = E.optgroup #: option group 100 | OPTION = E.option #: selectable choice 101 | P = E.p #: paragraph 102 | PARAM = E.param #: named property value 103 | PRE = E.pre #: preformatted text 104 | Q = E.q #: short inline quotation 105 | S = E.s #: strike-through text style (DEPRECATED) 106 | SAMP = E.samp #: sample program output, scripts, etc. 107 | SCRIPT = E.script #: script statements 108 | SELECT = E.select #: option selector 109 | SMALL = E.small #: small text style 110 | SPAN = E.span #: generic language/style container 111 | STRIKE = E.strike #: strike-through text (DEPRECATED) 112 | STRONG = E.strong #: strong emphasis 113 | STYLE = E.style #: style info 114 | SUB = E.sub #: subscript 115 | SUP = E.sup #: superscript 116 | TABLE = E.table #: 117 | TBODY = E.tbody #: table body 118 | TD = E.td #: table data cell 119 | TEXTAREA = E.textarea #: multi-line text field 120 | TFOOT = E.tfoot #: table footer 121 | TH = E.th #: table header cell 122 | THEAD = E.thead #: table header 123 | TITLE = E.title #: document title 124 | TR = E.tr #: table row 125 | TT = E.tt #: teletype or monospaced text style 126 | U = E.u #: underlined text style (DEPRECATED) 127 | UL = E.ul #: unordered list 128 | VAR = E.var #: instance of a variable or program argument 129 | 130 | # attributes (only reserved words are included here) 131 | ATTR = dict 132 | def CLASS(v): return {'class': v} 133 | def FOR(v): return {'for': v} 134 | -------------------------------------------------------------------------------- /lxml/html/clean.cp310-win_amd64.pyd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/clean.cp310-win_amd64.pyd -------------------------------------------------------------------------------- /lxml/html/defs.py: -------------------------------------------------------------------------------- 1 | # FIXME: this should all be confirmed against what a DTD says 2 | # (probably in a test; this may not match the DTD exactly, but we 3 | # should document just how it differs). 4 | 5 | """ 6 | Data taken from https://www.w3.org/TR/html401/index/elements.html 7 | and https://www.w3.org/community/webed/wiki/HTML/New_HTML5_Elements 8 | for html5_tags. 9 | """ 10 | 11 | empty_tags = frozenset([ 12 | 'area', 'base', 'basefont', 'br', 'col', 'frame', 'hr', 13 | 'img', 'input', 'isindex', 'link', 'meta', 'param', 'source', 'track']) 14 | 15 | deprecated_tags = frozenset([ 16 | 'applet', 'basefont', 'center', 'dir', 'font', 'isindex', 17 | 'menu', 's', 'strike', 'u']) 18 | 19 | # archive actually takes a space-separated list of URIs 20 | link_attrs = frozenset([ 21 | 'action', 'archive', 'background', 'cite', 'classid', 22 | 'codebase', 'data', 'href', 'longdesc', 'profile', 'src', 23 | 'usemap', 24 | # Not standard: 25 | 'dynsrc', 'lowsrc', 26 | # HTML5 formaction 27 | 'formaction' 28 | ]) 29 | 30 | # Not in the HTML 4 spec: 31 | # onerror, onresize 32 | event_attrs = frozenset([ 33 | 'onblur', 'onchange', 'onclick', 'ondblclick', 'onerror', 34 | 'onfocus', 'onkeydown', 'onkeypress', 'onkeyup', 'onload', 35 | 'onmousedown', 'onmousemove', 'onmouseout', 'onmouseover', 36 | 'onmouseup', 'onreset', 'onresize', 'onselect', 'onsubmit', 37 | 'onunload', 38 | ]) 39 | 40 | safe_attrs = frozenset([ 41 | 'abbr', 'accept', 'accept-charset', 'accesskey', 'action', 'align', 42 | 'alt', 'axis', 'border', 'cellpadding', 'cellspacing', 'char', 'charoff', 43 | 'charset', 'checked', 'cite', 'class', 'clear', 'cols', 'colspan', 44 | 'color', 'compact', 'coords', 'datetime', 'dir', 'disabled', 'enctype', 45 | 'for', 'frame', 'headers', 'height', 'href', 'hreflang', 'hspace', 'id', 46 | 'ismap', 'label', 'lang', 'longdesc', 'maxlength', 'media', 'method', 47 | 'multiple', 'name', 'nohref', 'noshade', 'nowrap', 'prompt', 'readonly', 48 | 'rel', 'rev', 'rows', 'rowspan', 'rules', 'scope', 'selected', 'shape', 49 | 'size', 'span', 'src', 'start', 'summary', 'tabindex', 'target', 'title', 50 | 'type', 'usemap', 'valign', 'value', 'vspace', 'width']) 51 | 52 | # From http://htmlhelp.com/reference/html40/olist.html 53 | top_level_tags = frozenset([ 54 | 'html', 'head', 'body', 'frameset', 55 | ]) 56 | 57 | head_tags = frozenset([ 58 | 'base', 'isindex', 'link', 'meta', 'script', 'style', 'title', 59 | ]) 60 | 61 | general_block_tags = frozenset([ 62 | 'address', 63 | 'blockquote', 64 | 'center', 65 | 'del', 66 | 'div', 67 | 'h1', 68 | 'h2', 69 | 'h3', 70 | 'h4', 71 | 'h5', 72 | 'h6', 73 | 'hr', 74 | 'ins', 75 | 'isindex', 76 | 'noscript', 77 | 'p', 78 | 'pre', 79 | ]) 80 | 81 | list_tags = frozenset([ 82 | 'dir', 'dl', 'dt', 'dd', 'li', 'menu', 'ol', 'ul', 83 | ]) 84 | 85 | table_tags = frozenset([ 86 | 'table', 'caption', 'colgroup', 'col', 87 | 'thead', 'tfoot', 'tbody', 'tr', 'td', 'th', 88 | ]) 89 | 90 | # just this one from 91 | # http://www.georgehernandez.com/h/XComputers/HTML/2BlockLevel.htm 92 | block_tags = general_block_tags | list_tags | table_tags | frozenset([ 93 | # Partial form tags 94 | 'fieldset', 'form', 'legend', 'optgroup', 'option', 95 | ]) 96 | 97 | form_tags = frozenset([ 98 | 'form', 'button', 'fieldset', 'legend', 'input', 'label', 99 | 'select', 'optgroup', 'option', 'textarea', 100 | ]) 101 | 102 | special_inline_tags = frozenset([ 103 | 'a', 'applet', 'basefont', 'bdo', 'br', 'embed', 'font', 'iframe', 104 | 'img', 'map', 'area', 'object', 'param', 'q', 'script', 105 | 'span', 'sub', 'sup', 106 | ]) 107 | 108 | phrase_tags = frozenset([ 109 | 'abbr', 'acronym', 'cite', 'code', 'del', 'dfn', 'em', 110 | 'ins', 'kbd', 'samp', 'strong', 'var', 111 | ]) 112 | 113 | font_style_tags = frozenset([ 114 | 'b', 'big', 'i', 's', 'small', 'strike', 'tt', 'u', 115 | ]) 116 | 117 | frame_tags = frozenset([ 118 | 'frameset', 'frame', 'noframes', 119 | ]) 120 | 121 | html5_tags = frozenset([ 122 | 'article', 'aside', 'audio', 'canvas', 'command', 'datalist', 123 | 'details', 'embed', 'figcaption', 'figure', 'footer', 'header', 124 | 'hgroup', 'keygen', 'mark', 'math', 'meter', 'nav', 'output', 125 | 'progress', 'rp', 'rt', 'ruby', 'section', 'source', 'summary', 126 | 'svg', 'time', 'track', 'video', 'wbr' 127 | ]) 128 | 129 | # These tags aren't standard 130 | nonstandard_tags = frozenset(['blink', 'marquee']) 131 | 132 | 133 | tags = (top_level_tags | head_tags | general_block_tags | list_tags 134 | | table_tags | form_tags | special_inline_tags | phrase_tags 135 | | font_style_tags | nonstandard_tags | html5_tags) 136 | -------------------------------------------------------------------------------- /lxml/html/diff.cp310-win_amd64.pyd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/html/diff.cp310-win_amd64.pyd -------------------------------------------------------------------------------- /lxml/html/usedoctest.py: -------------------------------------------------------------------------------- 1 | """Doctest module for HTML comparison. 2 | 3 | Usage:: 4 | 5 | >>> import lxml.html.usedoctest 6 | >>> # now do your HTML doctests ... 7 | 8 | See `lxml.doctestcompare`. 9 | """ 10 | 11 | from lxml import doctestcompare 12 | 13 | doctestcompare.temp_install(html=True, del_module=__name__) 14 | -------------------------------------------------------------------------------- /lxml/includes/__init__.pxd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/__init__.pxd -------------------------------------------------------------------------------- /lxml/includes/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/__init__.py -------------------------------------------------------------------------------- /lxml/includes/__pycache__/__init__.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/__pycache__/__init__.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/includes/c14n.pxd: -------------------------------------------------------------------------------- 1 | from lxml.includes.tree cimport xmlDoc, xmlOutputBuffer, xmlChar 2 | from lxml.includes.xpath cimport xmlNodeSet 3 | 4 | cdef extern from "libxml/c14n.h": 5 | cdef int xmlC14NDocDumpMemory(xmlDoc* doc, 6 | xmlNodeSet* nodes, 7 | int exclusive, 8 | xmlChar** inclusive_ns_prefixes, 9 | int with_comments, 10 | xmlChar** doc_txt_ptr) nogil 11 | 12 | cdef int xmlC14NDocSave(xmlDoc* doc, 13 | xmlNodeSet* nodes, 14 | int exclusive, 15 | xmlChar** inclusive_ns_prefixes, 16 | int with_comments, 17 | char* filename, 18 | int compression) nogil 19 | 20 | cdef int xmlC14NDocSaveTo(xmlDoc* doc, 21 | xmlNodeSet* nodes, 22 | int exclusive, 23 | xmlChar** inclusive_ns_prefixes, 24 | int with_comments, 25 | xmlOutputBuffer* buffer) nogil 26 | 27 | -------------------------------------------------------------------------------- /lxml/includes/config.pxd: -------------------------------------------------------------------------------- 1 | cdef extern from "etree_defs.h": 2 | cdef bint ENABLE_THREADING 3 | cdef bint ENABLE_SCHEMATRON 4 | -------------------------------------------------------------------------------- /lxml/includes/dtdvalid.pxd: -------------------------------------------------------------------------------- 1 | from lxml.includes cimport tree 2 | from lxml.includes.tree cimport xmlDoc, xmlDtd 3 | 4 | cdef extern from "libxml/valid.h" nogil: 5 | ctypedef void (*xmlValidityErrorFunc)(void * ctx, const char * msg, ...) 6 | ctypedef void (*xmlValidityWarningFunc)(void * ctx, const char * msg, ...) 7 | 8 | ctypedef struct xmlValidCtxt: 9 | void *userData 10 | xmlValidityErrorFunc error 11 | xmlValidityWarningFunc warning 12 | 13 | cdef xmlValidCtxt* xmlNewValidCtxt() 14 | cdef void xmlFreeValidCtxt(xmlValidCtxt* cur) 15 | 16 | cdef int xmlValidateDtd(xmlValidCtxt* ctxt, xmlDoc* doc, xmlDtd* dtd) 17 | cdef tree.xmlElement* xmlGetDtdElementDesc( 18 | xmlDtd* dtd, tree.const_xmlChar* name) 19 | -------------------------------------------------------------------------------- /lxml/includes/extlibs/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/extlibs/__init__.py -------------------------------------------------------------------------------- /lxml/includes/extlibs/__pycache__/__init__.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/extlibs/__pycache__/__init__.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/includes/htmlparser.pxd: -------------------------------------------------------------------------------- 1 | from libc.string cimport const_char 2 | 3 | from lxml.includes.tree cimport xmlDoc 4 | from lxml.includes.tree cimport xmlInputReadCallback, xmlInputCloseCallback 5 | from lxml.includes.xmlparser cimport xmlParserCtxt, xmlSAXHandler, xmlSAXHandlerV1 6 | 7 | cdef extern from "libxml/HTMLparser.h": 8 | ctypedef enum htmlParserOption: 9 | HTML_PARSE_NOERROR # suppress error reports 10 | HTML_PARSE_NOWARNING # suppress warning reports 11 | HTML_PARSE_PEDANTIC # pedantic error reporting 12 | HTML_PARSE_NOBLANKS # remove blank nodes 13 | HTML_PARSE_NONET # Forbid network access 14 | # libxml2 2.6.21+ only: 15 | HTML_PARSE_RECOVER # Relaxed parsing 16 | HTML_PARSE_COMPACT # compact small text nodes 17 | # libxml2 2.7.7+ only: 18 | HTML_PARSE_NOIMPLIED # Do not add implied html/body... elements 19 | # libxml2 2.7.8+ only: 20 | HTML_PARSE_NODEFDTD # do not default a doctype if not found 21 | # libxml2 2.8.0+ only: 22 | XML_PARSE_IGNORE_ENC # ignore internal document encoding hint 23 | 24 | xmlSAXHandlerV1 htmlDefaultSAXHandler 25 | 26 | cdef xmlParserCtxt* htmlCreateMemoryParserCtxt( 27 | char* buffer, int size) nogil 28 | cdef xmlParserCtxt* htmlCreateFileParserCtxt( 29 | char* filename, char* encoding) nogil 30 | cdef xmlParserCtxt* htmlCreatePushParserCtxt(xmlSAXHandler* sax, 31 | void* user_data, 32 | char* chunk, int size, 33 | char* filename, int enc) nogil 34 | cdef void htmlFreeParserCtxt(xmlParserCtxt* ctxt) nogil 35 | cdef void htmlCtxtReset(xmlParserCtxt* ctxt) nogil 36 | cdef int htmlCtxtUseOptions(xmlParserCtxt* ctxt, int options) nogil 37 | cdef int htmlParseDocument(xmlParserCtxt* ctxt) nogil 38 | cdef int htmlParseChunk(xmlParserCtxt* ctxt, 39 | char* chunk, int size, int terminate) nogil 40 | 41 | cdef xmlDoc* htmlCtxtReadFile(xmlParserCtxt* ctxt, 42 | char* filename, const_char* encoding, 43 | int options) nogil 44 | cdef xmlDoc* htmlCtxtReadDoc(xmlParserCtxt* ctxt, 45 | char* buffer, char* URL, const_char* encoding, 46 | int options) nogil 47 | cdef xmlDoc* htmlCtxtReadIO(xmlParserCtxt* ctxt, 48 | xmlInputReadCallback ioread, 49 | xmlInputCloseCallback ioclose, 50 | void* ioctx, 51 | char* URL, const_char* encoding, 52 | int options) nogil 53 | cdef xmlDoc* htmlCtxtReadMemory(xmlParserCtxt* ctxt, 54 | char* buffer, int size, 55 | char* filename, const_char* encoding, 56 | int options) nogil 57 | -------------------------------------------------------------------------------- /lxml/includes/libexslt/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/libexslt/__init__.py -------------------------------------------------------------------------------- /lxml/includes/libexslt/__pycache__/__init__.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/libexslt/__pycache__/__init__.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/includes/libexslt/exslt.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef __EXSLT_H__ 3 | #define __EXSLT_H__ 4 | 5 | #include 6 | #include 7 | #include "exsltexports.h" 8 | #include 9 | 10 | #ifdef __cplusplus 11 | extern "C" { 12 | #endif 13 | 14 | EXSLTPUBVAR const char *exsltLibraryVersion; 15 | EXSLTPUBVAR const int exsltLibexsltVersion; 16 | EXSLTPUBVAR const int exsltLibxsltVersion; 17 | EXSLTPUBVAR const int exsltLibxmlVersion; 18 | 19 | /** 20 | * EXSLT_COMMON_NAMESPACE: 21 | * 22 | * Namespace for EXSLT common functions 23 | */ 24 | #define EXSLT_COMMON_NAMESPACE ((const xmlChar *) "http://exslt.org/common") 25 | /** 26 | * EXSLT_CRYPTO_NAMESPACE: 27 | * 28 | * Namespace for EXSLT crypto functions 29 | */ 30 | #define EXSLT_CRYPTO_NAMESPACE ((const xmlChar *) "http://exslt.org/crypto") 31 | /** 32 | * EXSLT_MATH_NAMESPACE: 33 | * 34 | * Namespace for EXSLT math functions 35 | */ 36 | #define EXSLT_MATH_NAMESPACE ((const xmlChar *) "http://exslt.org/math") 37 | /** 38 | * EXSLT_SETS_NAMESPACE: 39 | * 40 | * Namespace for EXSLT set functions 41 | */ 42 | #define EXSLT_SETS_NAMESPACE ((const xmlChar *) "http://exslt.org/sets") 43 | /** 44 | * EXSLT_FUNCTIONS_NAMESPACE: 45 | * 46 | * Namespace for EXSLT functions extension functions 47 | */ 48 | #define EXSLT_FUNCTIONS_NAMESPACE ((const xmlChar *) "http://exslt.org/functions") 49 | /** 50 | * EXSLT_STRINGS_NAMESPACE: 51 | * 52 | * Namespace for EXSLT strings functions 53 | */ 54 | #define EXSLT_STRINGS_NAMESPACE ((const xmlChar *) "http://exslt.org/strings") 55 | /** 56 | * EXSLT_DATE_NAMESPACE: 57 | * 58 | * Namespace for EXSLT date functions 59 | */ 60 | #define EXSLT_DATE_NAMESPACE ((const xmlChar *) "http://exslt.org/dates-and-times") 61 | /** 62 | * EXSLT_DYNAMIC_NAMESPACE: 63 | * 64 | * Namespace for EXSLT dynamic functions 65 | */ 66 | #define EXSLT_DYNAMIC_NAMESPACE ((const xmlChar *) "http://exslt.org/dynamic") 67 | 68 | /** 69 | * SAXON_NAMESPACE: 70 | * 71 | * Namespace for SAXON extensions functions 72 | */ 73 | #define SAXON_NAMESPACE ((const xmlChar *) "http://icl.com/saxon") 74 | 75 | EXSLTPUBFUN void EXSLTCALL exsltCommonRegister (void); 76 | #ifdef EXSLT_CRYPTO_ENABLED 77 | EXSLTPUBFUN void EXSLTCALL exsltCryptoRegister (void); 78 | #endif 79 | EXSLTPUBFUN void EXSLTCALL exsltMathRegister (void); 80 | EXSLTPUBFUN void EXSLTCALL exsltSetsRegister (void); 81 | EXSLTPUBFUN void EXSLTCALL exsltFuncRegister (void); 82 | EXSLTPUBFUN void EXSLTCALL exsltStrRegister (void); 83 | EXSLTPUBFUN void EXSLTCALL exsltDateRegister (void); 84 | EXSLTPUBFUN void EXSLTCALL exsltSaxonRegister (void); 85 | EXSLTPUBFUN void EXSLTCALL exsltDynRegister(void); 86 | 87 | EXSLTPUBFUN void EXSLTCALL exsltRegisterAll (void); 88 | 89 | EXSLTPUBFUN int EXSLTCALL exsltDateXpathCtxtRegister (xmlXPathContextPtr ctxt, 90 | const xmlChar *prefix); 91 | EXSLTPUBFUN int EXSLTCALL exsltMathXpathCtxtRegister (xmlXPathContextPtr ctxt, 92 | const xmlChar *prefix); 93 | EXSLTPUBFUN int EXSLTCALL exsltSetsXpathCtxtRegister (xmlXPathContextPtr ctxt, 94 | const xmlChar *prefix); 95 | EXSLTPUBFUN int EXSLTCALL exsltStrXpathCtxtRegister (xmlXPathContextPtr ctxt, 96 | const xmlChar *prefix); 97 | 98 | #ifdef __cplusplus 99 | } 100 | #endif 101 | #endif /* __EXSLT_H__ */ 102 | 103 | -------------------------------------------------------------------------------- /lxml/includes/libexslt/exsltconfig.h: -------------------------------------------------------------------------------- 1 | /* 2 | * exsltconfig.h: compile-time version information for the EXSLT library 3 | * 4 | * See Copyright for the status of this software. 5 | * 6 | * daniel@veillard.com 7 | */ 8 | 9 | #ifndef __XML_EXSLTCONFIG_H__ 10 | #define __XML_EXSLTCONFIG_H__ 11 | 12 | #ifdef __cplusplus 13 | extern "C" { 14 | #endif 15 | 16 | /** 17 | * LIBEXSLT_DOTTED_VERSION: 18 | * 19 | * the version string like "1.2.3" 20 | */ 21 | #define LIBEXSLT_DOTTED_VERSION "0.8.20" 22 | 23 | /** 24 | * LIBEXSLT_VERSION: 25 | * 26 | * the version number: 1.2.3 value is 10203 27 | */ 28 | #define LIBEXSLT_VERSION 820 29 | 30 | /** 31 | * LIBEXSLT_VERSION_STRING: 32 | * 33 | * the version number string, 1.2.3 value is "10203" 34 | */ 35 | #define LIBEXSLT_VERSION_STRING "820" 36 | 37 | /** 38 | * LIBEXSLT_VERSION_EXTRA: 39 | * 40 | * extra version information, used to show a CVS compilation 41 | */ 42 | #define LIBEXSLT_VERSION_EXTRA "" 43 | 44 | /** 45 | * WITH_CRYPTO: 46 | * 47 | * Whether crypto support is configured into exslt 48 | */ 49 | #if 1 50 | #define EXSLT_CRYPTO_ENABLED 51 | #endif 52 | 53 | /** 54 | * ATTRIBUTE_UNUSED: 55 | * 56 | * This macro is used to flag unused function parameters to GCC 57 | */ 58 | #ifdef __GNUC__ 59 | #ifndef ATTRIBUTE_UNUSED 60 | #define ATTRIBUTE_UNUSED __attribute__((unused)) 61 | #endif 62 | #else 63 | #define ATTRIBUTE_UNUSED 64 | #endif 65 | 66 | #ifdef __cplusplus 67 | } 68 | #endif 69 | 70 | #endif /* __XML_EXSLTCONFIG_H__ */ 71 | -------------------------------------------------------------------------------- /lxml/includes/libexslt/exsltexports.h: -------------------------------------------------------------------------------- 1 | /* 2 | * exsltexports.h : macros for marking symbols as exportable/importable. 3 | * 4 | * See Copyright for the status of this software. 5 | * 6 | * igor@zlatkovic.com 7 | */ 8 | 9 | #ifndef __EXSLT_EXPORTS_H__ 10 | #define __EXSLT_EXPORTS_H__ 11 | 12 | /** 13 | * EXSLTPUBFUN, EXSLTPUBVAR, EXSLTCALL 14 | * 15 | * Macros which declare an exportable function, an exportable variable and 16 | * the calling convention used for functions. 17 | * 18 | * Please use an extra block for every platform/compiler combination when 19 | * modifying this, rather than overlong #ifdef lines. This helps 20 | * readability as well as the fact that different compilers on the same 21 | * platform might need different definitions. 22 | */ 23 | 24 | /** 25 | * EXSLTPUBFUN: 26 | * 27 | * Macros which declare an exportable function 28 | */ 29 | #define EXSLTPUBFUN 30 | /** 31 | * EXSLTPUBVAR: 32 | * 33 | * Macros which declare an exportable variable 34 | */ 35 | #define EXSLTPUBVAR extern 36 | /** 37 | * EXSLTCALL: 38 | * 39 | * Macros which declare the called convention for exported functions 40 | */ 41 | #define EXSLTCALL 42 | 43 | /** DOC_DISABLE */ 44 | 45 | /* Windows platform with MS compiler */ 46 | #if defined(_WIN32) && defined(_MSC_VER) 47 | #undef EXSLTPUBFUN 48 | #undef EXSLTPUBVAR 49 | #undef EXSLTCALL 50 | #if defined(IN_LIBEXSLT) && !defined(LIBEXSLT_STATIC) 51 | #define EXSLTPUBFUN __declspec(dllexport) 52 | #define EXSLTPUBVAR __declspec(dllexport) 53 | #else 54 | #define EXSLTPUBFUN 55 | #if !defined(LIBEXSLT_STATIC) 56 | #define EXSLTPUBVAR __declspec(dllimport) extern 57 | #else 58 | #define EXSLTPUBVAR extern 59 | #endif 60 | #endif 61 | #define EXSLTCALL __cdecl 62 | #if !defined _REENTRANT 63 | #define _REENTRANT 64 | #endif 65 | #endif 66 | 67 | /* Windows platform with Borland compiler */ 68 | #if defined(_WIN32) && defined(__BORLANDC__) 69 | #undef EXSLTPUBFUN 70 | #undef EXSLTPUBVAR 71 | #undef EXSLTCALL 72 | #if defined(IN_LIBEXSLT) && !defined(LIBEXSLT_STATIC) 73 | #define EXSLTPUBFUN __declspec(dllexport) 74 | #define EXSLTPUBVAR __declspec(dllexport) extern 75 | #else 76 | #define EXSLTPUBFUN 77 | #if !defined(LIBEXSLT_STATIC) 78 | #define EXSLTPUBVAR __declspec(dllimport) extern 79 | #else 80 | #define EXSLTPUBVAR extern 81 | #endif 82 | #endif 83 | #define EXSLTCALL __cdecl 84 | #if !defined _REENTRANT 85 | #define _REENTRANT 86 | #endif 87 | #endif 88 | 89 | /* Windows platform with GNU compiler (Mingw) */ 90 | #if defined(_WIN32) && defined(__MINGW32__) 91 | #undef EXSLTPUBFUN 92 | #undef EXSLTPUBVAR 93 | #undef EXSLTCALL 94 | /* 95 | #if defined(IN_LIBEXSLT) && !defined(LIBEXSLT_STATIC) 96 | */ 97 | #if !defined(LIBEXSLT_STATIC) 98 | #define EXSLTPUBFUN __declspec(dllexport) 99 | #define EXSLTPUBVAR __declspec(dllexport) extern 100 | #else 101 | #define EXSLTPUBFUN 102 | #if !defined(LIBEXSLT_STATIC) 103 | #define EXSLTPUBVAR __declspec(dllimport) extern 104 | #else 105 | #define EXSLTPUBVAR extern 106 | #endif 107 | #endif 108 | #define EXSLTCALL __cdecl 109 | #if !defined _REENTRANT 110 | #define _REENTRANT 111 | #endif 112 | #endif 113 | 114 | /* Cygwin platform (does not define _WIN32), GNU compiler */ 115 | #if defined(__CYGWIN__) 116 | #undef EXSLTPUBFUN 117 | #undef EXSLTPUBVAR 118 | #undef EXSLTCALL 119 | #if defined(IN_LIBEXSLT) && !defined(LIBEXSLT_STATIC) 120 | #define EXSLTPUBFUN __declspec(dllexport) 121 | #define EXSLTPUBVAR __declspec(dllexport) 122 | #else 123 | #define EXSLTPUBFUN 124 | #if !defined(LIBEXSLT_STATIC) 125 | #define EXSLTPUBVAR __declspec(dllimport) extern 126 | #else 127 | #define EXSLTPUBVAR extern 128 | #endif 129 | #endif 130 | #define EXSLTCALL __cdecl 131 | #endif 132 | 133 | /* Compatibility */ 134 | #if !defined(LIBEXSLT_PUBLIC) 135 | #define LIBEXSLT_PUBLIC EXSLTPUBVAR 136 | #endif 137 | 138 | #endif /* __EXSLT_EXPORTS_H__ */ 139 | 140 | 141 | -------------------------------------------------------------------------------- /lxml/includes/libexslt/libexslt.h: -------------------------------------------------------------------------------- 1 | /* 2 | * libexslt.h: internal header only used during the compilation of libexslt 3 | * 4 | * See COPYRIGHT for the status of this software 5 | * 6 | * Author: daniel@veillard.com 7 | */ 8 | 9 | #ifndef __XSLT_LIBEXSLT_H__ 10 | #define __XSLT_LIBEXSLT_H__ 11 | 12 | #if defined(_WIN32) && !defined (__CYGWIN__) && !defined (__MINGW32__) 13 | #include 14 | #else 15 | #include "config.h" 16 | #endif 17 | 18 | #include 19 | #include 20 | 21 | #if !defined LIBEXSLT_PUBLIC 22 | #if (defined (__CYGWIN__) || defined _MSC_VER) && !defined IN_LIBEXSLT && !defined LIBEXSLT_STATIC 23 | #define LIBEXSLT_PUBLIC __declspec(dllimport) 24 | #else 25 | #define LIBEXSLT_PUBLIC 26 | #endif 27 | #endif 28 | 29 | #endif /* ! __XSLT_LIBEXSLT_H__ */ 30 | -------------------------------------------------------------------------------- /lxml/includes/libxml/DOCBparser.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: old DocBook SGML parser 3 | * Description: interface for a DocBook SGML non-verifying parser 4 | * This code is DEPRECATED, and should not be used anymore. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __DOCB_PARSER_H__ 12 | #define __DOCB_PARSER_H__ 13 | #include 14 | 15 | #ifdef LIBXML_DOCB_ENABLED 16 | 17 | #include 18 | #include 19 | 20 | #ifndef IN_LIBXML 21 | #ifdef __GNUC__ 22 | #warning "The DOCBparser module has been deprecated in libxml2-2.6.0" 23 | #endif 24 | #endif 25 | 26 | #ifdef __cplusplus 27 | extern "C" { 28 | #endif 29 | 30 | /* 31 | * Most of the back-end structures from XML and SGML are shared. 32 | */ 33 | typedef xmlParserCtxt docbParserCtxt; 34 | typedef xmlParserCtxtPtr docbParserCtxtPtr; 35 | typedef xmlSAXHandler docbSAXHandler; 36 | typedef xmlSAXHandlerPtr docbSAXHandlerPtr; 37 | typedef xmlParserInput docbParserInput; 38 | typedef xmlParserInputPtr docbParserInputPtr; 39 | typedef xmlDocPtr docbDocPtr; 40 | 41 | /* 42 | * There is only few public functions. 43 | */ 44 | XMLPUBFUN int XMLCALL 45 | docbEncodeEntities(unsigned char *out, 46 | int *outlen, 47 | const unsigned char *in, 48 | int *inlen, int quoteChar); 49 | 50 | XMLPUBFUN docbDocPtr XMLCALL 51 | docbSAXParseDoc (xmlChar *cur, 52 | const char *encoding, 53 | docbSAXHandlerPtr sax, 54 | void *userData); 55 | XMLPUBFUN docbDocPtr XMLCALL 56 | docbParseDoc (xmlChar *cur, 57 | const char *encoding); 58 | XMLPUBFUN docbDocPtr XMLCALL 59 | docbSAXParseFile (const char *filename, 60 | const char *encoding, 61 | docbSAXHandlerPtr sax, 62 | void *userData); 63 | XMLPUBFUN docbDocPtr XMLCALL 64 | docbParseFile (const char *filename, 65 | const char *encoding); 66 | 67 | /** 68 | * Interfaces for the Push mode. 69 | */ 70 | XMLPUBFUN void XMLCALL 71 | docbFreeParserCtxt (docbParserCtxtPtr ctxt); 72 | XMLPUBFUN docbParserCtxtPtr XMLCALL 73 | docbCreatePushParserCtxt(docbSAXHandlerPtr sax, 74 | void *user_data, 75 | const char *chunk, 76 | int size, 77 | const char *filename, 78 | xmlCharEncoding enc); 79 | XMLPUBFUN int XMLCALL 80 | docbParseChunk (docbParserCtxtPtr ctxt, 81 | const char *chunk, 82 | int size, 83 | int terminate); 84 | XMLPUBFUN docbParserCtxtPtr XMLCALL 85 | docbCreateFileParserCtxt(const char *filename, 86 | const char *encoding); 87 | XMLPUBFUN int XMLCALL 88 | docbParseDocument (docbParserCtxtPtr ctxt); 89 | 90 | #ifdef __cplusplus 91 | } 92 | #endif 93 | 94 | #endif /* LIBXML_DOCB_ENABLED */ 95 | 96 | #endif /* __DOCB_PARSER_H__ */ 97 | -------------------------------------------------------------------------------- /lxml/includes/libxml/HTMLtree.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: specific APIs to process HTML tree, especially serialization 3 | * Description: this module implements a few function needed to process 4 | * tree in an HTML specific way. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __HTML_TREE_H__ 12 | #define __HTML_TREE_H__ 13 | 14 | #include 15 | #include 16 | #include 17 | #include 18 | 19 | #ifdef LIBXML_HTML_ENABLED 20 | 21 | #ifdef __cplusplus 22 | extern "C" { 23 | #endif 24 | 25 | 26 | /** 27 | * HTML_TEXT_NODE: 28 | * 29 | * Macro. A text node in a HTML document is really implemented 30 | * the same way as a text node in an XML document. 31 | */ 32 | #define HTML_TEXT_NODE XML_TEXT_NODE 33 | /** 34 | * HTML_ENTITY_REF_NODE: 35 | * 36 | * Macro. An entity reference in a HTML document is really implemented 37 | * the same way as an entity reference in an XML document. 38 | */ 39 | #define HTML_ENTITY_REF_NODE XML_ENTITY_REF_NODE 40 | /** 41 | * HTML_COMMENT_NODE: 42 | * 43 | * Macro. A comment in a HTML document is really implemented 44 | * the same way as a comment in an XML document. 45 | */ 46 | #define HTML_COMMENT_NODE XML_COMMENT_NODE 47 | /** 48 | * HTML_PRESERVE_NODE: 49 | * 50 | * Macro. A preserved node in a HTML document is really implemented 51 | * the same way as a CDATA section in an XML document. 52 | */ 53 | #define HTML_PRESERVE_NODE XML_CDATA_SECTION_NODE 54 | /** 55 | * HTML_PI_NODE: 56 | * 57 | * Macro. A processing instruction in a HTML document is really implemented 58 | * the same way as a processing instruction in an XML document. 59 | */ 60 | #define HTML_PI_NODE XML_PI_NODE 61 | 62 | XMLPUBFUN htmlDocPtr XMLCALL 63 | htmlNewDoc (const xmlChar *URI, 64 | const xmlChar *ExternalID); 65 | XMLPUBFUN htmlDocPtr XMLCALL 66 | htmlNewDocNoDtD (const xmlChar *URI, 67 | const xmlChar *ExternalID); 68 | XMLPUBFUN const xmlChar * XMLCALL 69 | htmlGetMetaEncoding (htmlDocPtr doc); 70 | XMLPUBFUN int XMLCALL 71 | htmlSetMetaEncoding (htmlDocPtr doc, 72 | const xmlChar *encoding); 73 | #ifdef LIBXML_OUTPUT_ENABLED 74 | XMLPUBFUN void XMLCALL 75 | htmlDocDumpMemory (xmlDocPtr cur, 76 | xmlChar **mem, 77 | int *size); 78 | XMLPUBFUN void XMLCALL 79 | htmlDocDumpMemoryFormat (xmlDocPtr cur, 80 | xmlChar **mem, 81 | int *size, 82 | int format); 83 | XMLPUBFUN int XMLCALL 84 | htmlDocDump (FILE *f, 85 | xmlDocPtr cur); 86 | XMLPUBFUN int XMLCALL 87 | htmlSaveFile (const char *filename, 88 | xmlDocPtr cur); 89 | XMLPUBFUN int XMLCALL 90 | htmlNodeDump (xmlBufferPtr buf, 91 | xmlDocPtr doc, 92 | xmlNodePtr cur); 93 | XMLPUBFUN void XMLCALL 94 | htmlNodeDumpFile (FILE *out, 95 | xmlDocPtr doc, 96 | xmlNodePtr cur); 97 | XMLPUBFUN int XMLCALL 98 | htmlNodeDumpFileFormat (FILE *out, 99 | xmlDocPtr doc, 100 | xmlNodePtr cur, 101 | const char *encoding, 102 | int format); 103 | XMLPUBFUN int XMLCALL 104 | htmlSaveFileEnc (const char *filename, 105 | xmlDocPtr cur, 106 | const char *encoding); 107 | XMLPUBFUN int XMLCALL 108 | htmlSaveFileFormat (const char *filename, 109 | xmlDocPtr cur, 110 | const char *encoding, 111 | int format); 112 | 113 | XMLPUBFUN void XMLCALL 114 | htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, 115 | xmlDocPtr doc, 116 | xmlNodePtr cur, 117 | const char *encoding, 118 | int format); 119 | XMLPUBFUN void XMLCALL 120 | htmlDocContentDumpOutput(xmlOutputBufferPtr buf, 121 | xmlDocPtr cur, 122 | const char *encoding); 123 | XMLPUBFUN void XMLCALL 124 | htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf, 125 | xmlDocPtr cur, 126 | const char *encoding, 127 | int format); 128 | XMLPUBFUN void XMLCALL 129 | htmlNodeDumpOutput (xmlOutputBufferPtr buf, 130 | xmlDocPtr doc, 131 | xmlNodePtr cur, 132 | const char *encoding); 133 | 134 | #endif /* LIBXML_OUTPUT_ENABLED */ 135 | 136 | XMLPUBFUN int XMLCALL 137 | htmlIsBooleanAttr (const xmlChar *name); 138 | 139 | 140 | #ifdef __cplusplus 141 | } 142 | #endif 143 | 144 | #endif /* LIBXML_HTML_ENABLED */ 145 | 146 | #endif /* __HTML_TREE_H__ */ 147 | 148 | -------------------------------------------------------------------------------- /lxml/includes/libxml/SAX.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: Old SAX version 1 handler, deprecated 3 | * Description: DEPRECATED set of SAX version 1 interfaces used to 4 | * build the DOM tree. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | 12 | #ifndef __XML_SAX_H__ 13 | #define __XML_SAX_H__ 14 | 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | #ifdef LIBXML_LEGACY_ENABLED 22 | 23 | #ifdef __cplusplus 24 | extern "C" { 25 | #endif 26 | XMLPUBFUN const xmlChar * XMLCALL 27 | getPublicId (void *ctx); 28 | XMLPUBFUN const xmlChar * XMLCALL 29 | getSystemId (void *ctx); 30 | XMLPUBFUN void XMLCALL 31 | setDocumentLocator (void *ctx, 32 | xmlSAXLocatorPtr loc); 33 | 34 | XMLPUBFUN int XMLCALL 35 | getLineNumber (void *ctx); 36 | XMLPUBFUN int XMLCALL 37 | getColumnNumber (void *ctx); 38 | 39 | XMLPUBFUN int XMLCALL 40 | isStandalone (void *ctx); 41 | XMLPUBFUN int XMLCALL 42 | hasInternalSubset (void *ctx); 43 | XMLPUBFUN int XMLCALL 44 | hasExternalSubset (void *ctx); 45 | 46 | XMLPUBFUN void XMLCALL 47 | internalSubset (void *ctx, 48 | const xmlChar *name, 49 | const xmlChar *ExternalID, 50 | const xmlChar *SystemID); 51 | XMLPUBFUN void XMLCALL 52 | externalSubset (void *ctx, 53 | const xmlChar *name, 54 | const xmlChar *ExternalID, 55 | const xmlChar *SystemID); 56 | XMLPUBFUN xmlEntityPtr XMLCALL 57 | getEntity (void *ctx, 58 | const xmlChar *name); 59 | XMLPUBFUN xmlEntityPtr XMLCALL 60 | getParameterEntity (void *ctx, 61 | const xmlChar *name); 62 | XMLPUBFUN xmlParserInputPtr XMLCALL 63 | resolveEntity (void *ctx, 64 | const xmlChar *publicId, 65 | const xmlChar *systemId); 66 | 67 | XMLPUBFUN void XMLCALL 68 | entityDecl (void *ctx, 69 | const xmlChar *name, 70 | int type, 71 | const xmlChar *publicId, 72 | const xmlChar *systemId, 73 | xmlChar *content); 74 | XMLPUBFUN void XMLCALL 75 | attributeDecl (void *ctx, 76 | const xmlChar *elem, 77 | const xmlChar *fullname, 78 | int type, 79 | int def, 80 | const xmlChar *defaultValue, 81 | xmlEnumerationPtr tree); 82 | XMLPUBFUN void XMLCALL 83 | elementDecl (void *ctx, 84 | const xmlChar *name, 85 | int type, 86 | xmlElementContentPtr content); 87 | XMLPUBFUN void XMLCALL 88 | notationDecl (void *ctx, 89 | const xmlChar *name, 90 | const xmlChar *publicId, 91 | const xmlChar *systemId); 92 | XMLPUBFUN void XMLCALL 93 | unparsedEntityDecl (void *ctx, 94 | const xmlChar *name, 95 | const xmlChar *publicId, 96 | const xmlChar *systemId, 97 | const xmlChar *notationName); 98 | 99 | XMLPUBFUN void XMLCALL 100 | startDocument (void *ctx); 101 | XMLPUBFUN void XMLCALL 102 | endDocument (void *ctx); 103 | XMLPUBFUN void XMLCALL 104 | attribute (void *ctx, 105 | const xmlChar *fullname, 106 | const xmlChar *value); 107 | XMLPUBFUN void XMLCALL 108 | startElement (void *ctx, 109 | const xmlChar *fullname, 110 | const xmlChar **atts); 111 | XMLPUBFUN void XMLCALL 112 | endElement (void *ctx, 113 | const xmlChar *name); 114 | XMLPUBFUN void XMLCALL 115 | reference (void *ctx, 116 | const xmlChar *name); 117 | XMLPUBFUN void XMLCALL 118 | characters (void *ctx, 119 | const xmlChar *ch, 120 | int len); 121 | XMLPUBFUN void XMLCALL 122 | ignorableWhitespace (void *ctx, 123 | const xmlChar *ch, 124 | int len); 125 | XMLPUBFUN void XMLCALL 126 | processingInstruction (void *ctx, 127 | const xmlChar *target, 128 | const xmlChar *data); 129 | XMLPUBFUN void XMLCALL 130 | globalNamespace (void *ctx, 131 | const xmlChar *href, 132 | const xmlChar *prefix); 133 | XMLPUBFUN void XMLCALL 134 | setNamespace (void *ctx, 135 | const xmlChar *name); 136 | XMLPUBFUN xmlNsPtr XMLCALL 137 | getNamespace (void *ctx); 138 | XMLPUBFUN int XMLCALL 139 | checkNamespace (void *ctx, 140 | xmlChar *nameSpace); 141 | XMLPUBFUN void XMLCALL 142 | namespaceDecl (void *ctx, 143 | const xmlChar *href, 144 | const xmlChar *prefix); 145 | XMLPUBFUN void XMLCALL 146 | comment (void *ctx, 147 | const xmlChar *value); 148 | XMLPUBFUN void XMLCALL 149 | cdataBlock (void *ctx, 150 | const xmlChar *value, 151 | int len); 152 | 153 | #ifdef LIBXML_SAX1_ENABLED 154 | XMLPUBFUN void XMLCALL 155 | initxmlDefaultSAXHandler (xmlSAXHandlerV1 *hdlr, 156 | int warning); 157 | #ifdef LIBXML_HTML_ENABLED 158 | XMLPUBFUN void XMLCALL 159 | inithtmlDefaultSAXHandler (xmlSAXHandlerV1 *hdlr); 160 | #endif 161 | #ifdef LIBXML_DOCB_ENABLED 162 | XMLPUBFUN void XMLCALL 163 | initdocbDefaultSAXHandler (xmlSAXHandlerV1 *hdlr); 164 | #endif 165 | #endif /* LIBXML_SAX1_ENABLED */ 166 | 167 | #ifdef __cplusplus 168 | } 169 | #endif 170 | 171 | #endif /* LIBXML_LEGACY_ENABLED */ 172 | 173 | #endif /* __XML_SAX_H__ */ 174 | -------------------------------------------------------------------------------- /lxml/includes/libxml/SAX2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: SAX2 parser interface used to build the DOM tree 3 | * Description: those are the default SAX2 interfaces used by 4 | * the library when building DOM tree. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | 12 | #ifndef __XML_SAX2_H__ 13 | #define __XML_SAX2_H__ 14 | 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | #ifdef __cplusplus 22 | extern "C" { 23 | #endif 24 | XMLPUBFUN const xmlChar * XMLCALL 25 | xmlSAX2GetPublicId (void *ctx); 26 | XMLPUBFUN const xmlChar * XMLCALL 27 | xmlSAX2GetSystemId (void *ctx); 28 | XMLPUBFUN void XMLCALL 29 | xmlSAX2SetDocumentLocator (void *ctx, 30 | xmlSAXLocatorPtr loc); 31 | 32 | XMLPUBFUN int XMLCALL 33 | xmlSAX2GetLineNumber (void *ctx); 34 | XMLPUBFUN int XMLCALL 35 | xmlSAX2GetColumnNumber (void *ctx); 36 | 37 | XMLPUBFUN int XMLCALL 38 | xmlSAX2IsStandalone (void *ctx); 39 | XMLPUBFUN int XMLCALL 40 | xmlSAX2HasInternalSubset (void *ctx); 41 | XMLPUBFUN int XMLCALL 42 | xmlSAX2HasExternalSubset (void *ctx); 43 | 44 | XMLPUBFUN void XMLCALL 45 | xmlSAX2InternalSubset (void *ctx, 46 | const xmlChar *name, 47 | const xmlChar *ExternalID, 48 | const xmlChar *SystemID); 49 | XMLPUBFUN void XMLCALL 50 | xmlSAX2ExternalSubset (void *ctx, 51 | const xmlChar *name, 52 | const xmlChar *ExternalID, 53 | const xmlChar *SystemID); 54 | XMLPUBFUN xmlEntityPtr XMLCALL 55 | xmlSAX2GetEntity (void *ctx, 56 | const xmlChar *name); 57 | XMLPUBFUN xmlEntityPtr XMLCALL 58 | xmlSAX2GetParameterEntity (void *ctx, 59 | const xmlChar *name); 60 | XMLPUBFUN xmlParserInputPtr XMLCALL 61 | xmlSAX2ResolveEntity (void *ctx, 62 | const xmlChar *publicId, 63 | const xmlChar *systemId); 64 | 65 | XMLPUBFUN void XMLCALL 66 | xmlSAX2EntityDecl (void *ctx, 67 | const xmlChar *name, 68 | int type, 69 | const xmlChar *publicId, 70 | const xmlChar *systemId, 71 | xmlChar *content); 72 | XMLPUBFUN void XMLCALL 73 | xmlSAX2AttributeDecl (void *ctx, 74 | const xmlChar *elem, 75 | const xmlChar *fullname, 76 | int type, 77 | int def, 78 | const xmlChar *defaultValue, 79 | xmlEnumerationPtr tree); 80 | XMLPUBFUN void XMLCALL 81 | xmlSAX2ElementDecl (void *ctx, 82 | const xmlChar *name, 83 | int type, 84 | xmlElementContentPtr content); 85 | XMLPUBFUN void XMLCALL 86 | xmlSAX2NotationDecl (void *ctx, 87 | const xmlChar *name, 88 | const xmlChar *publicId, 89 | const xmlChar *systemId); 90 | XMLPUBFUN void XMLCALL 91 | xmlSAX2UnparsedEntityDecl (void *ctx, 92 | const xmlChar *name, 93 | const xmlChar *publicId, 94 | const xmlChar *systemId, 95 | const xmlChar *notationName); 96 | 97 | XMLPUBFUN void XMLCALL 98 | xmlSAX2StartDocument (void *ctx); 99 | XMLPUBFUN void XMLCALL 100 | xmlSAX2EndDocument (void *ctx); 101 | #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ 102 | defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || \ 103 | defined(LIBXML_LEGACY_ENABLED) 104 | XMLPUBFUN void XMLCALL 105 | xmlSAX2StartElement (void *ctx, 106 | const xmlChar *fullname, 107 | const xmlChar **atts); 108 | XMLPUBFUN void XMLCALL 109 | xmlSAX2EndElement (void *ctx, 110 | const xmlChar *name); 111 | #endif /* LIBXML_SAX1_ENABLED or LIBXML_HTML_ENABLED or LIBXML_LEGACY_ENABLED */ 112 | XMLPUBFUN void XMLCALL 113 | xmlSAX2StartElementNs (void *ctx, 114 | const xmlChar *localname, 115 | const xmlChar *prefix, 116 | const xmlChar *URI, 117 | int nb_namespaces, 118 | const xmlChar **namespaces, 119 | int nb_attributes, 120 | int nb_defaulted, 121 | const xmlChar **attributes); 122 | XMLPUBFUN void XMLCALL 123 | xmlSAX2EndElementNs (void *ctx, 124 | const xmlChar *localname, 125 | const xmlChar *prefix, 126 | const xmlChar *URI); 127 | XMLPUBFUN void XMLCALL 128 | xmlSAX2Reference (void *ctx, 129 | const xmlChar *name); 130 | XMLPUBFUN void XMLCALL 131 | xmlSAX2Characters (void *ctx, 132 | const xmlChar *ch, 133 | int len); 134 | XMLPUBFUN void XMLCALL 135 | xmlSAX2IgnorableWhitespace (void *ctx, 136 | const xmlChar *ch, 137 | int len); 138 | XMLPUBFUN void XMLCALL 139 | xmlSAX2ProcessingInstruction (void *ctx, 140 | const xmlChar *target, 141 | const xmlChar *data); 142 | XMLPUBFUN void XMLCALL 143 | xmlSAX2Comment (void *ctx, 144 | const xmlChar *value); 145 | XMLPUBFUN void XMLCALL 146 | xmlSAX2CDataBlock (void *ctx, 147 | const xmlChar *value, 148 | int len); 149 | 150 | #ifdef LIBXML_SAX1_ENABLED 151 | XMLPUBFUN int XMLCALL 152 | xmlSAXDefaultVersion (int version); 153 | #endif /* LIBXML_SAX1_ENABLED */ 154 | 155 | XMLPUBFUN int XMLCALL 156 | xmlSAXVersion (xmlSAXHandler *hdlr, 157 | int version); 158 | XMLPUBFUN void XMLCALL 159 | xmlSAX2InitDefaultSAXHandler (xmlSAXHandler *hdlr, 160 | int warning); 161 | #ifdef LIBXML_HTML_ENABLED 162 | XMLPUBFUN void XMLCALL 163 | xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr); 164 | XMLPUBFUN void XMLCALL 165 | htmlDefaultSAXHandlerInit (void); 166 | #endif 167 | #ifdef LIBXML_DOCB_ENABLED 168 | XMLPUBFUN void XMLCALL 169 | xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr); 170 | XMLPUBFUN void XMLCALL 171 | docbDefaultSAXHandlerInit (void); 172 | #endif 173 | XMLPUBFUN void XMLCALL 174 | xmlDefaultSAXHandlerInit (void); 175 | #ifdef __cplusplus 176 | } 177 | #endif 178 | #endif /* __XML_SAX2_H__ */ 179 | -------------------------------------------------------------------------------- /lxml/includes/libxml/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/libxml/__init__.py -------------------------------------------------------------------------------- /lxml/includes/libxml/__pycache__/__init__.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/libxml/__pycache__/__init__.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/includes/libxml/c14n.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: Provide Canonical XML and Exclusive XML Canonicalization 3 | * Description: the c14n modules provides a 4 | * 5 | * "Canonical XML" implementation 6 | * http://www.w3.org/TR/xml-c14n 7 | * 8 | * and an 9 | * 10 | * "Exclusive XML Canonicalization" implementation 11 | * http://www.w3.org/TR/xml-exc-c14n 12 | 13 | * Copy: See Copyright for the status of this software. 14 | * 15 | * Author: Aleksey Sanin 16 | */ 17 | #ifndef __XML_C14N_H__ 18 | #define __XML_C14N_H__ 19 | 20 | #include 21 | 22 | #ifdef LIBXML_C14N_ENABLED 23 | #ifdef LIBXML_OUTPUT_ENABLED 24 | 25 | #include 26 | #include 27 | 28 | #ifdef __cplusplus 29 | extern "C" { 30 | #endif /* __cplusplus */ 31 | 32 | /* 33 | * XML Canonicalization 34 | * http://www.w3.org/TR/xml-c14n 35 | * 36 | * Exclusive XML Canonicalization 37 | * http://www.w3.org/TR/xml-exc-c14n 38 | * 39 | * Canonical form of an XML document could be created if and only if 40 | * a) default attributes (if any) are added to all nodes 41 | * b) all character and parsed entity references are resolved 42 | * In order to achieve this in libxml2 the document MUST be loaded with 43 | * following global settings: 44 | * 45 | * xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS; 46 | * xmlSubstituteEntitiesDefault(1); 47 | * 48 | * or corresponding parser context setting: 49 | * xmlParserCtxtPtr ctxt; 50 | * 51 | * ... 52 | * ctxt->loadsubset = XML_DETECT_IDS | XML_COMPLETE_ATTRS; 53 | * ctxt->replaceEntities = 1; 54 | * ... 55 | */ 56 | 57 | /* 58 | * xmlC14NMode: 59 | * 60 | * Predefined values for C14N modes 61 | * 62 | */ 63 | typedef enum { 64 | XML_C14N_1_0 = 0, /* Original C14N 1.0 spec */ 65 | XML_C14N_EXCLUSIVE_1_0 = 1, /* Exclusive C14N 1.0 spec */ 66 | XML_C14N_1_1 = 2 /* C14N 1.1 spec */ 67 | } xmlC14NMode; 68 | 69 | XMLPUBFUN int XMLCALL 70 | xmlC14NDocSaveTo (xmlDocPtr doc, 71 | xmlNodeSetPtr nodes, 72 | int mode, /* a xmlC14NMode */ 73 | xmlChar **inclusive_ns_prefixes, 74 | int with_comments, 75 | xmlOutputBufferPtr buf); 76 | 77 | XMLPUBFUN int XMLCALL 78 | xmlC14NDocDumpMemory (xmlDocPtr doc, 79 | xmlNodeSetPtr nodes, 80 | int mode, /* a xmlC14NMode */ 81 | xmlChar **inclusive_ns_prefixes, 82 | int with_comments, 83 | xmlChar **doc_txt_ptr); 84 | 85 | XMLPUBFUN int XMLCALL 86 | xmlC14NDocSave (xmlDocPtr doc, 87 | xmlNodeSetPtr nodes, 88 | int mode, /* a xmlC14NMode */ 89 | xmlChar **inclusive_ns_prefixes, 90 | int with_comments, 91 | const char* filename, 92 | int compression); 93 | 94 | 95 | /** 96 | * This is the core C14N function 97 | */ 98 | /** 99 | * xmlC14NIsVisibleCallback: 100 | * @user_data: user data 101 | * @node: the current node 102 | * @parent: the parent node 103 | * 104 | * Signature for a C14N callback on visible nodes 105 | * 106 | * Returns 1 if the node should be included 107 | */ 108 | typedef int (*xmlC14NIsVisibleCallback) (void* user_data, 109 | xmlNodePtr node, 110 | xmlNodePtr parent); 111 | 112 | XMLPUBFUN int XMLCALL 113 | xmlC14NExecute (xmlDocPtr doc, 114 | xmlC14NIsVisibleCallback is_visible_callback, 115 | void* user_data, 116 | int mode, /* a xmlC14NMode */ 117 | xmlChar **inclusive_ns_prefixes, 118 | int with_comments, 119 | xmlOutputBufferPtr buf); 120 | 121 | #ifdef __cplusplus 122 | } 123 | #endif /* __cplusplus */ 124 | 125 | #endif /* LIBXML_OUTPUT_ENABLED */ 126 | #endif /* LIBXML_C14N_ENABLED */ 127 | #endif /* __XML_C14N_H__ */ 128 | 129 | -------------------------------------------------------------------------------- /lxml/includes/libxml/catalog.h: -------------------------------------------------------------------------------- 1 | /** 2 | * Summary: interfaces to the Catalog handling system 3 | * Description: the catalog module implements the support for 4 | * XML Catalogs and SGML catalogs 5 | * 6 | * SGML Open Technical Resolution TR9401:1997. 7 | * http://www.jclark.com/sp/catalog.htm 8 | * 9 | * XML Catalogs Working Draft 06 August 2001 10 | * http://www.oasis-open.org/committees/entity/spec-2001-08-06.html 11 | * 12 | * Copy: See Copyright for the status of this software. 13 | * 14 | * Author: Daniel Veillard 15 | */ 16 | 17 | #ifndef __XML_CATALOG_H__ 18 | #define __XML_CATALOG_H__ 19 | 20 | #include 21 | 22 | #include 23 | #include 24 | #include 25 | 26 | #ifdef LIBXML_CATALOG_ENABLED 27 | 28 | #ifdef __cplusplus 29 | extern "C" { 30 | #endif 31 | 32 | /** 33 | * XML_CATALOGS_NAMESPACE: 34 | * 35 | * The namespace for the XML Catalogs elements. 36 | */ 37 | #define XML_CATALOGS_NAMESPACE \ 38 | (const xmlChar *) "urn:oasis:names:tc:entity:xmlns:xml:catalog" 39 | /** 40 | * XML_CATALOG_PI: 41 | * 42 | * The specific XML Catalog Processing Instruction name. 43 | */ 44 | #define XML_CATALOG_PI \ 45 | (const xmlChar *) "oasis-xml-catalog" 46 | 47 | /* 48 | * The API is voluntarily limited to general cataloging. 49 | */ 50 | typedef enum { 51 | XML_CATA_PREFER_NONE = 0, 52 | XML_CATA_PREFER_PUBLIC = 1, 53 | XML_CATA_PREFER_SYSTEM 54 | } xmlCatalogPrefer; 55 | 56 | typedef enum { 57 | XML_CATA_ALLOW_NONE = 0, 58 | XML_CATA_ALLOW_GLOBAL = 1, 59 | XML_CATA_ALLOW_DOCUMENT = 2, 60 | XML_CATA_ALLOW_ALL = 3 61 | } xmlCatalogAllow; 62 | 63 | typedef struct _xmlCatalog xmlCatalog; 64 | typedef xmlCatalog *xmlCatalogPtr; 65 | 66 | /* 67 | * Operations on a given catalog. 68 | */ 69 | XMLPUBFUN xmlCatalogPtr XMLCALL 70 | xmlNewCatalog (int sgml); 71 | XMLPUBFUN xmlCatalogPtr XMLCALL 72 | xmlLoadACatalog (const char *filename); 73 | XMLPUBFUN xmlCatalogPtr XMLCALL 74 | xmlLoadSGMLSuperCatalog (const char *filename); 75 | XMLPUBFUN int XMLCALL 76 | xmlConvertSGMLCatalog (xmlCatalogPtr catal); 77 | XMLPUBFUN int XMLCALL 78 | xmlACatalogAdd (xmlCatalogPtr catal, 79 | const xmlChar *type, 80 | const xmlChar *orig, 81 | const xmlChar *replace); 82 | XMLPUBFUN int XMLCALL 83 | xmlACatalogRemove (xmlCatalogPtr catal, 84 | const xmlChar *value); 85 | XMLPUBFUN xmlChar * XMLCALL 86 | xmlACatalogResolve (xmlCatalogPtr catal, 87 | const xmlChar *pubID, 88 | const xmlChar *sysID); 89 | XMLPUBFUN xmlChar * XMLCALL 90 | xmlACatalogResolveSystem(xmlCatalogPtr catal, 91 | const xmlChar *sysID); 92 | XMLPUBFUN xmlChar * XMLCALL 93 | xmlACatalogResolvePublic(xmlCatalogPtr catal, 94 | const xmlChar *pubID); 95 | XMLPUBFUN xmlChar * XMLCALL 96 | xmlACatalogResolveURI (xmlCatalogPtr catal, 97 | const xmlChar *URI); 98 | #ifdef LIBXML_OUTPUT_ENABLED 99 | XMLPUBFUN void XMLCALL 100 | xmlACatalogDump (xmlCatalogPtr catal, 101 | FILE *out); 102 | #endif /* LIBXML_OUTPUT_ENABLED */ 103 | XMLPUBFUN void XMLCALL 104 | xmlFreeCatalog (xmlCatalogPtr catal); 105 | XMLPUBFUN int XMLCALL 106 | xmlCatalogIsEmpty (xmlCatalogPtr catal); 107 | 108 | /* 109 | * Global operations. 110 | */ 111 | XMLPUBFUN void XMLCALL 112 | xmlInitializeCatalog (void); 113 | XMLPUBFUN int XMLCALL 114 | xmlLoadCatalog (const char *filename); 115 | XMLPUBFUN void XMLCALL 116 | xmlLoadCatalogs (const char *paths); 117 | XMLPUBFUN void XMLCALL 118 | xmlCatalogCleanup (void); 119 | #ifdef LIBXML_OUTPUT_ENABLED 120 | XMLPUBFUN void XMLCALL 121 | xmlCatalogDump (FILE *out); 122 | #endif /* LIBXML_OUTPUT_ENABLED */ 123 | XMLPUBFUN xmlChar * XMLCALL 124 | xmlCatalogResolve (const xmlChar *pubID, 125 | const xmlChar *sysID); 126 | XMLPUBFUN xmlChar * XMLCALL 127 | xmlCatalogResolveSystem (const xmlChar *sysID); 128 | XMLPUBFUN xmlChar * XMLCALL 129 | xmlCatalogResolvePublic (const xmlChar *pubID); 130 | XMLPUBFUN xmlChar * XMLCALL 131 | xmlCatalogResolveURI (const xmlChar *URI); 132 | XMLPUBFUN int XMLCALL 133 | xmlCatalogAdd (const xmlChar *type, 134 | const xmlChar *orig, 135 | const xmlChar *replace); 136 | XMLPUBFUN int XMLCALL 137 | xmlCatalogRemove (const xmlChar *value); 138 | XMLPUBFUN xmlDocPtr XMLCALL 139 | xmlParseCatalogFile (const char *filename); 140 | XMLPUBFUN int XMLCALL 141 | xmlCatalogConvert (void); 142 | 143 | /* 144 | * Strictly minimal interfaces for per-document catalogs used 145 | * by the parser. 146 | */ 147 | XMLPUBFUN void XMLCALL 148 | xmlCatalogFreeLocal (void *catalogs); 149 | XMLPUBFUN void * XMLCALL 150 | xmlCatalogAddLocal (void *catalogs, 151 | const xmlChar *URL); 152 | XMLPUBFUN xmlChar * XMLCALL 153 | xmlCatalogLocalResolve (void *catalogs, 154 | const xmlChar *pubID, 155 | const xmlChar *sysID); 156 | XMLPUBFUN xmlChar * XMLCALL 157 | xmlCatalogLocalResolveURI(void *catalogs, 158 | const xmlChar *URI); 159 | /* 160 | * Preference settings. 161 | */ 162 | XMLPUBFUN int XMLCALL 163 | xmlCatalogSetDebug (int level); 164 | XMLPUBFUN xmlCatalogPrefer XMLCALL 165 | xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer); 166 | XMLPUBFUN void XMLCALL 167 | xmlCatalogSetDefaults (xmlCatalogAllow allow); 168 | XMLPUBFUN xmlCatalogAllow XMLCALL 169 | xmlCatalogGetDefaults (void); 170 | 171 | 172 | /* DEPRECATED interfaces */ 173 | XMLPUBFUN const xmlChar * XMLCALL 174 | xmlCatalogGetSystem (const xmlChar *sysID); 175 | XMLPUBFUN const xmlChar * XMLCALL 176 | xmlCatalogGetPublic (const xmlChar *pubID); 177 | 178 | #ifdef __cplusplus 179 | } 180 | #endif 181 | #endif /* LIBXML_CATALOG_ENABLED */ 182 | #endif /* __XML_CATALOG_H__ */ 183 | -------------------------------------------------------------------------------- /lxml/includes/libxml/dict.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: string dictionary 3 | * Description: dictionary of reusable strings, just used to avoid allocation 4 | * and freeing operations. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_DICT_H__ 12 | #define __XML_DICT_H__ 13 | 14 | #include 15 | #include 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | /* 22 | * The dictionary. 23 | */ 24 | typedef struct _xmlDict xmlDict; 25 | typedef xmlDict *xmlDictPtr; 26 | 27 | /* 28 | * Initializer 29 | */ 30 | XMLPUBFUN int XMLCALL xmlInitializeDict(void); 31 | 32 | /* 33 | * Constructor and destructor. 34 | */ 35 | XMLPUBFUN xmlDictPtr XMLCALL 36 | xmlDictCreate (void); 37 | XMLPUBFUN size_t XMLCALL 38 | xmlDictSetLimit (xmlDictPtr dict, 39 | size_t limit); 40 | XMLPUBFUN size_t XMLCALL 41 | xmlDictGetUsage (xmlDictPtr dict); 42 | XMLPUBFUN xmlDictPtr XMLCALL 43 | xmlDictCreateSub(xmlDictPtr sub); 44 | XMLPUBFUN int XMLCALL 45 | xmlDictReference(xmlDictPtr dict); 46 | XMLPUBFUN void XMLCALL 47 | xmlDictFree (xmlDictPtr dict); 48 | 49 | /* 50 | * Lookup of entry in the dictionary. 51 | */ 52 | XMLPUBFUN const xmlChar * XMLCALL 53 | xmlDictLookup (xmlDictPtr dict, 54 | const xmlChar *name, 55 | int len); 56 | XMLPUBFUN const xmlChar * XMLCALL 57 | xmlDictExists (xmlDictPtr dict, 58 | const xmlChar *name, 59 | int len); 60 | XMLPUBFUN const xmlChar * XMLCALL 61 | xmlDictQLookup (xmlDictPtr dict, 62 | const xmlChar *prefix, 63 | const xmlChar *name); 64 | XMLPUBFUN int XMLCALL 65 | xmlDictOwns (xmlDictPtr dict, 66 | const xmlChar *str); 67 | XMLPUBFUN int XMLCALL 68 | xmlDictSize (xmlDictPtr dict); 69 | 70 | /* 71 | * Cleanup function 72 | */ 73 | XMLPUBFUN void XMLCALL 74 | xmlDictCleanup (void); 75 | 76 | #ifdef __cplusplus 77 | } 78 | #endif 79 | #endif /* ! __XML_DICT_H__ */ 80 | -------------------------------------------------------------------------------- /lxml/includes/libxml/entities.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the XML entities handling 3 | * Description: this module provides some of the entity API needed 4 | * for the parser and applications. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_ENTITIES_H__ 12 | #define __XML_ENTITIES_H__ 13 | 14 | #include 15 | #include 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | /* 22 | * The different valid entity types. 23 | */ 24 | typedef enum { 25 | XML_INTERNAL_GENERAL_ENTITY = 1, 26 | XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2, 27 | XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3, 28 | XML_INTERNAL_PARAMETER_ENTITY = 4, 29 | XML_EXTERNAL_PARAMETER_ENTITY = 5, 30 | XML_INTERNAL_PREDEFINED_ENTITY = 6 31 | } xmlEntityType; 32 | 33 | /* 34 | * An unit of storage for an entity, contains the string, the value 35 | * and the linkind data needed for the linking in the hash table. 36 | */ 37 | 38 | struct _xmlEntity { 39 | void *_private; /* application data */ 40 | xmlElementType type; /* XML_ENTITY_DECL, must be second ! */ 41 | const xmlChar *name; /* Entity name */ 42 | struct _xmlNode *children; /* First child link */ 43 | struct _xmlNode *last; /* Last child link */ 44 | struct _xmlDtd *parent; /* -> DTD */ 45 | struct _xmlNode *next; /* next sibling link */ 46 | struct _xmlNode *prev; /* previous sibling link */ 47 | struct _xmlDoc *doc; /* the containing document */ 48 | 49 | xmlChar *orig; /* content without ref substitution */ 50 | xmlChar *content; /* content or ndata if unparsed */ 51 | int length; /* the content length */ 52 | xmlEntityType etype; /* The entity type */ 53 | const xmlChar *ExternalID; /* External identifier for PUBLIC */ 54 | const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC Entity */ 55 | 56 | struct _xmlEntity *nexte; /* unused */ 57 | const xmlChar *URI; /* the full URI as computed */ 58 | int owner; /* does the entity own the childrens */ 59 | int checked; /* was the entity content checked */ 60 | /* this is also used to count entities 61 | * references done from that entity 62 | * and if it contains '<' */ 63 | }; 64 | 65 | /* 66 | * All entities are stored in an hash table. 67 | * There is 2 separate hash tables for global and parameter entities. 68 | */ 69 | 70 | typedef struct _xmlHashTable xmlEntitiesTable; 71 | typedef xmlEntitiesTable *xmlEntitiesTablePtr; 72 | 73 | /* 74 | * External functions: 75 | */ 76 | 77 | #ifdef LIBXML_LEGACY_ENABLED 78 | XMLPUBFUN void XMLCALL 79 | xmlInitializePredefinedEntities (void); 80 | #endif /* LIBXML_LEGACY_ENABLED */ 81 | 82 | XMLPUBFUN xmlEntityPtr XMLCALL 83 | xmlNewEntity (xmlDocPtr doc, 84 | const xmlChar *name, 85 | int type, 86 | const xmlChar *ExternalID, 87 | const xmlChar *SystemID, 88 | const xmlChar *content); 89 | XMLPUBFUN xmlEntityPtr XMLCALL 90 | xmlAddDocEntity (xmlDocPtr doc, 91 | const xmlChar *name, 92 | int type, 93 | const xmlChar *ExternalID, 94 | const xmlChar *SystemID, 95 | const xmlChar *content); 96 | XMLPUBFUN xmlEntityPtr XMLCALL 97 | xmlAddDtdEntity (xmlDocPtr doc, 98 | const xmlChar *name, 99 | int type, 100 | const xmlChar *ExternalID, 101 | const xmlChar *SystemID, 102 | const xmlChar *content); 103 | XMLPUBFUN xmlEntityPtr XMLCALL 104 | xmlGetPredefinedEntity (const xmlChar *name); 105 | XMLPUBFUN xmlEntityPtr XMLCALL 106 | xmlGetDocEntity (const xmlDoc *doc, 107 | const xmlChar *name); 108 | XMLPUBFUN xmlEntityPtr XMLCALL 109 | xmlGetDtdEntity (xmlDocPtr doc, 110 | const xmlChar *name); 111 | XMLPUBFUN xmlEntityPtr XMLCALL 112 | xmlGetParameterEntity (xmlDocPtr doc, 113 | const xmlChar *name); 114 | #ifdef LIBXML_LEGACY_ENABLED 115 | XMLPUBFUN const xmlChar * XMLCALL 116 | xmlEncodeEntities (xmlDocPtr doc, 117 | const xmlChar *input); 118 | #endif /* LIBXML_LEGACY_ENABLED */ 119 | XMLPUBFUN xmlChar * XMLCALL 120 | xmlEncodeEntitiesReentrant(xmlDocPtr doc, 121 | const xmlChar *input); 122 | XMLPUBFUN xmlChar * XMLCALL 123 | xmlEncodeSpecialChars (const xmlDoc *doc, 124 | const xmlChar *input); 125 | XMLPUBFUN xmlEntitiesTablePtr XMLCALL 126 | xmlCreateEntitiesTable (void); 127 | #ifdef LIBXML_TREE_ENABLED 128 | XMLPUBFUN xmlEntitiesTablePtr XMLCALL 129 | xmlCopyEntitiesTable (xmlEntitiesTablePtr table); 130 | #endif /* LIBXML_TREE_ENABLED */ 131 | XMLPUBFUN void XMLCALL 132 | xmlFreeEntitiesTable (xmlEntitiesTablePtr table); 133 | #ifdef LIBXML_OUTPUT_ENABLED 134 | XMLPUBFUN void XMLCALL 135 | xmlDumpEntitiesTable (xmlBufferPtr buf, 136 | xmlEntitiesTablePtr table); 137 | XMLPUBFUN void XMLCALL 138 | xmlDumpEntityDecl (xmlBufferPtr buf, 139 | xmlEntityPtr ent); 140 | #endif /* LIBXML_OUTPUT_ENABLED */ 141 | #ifdef LIBXML_LEGACY_ENABLED 142 | XMLPUBFUN void XMLCALL 143 | xmlCleanupPredefinedEntities(void); 144 | #endif /* LIBXML_LEGACY_ENABLED */ 145 | 146 | 147 | #ifdef __cplusplus 148 | } 149 | #endif 150 | 151 | # endif /* __XML_ENTITIES_H__ */ 152 | -------------------------------------------------------------------------------- /lxml/includes/libxml/list.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: lists interfaces 3 | * Description: this module implement the list support used in 4 | * various place in the library. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Gary Pennington 9 | */ 10 | 11 | #ifndef __XML_LINK_INCLUDE__ 12 | #define __XML_LINK_INCLUDE__ 13 | 14 | #include 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | typedef struct _xmlLink xmlLink; 21 | typedef xmlLink *xmlLinkPtr; 22 | 23 | typedef struct _xmlList xmlList; 24 | typedef xmlList *xmlListPtr; 25 | 26 | /** 27 | * xmlListDeallocator: 28 | * @lk: the data to deallocate 29 | * 30 | * Callback function used to free data from a list. 31 | */ 32 | typedef void (*xmlListDeallocator) (xmlLinkPtr lk); 33 | /** 34 | * xmlListDataCompare: 35 | * @data0: the first data 36 | * @data1: the second data 37 | * 38 | * Callback function used to compare 2 data. 39 | * 40 | * Returns 0 is equality, -1 or 1 otherwise depending on the ordering. 41 | */ 42 | typedef int (*xmlListDataCompare) (const void *data0, const void *data1); 43 | /** 44 | * xmlListWalker: 45 | * @data: the data found in the list 46 | * @user: extra user provided data to the walker 47 | * 48 | * Callback function used when walking a list with xmlListWalk(). 49 | * 50 | * Returns 0 to stop walking the list, 1 otherwise. 51 | */ 52 | typedef int (*xmlListWalker) (const void *data, void *user); 53 | 54 | /* Creation/Deletion */ 55 | XMLPUBFUN xmlListPtr XMLCALL 56 | xmlListCreate (xmlListDeallocator deallocator, 57 | xmlListDataCompare compare); 58 | XMLPUBFUN void XMLCALL 59 | xmlListDelete (xmlListPtr l); 60 | 61 | /* Basic Operators */ 62 | XMLPUBFUN void * XMLCALL 63 | xmlListSearch (xmlListPtr l, 64 | void *data); 65 | XMLPUBFUN void * XMLCALL 66 | xmlListReverseSearch (xmlListPtr l, 67 | void *data); 68 | XMLPUBFUN int XMLCALL 69 | xmlListInsert (xmlListPtr l, 70 | void *data) ; 71 | XMLPUBFUN int XMLCALL 72 | xmlListAppend (xmlListPtr l, 73 | void *data) ; 74 | XMLPUBFUN int XMLCALL 75 | xmlListRemoveFirst (xmlListPtr l, 76 | void *data); 77 | XMLPUBFUN int XMLCALL 78 | xmlListRemoveLast (xmlListPtr l, 79 | void *data); 80 | XMLPUBFUN int XMLCALL 81 | xmlListRemoveAll (xmlListPtr l, 82 | void *data); 83 | XMLPUBFUN void XMLCALL 84 | xmlListClear (xmlListPtr l); 85 | XMLPUBFUN int XMLCALL 86 | xmlListEmpty (xmlListPtr l); 87 | XMLPUBFUN xmlLinkPtr XMLCALL 88 | xmlListFront (xmlListPtr l); 89 | XMLPUBFUN xmlLinkPtr XMLCALL 90 | xmlListEnd (xmlListPtr l); 91 | XMLPUBFUN int XMLCALL 92 | xmlListSize (xmlListPtr l); 93 | 94 | XMLPUBFUN void XMLCALL 95 | xmlListPopFront (xmlListPtr l); 96 | XMLPUBFUN void XMLCALL 97 | xmlListPopBack (xmlListPtr l); 98 | XMLPUBFUN int XMLCALL 99 | xmlListPushFront (xmlListPtr l, 100 | void *data); 101 | XMLPUBFUN int XMLCALL 102 | xmlListPushBack (xmlListPtr l, 103 | void *data); 104 | 105 | /* Advanced Operators */ 106 | XMLPUBFUN void XMLCALL 107 | xmlListReverse (xmlListPtr l); 108 | XMLPUBFUN void XMLCALL 109 | xmlListSort (xmlListPtr l); 110 | XMLPUBFUN void XMLCALL 111 | xmlListWalk (xmlListPtr l, 112 | xmlListWalker walker, 113 | void *user); 114 | XMLPUBFUN void XMLCALL 115 | xmlListReverseWalk (xmlListPtr l, 116 | xmlListWalker walker, 117 | void *user); 118 | XMLPUBFUN void XMLCALL 119 | xmlListMerge (xmlListPtr l1, 120 | xmlListPtr l2); 121 | XMLPUBFUN xmlListPtr XMLCALL 122 | xmlListDup (const xmlListPtr old); 123 | XMLPUBFUN int XMLCALL 124 | xmlListCopy (xmlListPtr cur, 125 | const xmlListPtr old); 126 | /* Link operators */ 127 | XMLPUBFUN void * XMLCALL 128 | xmlLinkGetData (xmlLinkPtr lk); 129 | 130 | /* xmlListUnique() */ 131 | /* xmlListSwap */ 132 | 133 | #ifdef __cplusplus 134 | } 135 | #endif 136 | 137 | #endif /* __XML_LINK_INCLUDE__ */ 138 | -------------------------------------------------------------------------------- /lxml/includes/libxml/nanoftp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: minimal FTP implementation 3 | * Description: minimal FTP implementation allowing to fetch resources 4 | * like external subset. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __NANO_FTP_H__ 12 | #define __NANO_FTP_H__ 13 | 14 | #include 15 | 16 | #ifdef LIBXML_FTP_ENABLED 17 | 18 | /* Needed for portability to Windows 64 bits */ 19 | #if defined(_WIN32) && !defined(__CYGWIN__) 20 | #include 21 | #else 22 | /** 23 | * SOCKET: 24 | * 25 | * macro used to provide portability of code to windows sockets 26 | */ 27 | #define SOCKET int 28 | /** 29 | * INVALID_SOCKET: 30 | * 31 | * macro used to provide portability of code to windows sockets 32 | * the value to be used when the socket is not valid 33 | */ 34 | #undef INVALID_SOCKET 35 | #define INVALID_SOCKET (-1) 36 | #endif 37 | 38 | #ifdef __cplusplus 39 | extern "C" { 40 | #endif 41 | 42 | /** 43 | * ftpListCallback: 44 | * @userData: user provided data for the callback 45 | * @filename: the file name (including "->" when links are shown) 46 | * @attrib: the attribute string 47 | * @owner: the owner string 48 | * @group: the group string 49 | * @size: the file size 50 | * @links: the link count 51 | * @year: the year 52 | * @month: the month 53 | * @day: the day 54 | * @hour: the hour 55 | * @minute: the minute 56 | * 57 | * A callback for the xmlNanoFTPList command. 58 | * Note that only one of year and day:minute are specified. 59 | */ 60 | typedef void (*ftpListCallback) (void *userData, 61 | const char *filename, const char *attrib, 62 | const char *owner, const char *group, 63 | unsigned long size, int links, int year, 64 | const char *month, int day, int hour, 65 | int minute); 66 | /** 67 | * ftpDataCallback: 68 | * @userData: the user provided context 69 | * @data: the data received 70 | * @len: its size in bytes 71 | * 72 | * A callback for the xmlNanoFTPGet command. 73 | */ 74 | typedef void (*ftpDataCallback) (void *userData, 75 | const char *data, 76 | int len); 77 | 78 | /* 79 | * Init 80 | */ 81 | XMLPUBFUN void XMLCALL 82 | xmlNanoFTPInit (void); 83 | XMLPUBFUN void XMLCALL 84 | xmlNanoFTPCleanup (void); 85 | 86 | /* 87 | * Creating/freeing contexts. 88 | */ 89 | XMLPUBFUN void * XMLCALL 90 | xmlNanoFTPNewCtxt (const char *URL); 91 | XMLPUBFUN void XMLCALL 92 | xmlNanoFTPFreeCtxt (void * ctx); 93 | XMLPUBFUN void * XMLCALL 94 | xmlNanoFTPConnectTo (const char *server, 95 | int port); 96 | /* 97 | * Opening/closing session connections. 98 | */ 99 | XMLPUBFUN void * XMLCALL 100 | xmlNanoFTPOpen (const char *URL); 101 | XMLPUBFUN int XMLCALL 102 | xmlNanoFTPConnect (void *ctx); 103 | XMLPUBFUN int XMLCALL 104 | xmlNanoFTPClose (void *ctx); 105 | XMLPUBFUN int XMLCALL 106 | xmlNanoFTPQuit (void *ctx); 107 | XMLPUBFUN void XMLCALL 108 | xmlNanoFTPScanProxy (const char *URL); 109 | XMLPUBFUN void XMLCALL 110 | xmlNanoFTPProxy (const char *host, 111 | int port, 112 | const char *user, 113 | const char *passwd, 114 | int type); 115 | XMLPUBFUN int XMLCALL 116 | xmlNanoFTPUpdateURL (void *ctx, 117 | const char *URL); 118 | 119 | /* 120 | * Rather internal commands. 121 | */ 122 | XMLPUBFUN int XMLCALL 123 | xmlNanoFTPGetResponse (void *ctx); 124 | XMLPUBFUN int XMLCALL 125 | xmlNanoFTPCheckResponse (void *ctx); 126 | 127 | /* 128 | * CD/DIR/GET handlers. 129 | */ 130 | XMLPUBFUN int XMLCALL 131 | xmlNanoFTPCwd (void *ctx, 132 | const char *directory); 133 | XMLPUBFUN int XMLCALL 134 | xmlNanoFTPDele (void *ctx, 135 | const char *file); 136 | 137 | XMLPUBFUN SOCKET XMLCALL 138 | xmlNanoFTPGetConnection (void *ctx); 139 | XMLPUBFUN int XMLCALL 140 | xmlNanoFTPCloseConnection(void *ctx); 141 | XMLPUBFUN int XMLCALL 142 | xmlNanoFTPList (void *ctx, 143 | ftpListCallback callback, 144 | void *userData, 145 | const char *filename); 146 | XMLPUBFUN SOCKET XMLCALL 147 | xmlNanoFTPGetSocket (void *ctx, 148 | const char *filename); 149 | XMLPUBFUN int XMLCALL 150 | xmlNanoFTPGet (void *ctx, 151 | ftpDataCallback callback, 152 | void *userData, 153 | const char *filename); 154 | XMLPUBFUN int XMLCALL 155 | xmlNanoFTPRead (void *ctx, 156 | void *dest, 157 | int len); 158 | 159 | #ifdef __cplusplus 160 | } 161 | #endif 162 | #endif /* LIBXML_FTP_ENABLED */ 163 | #endif /* __NANO_FTP_H__ */ 164 | -------------------------------------------------------------------------------- /lxml/includes/libxml/nanohttp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: minimal HTTP implementation 3 | * Description: minimal HTTP implementation allowing to fetch resources 4 | * like external subset. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __NANO_HTTP_H__ 12 | #define __NANO_HTTP_H__ 13 | 14 | #include 15 | 16 | #ifdef LIBXML_HTTP_ENABLED 17 | 18 | #ifdef __cplusplus 19 | extern "C" { 20 | #endif 21 | XMLPUBFUN void XMLCALL 22 | xmlNanoHTTPInit (void); 23 | XMLPUBFUN void XMLCALL 24 | xmlNanoHTTPCleanup (void); 25 | XMLPUBFUN void XMLCALL 26 | xmlNanoHTTPScanProxy (const char *URL); 27 | XMLPUBFUN int XMLCALL 28 | xmlNanoHTTPFetch (const char *URL, 29 | const char *filename, 30 | char **contentType); 31 | XMLPUBFUN void * XMLCALL 32 | xmlNanoHTTPMethod (const char *URL, 33 | const char *method, 34 | const char *input, 35 | char **contentType, 36 | const char *headers, 37 | int ilen); 38 | XMLPUBFUN void * XMLCALL 39 | xmlNanoHTTPMethodRedir (const char *URL, 40 | const char *method, 41 | const char *input, 42 | char **contentType, 43 | char **redir, 44 | const char *headers, 45 | int ilen); 46 | XMLPUBFUN void * XMLCALL 47 | xmlNanoHTTPOpen (const char *URL, 48 | char **contentType); 49 | XMLPUBFUN void * XMLCALL 50 | xmlNanoHTTPOpenRedir (const char *URL, 51 | char **contentType, 52 | char **redir); 53 | XMLPUBFUN int XMLCALL 54 | xmlNanoHTTPReturnCode (void *ctx); 55 | XMLPUBFUN const char * XMLCALL 56 | xmlNanoHTTPAuthHeader (void *ctx); 57 | XMLPUBFUN const char * XMLCALL 58 | xmlNanoHTTPRedir (void *ctx); 59 | XMLPUBFUN int XMLCALL 60 | xmlNanoHTTPContentLength( void * ctx ); 61 | XMLPUBFUN const char * XMLCALL 62 | xmlNanoHTTPEncoding (void *ctx); 63 | XMLPUBFUN const char * XMLCALL 64 | xmlNanoHTTPMimeType (void *ctx); 65 | XMLPUBFUN int XMLCALL 66 | xmlNanoHTTPRead (void *ctx, 67 | void *dest, 68 | int len); 69 | #ifdef LIBXML_OUTPUT_ENABLED 70 | XMLPUBFUN int XMLCALL 71 | xmlNanoHTTPSave (void *ctxt, 72 | const char *filename); 73 | #endif /* LIBXML_OUTPUT_ENABLED */ 74 | XMLPUBFUN void XMLCALL 75 | xmlNanoHTTPClose (void *ctx); 76 | #ifdef __cplusplus 77 | } 78 | #endif 79 | 80 | #endif /* LIBXML_HTTP_ENABLED */ 81 | #endif /* __NANO_HTTP_H__ */ 82 | -------------------------------------------------------------------------------- /lxml/includes/libxml/pattern.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: pattern expression handling 3 | * Description: allows to compile and test pattern expressions for nodes 4 | * either in a tree or based on a parser state. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_PATTERN_H__ 12 | #define __XML_PATTERN_H__ 13 | 14 | #include 15 | #include 16 | #include 17 | 18 | #ifdef LIBXML_PATTERN_ENABLED 19 | 20 | #ifdef __cplusplus 21 | extern "C" { 22 | #endif 23 | 24 | /** 25 | * xmlPattern: 26 | * 27 | * A compiled (XPath based) pattern to select nodes 28 | */ 29 | typedef struct _xmlPattern xmlPattern; 30 | typedef xmlPattern *xmlPatternPtr; 31 | 32 | /** 33 | * xmlPatternFlags: 34 | * 35 | * This is the set of options affecting the behaviour of pattern 36 | * matching with this module 37 | * 38 | */ 39 | typedef enum { 40 | XML_PATTERN_DEFAULT = 0, /* simple pattern match */ 41 | XML_PATTERN_XPATH = 1<<0, /* standard XPath pattern */ 42 | XML_PATTERN_XSSEL = 1<<1, /* XPath subset for schema selector */ 43 | XML_PATTERN_XSFIELD = 1<<2 /* XPath subset for schema field */ 44 | } xmlPatternFlags; 45 | 46 | XMLPUBFUN void XMLCALL 47 | xmlFreePattern (xmlPatternPtr comp); 48 | 49 | XMLPUBFUN void XMLCALL 50 | xmlFreePatternList (xmlPatternPtr comp); 51 | 52 | XMLPUBFUN xmlPatternPtr XMLCALL 53 | xmlPatterncompile (const xmlChar *pattern, 54 | xmlDict *dict, 55 | int flags, 56 | const xmlChar **namespaces); 57 | XMLPUBFUN int XMLCALL 58 | xmlPatternMatch (xmlPatternPtr comp, 59 | xmlNodePtr node); 60 | 61 | /* streaming interfaces */ 62 | typedef struct _xmlStreamCtxt xmlStreamCtxt; 63 | typedef xmlStreamCtxt *xmlStreamCtxtPtr; 64 | 65 | XMLPUBFUN int XMLCALL 66 | xmlPatternStreamable (xmlPatternPtr comp); 67 | XMLPUBFUN int XMLCALL 68 | xmlPatternMaxDepth (xmlPatternPtr comp); 69 | XMLPUBFUN int XMLCALL 70 | xmlPatternMinDepth (xmlPatternPtr comp); 71 | XMLPUBFUN int XMLCALL 72 | xmlPatternFromRoot (xmlPatternPtr comp); 73 | XMLPUBFUN xmlStreamCtxtPtr XMLCALL 74 | xmlPatternGetStreamCtxt (xmlPatternPtr comp); 75 | XMLPUBFUN void XMLCALL 76 | xmlFreeStreamCtxt (xmlStreamCtxtPtr stream); 77 | XMLPUBFUN int XMLCALL 78 | xmlStreamPushNode (xmlStreamCtxtPtr stream, 79 | const xmlChar *name, 80 | const xmlChar *ns, 81 | int nodeType); 82 | XMLPUBFUN int XMLCALL 83 | xmlStreamPush (xmlStreamCtxtPtr stream, 84 | const xmlChar *name, 85 | const xmlChar *ns); 86 | XMLPUBFUN int XMLCALL 87 | xmlStreamPushAttr (xmlStreamCtxtPtr stream, 88 | const xmlChar *name, 89 | const xmlChar *ns); 90 | XMLPUBFUN int XMLCALL 91 | xmlStreamPop (xmlStreamCtxtPtr stream); 92 | XMLPUBFUN int XMLCALL 93 | xmlStreamWantsAnyNode (xmlStreamCtxtPtr stream); 94 | #ifdef __cplusplus 95 | } 96 | #endif 97 | 98 | #endif /* LIBXML_PATTERN_ENABLED */ 99 | 100 | #endif /* __XML_PATTERN_H__ */ 101 | -------------------------------------------------------------------------------- /lxml/includes/libxml/schematron.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: XML Schemastron implementation 3 | * Description: interface to the XML Schematron validity checking. 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Daniel Veillard 8 | */ 9 | 10 | 11 | #ifndef __XML_SCHEMATRON_H__ 12 | #define __XML_SCHEMATRON_H__ 13 | 14 | #include 15 | 16 | #ifdef LIBXML_SCHEMATRON_ENABLED 17 | 18 | #include 19 | 20 | #ifdef __cplusplus 21 | extern "C" { 22 | #endif 23 | 24 | typedef enum { 25 | XML_SCHEMATRON_OUT_QUIET = 1 << 0, /* quiet no report */ 26 | XML_SCHEMATRON_OUT_TEXT = 1 << 1, /* build a textual report */ 27 | XML_SCHEMATRON_OUT_XML = 1 << 2, /* output SVRL */ 28 | XML_SCHEMATRON_OUT_ERROR = 1 << 3, /* output via xmlStructuredErrorFunc */ 29 | XML_SCHEMATRON_OUT_FILE = 1 << 8, /* output to a file descriptor */ 30 | XML_SCHEMATRON_OUT_BUFFER = 1 << 9, /* output to a buffer */ 31 | XML_SCHEMATRON_OUT_IO = 1 << 10 /* output to I/O mechanism */ 32 | } xmlSchematronValidOptions; 33 | 34 | /** 35 | * The schemas related types are kept internal 36 | */ 37 | typedef struct _xmlSchematron xmlSchematron; 38 | typedef xmlSchematron *xmlSchematronPtr; 39 | 40 | /** 41 | * xmlSchematronValidityErrorFunc: 42 | * @ctx: the validation context 43 | * @msg: the message 44 | * @...: extra arguments 45 | * 46 | * Signature of an error callback from a Schematron validation 47 | */ 48 | typedef void (*xmlSchematronValidityErrorFunc) (void *ctx, const char *msg, ...); 49 | 50 | /** 51 | * xmlSchematronValidityWarningFunc: 52 | * @ctx: the validation context 53 | * @msg: the message 54 | * @...: extra arguments 55 | * 56 | * Signature of a warning callback from a Schematron validation 57 | */ 58 | typedef void (*xmlSchematronValidityWarningFunc) (void *ctx, const char *msg, ...); 59 | 60 | /** 61 | * A schemas validation context 62 | */ 63 | typedef struct _xmlSchematronParserCtxt xmlSchematronParserCtxt; 64 | typedef xmlSchematronParserCtxt *xmlSchematronParserCtxtPtr; 65 | 66 | typedef struct _xmlSchematronValidCtxt xmlSchematronValidCtxt; 67 | typedef xmlSchematronValidCtxt *xmlSchematronValidCtxtPtr; 68 | 69 | /* 70 | * Interfaces for parsing. 71 | */ 72 | XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL 73 | xmlSchematronNewParserCtxt (const char *URL); 74 | XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL 75 | xmlSchematronNewMemParserCtxt(const char *buffer, 76 | int size); 77 | XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL 78 | xmlSchematronNewDocParserCtxt(xmlDocPtr doc); 79 | XMLPUBFUN void XMLCALL 80 | xmlSchematronFreeParserCtxt (xmlSchematronParserCtxtPtr ctxt); 81 | /***** 82 | XMLPUBFUN void XMLCALL 83 | xmlSchematronSetParserErrors(xmlSchematronParserCtxtPtr ctxt, 84 | xmlSchematronValidityErrorFunc err, 85 | xmlSchematronValidityWarningFunc warn, 86 | void *ctx); 87 | XMLPUBFUN int XMLCALL 88 | xmlSchematronGetParserErrors(xmlSchematronParserCtxtPtr ctxt, 89 | xmlSchematronValidityErrorFunc * err, 90 | xmlSchematronValidityWarningFunc * warn, 91 | void **ctx); 92 | XMLPUBFUN int XMLCALL 93 | xmlSchematronIsValid (xmlSchematronValidCtxtPtr ctxt); 94 | *****/ 95 | XMLPUBFUN xmlSchematronPtr XMLCALL 96 | xmlSchematronParse (xmlSchematronParserCtxtPtr ctxt); 97 | XMLPUBFUN void XMLCALL 98 | xmlSchematronFree (xmlSchematronPtr schema); 99 | /* 100 | * Interfaces for validating 101 | */ 102 | XMLPUBFUN void XMLCALL 103 | xmlSchematronSetValidStructuredErrors( 104 | xmlSchematronValidCtxtPtr ctxt, 105 | xmlStructuredErrorFunc serror, 106 | void *ctx); 107 | /****** 108 | XMLPUBFUN void XMLCALL 109 | xmlSchematronSetValidErrors (xmlSchematronValidCtxtPtr ctxt, 110 | xmlSchematronValidityErrorFunc err, 111 | xmlSchematronValidityWarningFunc warn, 112 | void *ctx); 113 | XMLPUBFUN int XMLCALL 114 | xmlSchematronGetValidErrors (xmlSchematronValidCtxtPtr ctxt, 115 | xmlSchematronValidityErrorFunc *err, 116 | xmlSchematronValidityWarningFunc *warn, 117 | void **ctx); 118 | XMLPUBFUN int XMLCALL 119 | xmlSchematronSetValidOptions(xmlSchematronValidCtxtPtr ctxt, 120 | int options); 121 | XMLPUBFUN int XMLCALL 122 | xmlSchematronValidCtxtGetOptions(xmlSchematronValidCtxtPtr ctxt); 123 | XMLPUBFUN int XMLCALL 124 | xmlSchematronValidateOneElement (xmlSchematronValidCtxtPtr ctxt, 125 | xmlNodePtr elem); 126 | *******/ 127 | 128 | XMLPUBFUN xmlSchematronValidCtxtPtr XMLCALL 129 | xmlSchematronNewValidCtxt (xmlSchematronPtr schema, 130 | int options); 131 | XMLPUBFUN void XMLCALL 132 | xmlSchematronFreeValidCtxt (xmlSchematronValidCtxtPtr ctxt); 133 | XMLPUBFUN int XMLCALL 134 | xmlSchematronValidateDoc (xmlSchematronValidCtxtPtr ctxt, 135 | xmlDocPtr instance); 136 | 137 | #ifdef __cplusplus 138 | } 139 | #endif 140 | 141 | #endif /* LIBXML_SCHEMATRON_ENABLED */ 142 | #endif /* __XML_SCHEMATRON_H__ */ 143 | -------------------------------------------------------------------------------- /lxml/includes/libxml/threads.h: -------------------------------------------------------------------------------- 1 | /** 2 | * Summary: interfaces for thread handling 3 | * Description: set of generic threading related routines 4 | * should work with pthreads, Windows native or TLS threads 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_THREADS_H__ 12 | #define __XML_THREADS_H__ 13 | 14 | #include 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | /* 21 | * xmlMutex are a simple mutual exception locks. 22 | */ 23 | typedef struct _xmlMutex xmlMutex; 24 | typedef xmlMutex *xmlMutexPtr; 25 | 26 | /* 27 | * xmlRMutex are reentrant mutual exception locks. 28 | */ 29 | typedef struct _xmlRMutex xmlRMutex; 30 | typedef xmlRMutex *xmlRMutexPtr; 31 | 32 | #ifdef __cplusplus 33 | } 34 | #endif 35 | #include 36 | #ifdef __cplusplus 37 | extern "C" { 38 | #endif 39 | XMLPUBFUN xmlMutexPtr XMLCALL 40 | xmlNewMutex (void); 41 | XMLPUBFUN void XMLCALL 42 | xmlMutexLock (xmlMutexPtr tok); 43 | XMLPUBFUN void XMLCALL 44 | xmlMutexUnlock (xmlMutexPtr tok); 45 | XMLPUBFUN void XMLCALL 46 | xmlFreeMutex (xmlMutexPtr tok); 47 | 48 | XMLPUBFUN xmlRMutexPtr XMLCALL 49 | xmlNewRMutex (void); 50 | XMLPUBFUN void XMLCALL 51 | xmlRMutexLock (xmlRMutexPtr tok); 52 | XMLPUBFUN void XMLCALL 53 | xmlRMutexUnlock (xmlRMutexPtr tok); 54 | XMLPUBFUN void XMLCALL 55 | xmlFreeRMutex (xmlRMutexPtr tok); 56 | 57 | /* 58 | * Library wide APIs. 59 | */ 60 | XMLPUBFUN void XMLCALL 61 | xmlInitThreads (void); 62 | XMLPUBFUN void XMLCALL 63 | xmlLockLibrary (void); 64 | XMLPUBFUN void XMLCALL 65 | xmlUnlockLibrary(void); 66 | XMLPUBFUN int XMLCALL 67 | xmlGetThreadId (void); 68 | XMLPUBFUN int XMLCALL 69 | xmlIsMainThread (void); 70 | XMLPUBFUN void XMLCALL 71 | xmlCleanupThreads(void); 72 | XMLPUBFUN xmlGlobalStatePtr XMLCALL 73 | xmlGetGlobalState(void); 74 | 75 | #ifdef HAVE_PTHREAD_H 76 | #elif defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && (!defined(LIBXML_STATIC) || defined(LIBXML_STATIC_FOR_DLL)) 77 | #if defined(LIBXML_STATIC_FOR_DLL) 78 | int XMLCALL 79 | xmlDllMain(void *hinstDLL, unsigned long fdwReason, 80 | void *lpvReserved); 81 | #endif 82 | #endif 83 | 84 | #ifdef __cplusplus 85 | } 86 | #endif 87 | 88 | 89 | #endif /* __XML_THREADS_H__ */ 90 | -------------------------------------------------------------------------------- /lxml/includes/libxml/uri.h: -------------------------------------------------------------------------------- 1 | /** 2 | * Summary: library of generic URI related routines 3 | * Description: library of generic URI related routines 4 | * Implements RFC 2396 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_URI_H__ 12 | #define __XML_URI_H__ 13 | 14 | #include 15 | #include 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | /** 22 | * xmlURI: 23 | * 24 | * A parsed URI reference. This is a struct containing the various fields 25 | * as described in RFC 2396 but separated for further processing. 26 | * 27 | * Note: query is a deprecated field which is incorrectly unescaped. 28 | * query_raw takes precedence over query if the former is set. 29 | * See: http://mail.gnome.org/archives/xml/2007-April/thread.html#00127 30 | */ 31 | typedef struct _xmlURI xmlURI; 32 | typedef xmlURI *xmlURIPtr; 33 | struct _xmlURI { 34 | char *scheme; /* the URI scheme */ 35 | char *opaque; /* opaque part */ 36 | char *authority; /* the authority part */ 37 | char *server; /* the server part */ 38 | char *user; /* the user part */ 39 | int port; /* the port number */ 40 | char *path; /* the path string */ 41 | char *query; /* the query string (deprecated - use with caution) */ 42 | char *fragment; /* the fragment identifier */ 43 | int cleanup; /* parsing potentially unclean URI */ 44 | char *query_raw; /* the query string (as it appears in the URI) */ 45 | }; 46 | 47 | /* 48 | * This function is in tree.h: 49 | * xmlChar * xmlNodeGetBase (xmlDocPtr doc, 50 | * xmlNodePtr cur); 51 | */ 52 | XMLPUBFUN xmlURIPtr XMLCALL 53 | xmlCreateURI (void); 54 | XMLPUBFUN xmlChar * XMLCALL 55 | xmlBuildURI (const xmlChar *URI, 56 | const xmlChar *base); 57 | XMLPUBFUN xmlChar * XMLCALL 58 | xmlBuildRelativeURI (const xmlChar *URI, 59 | const xmlChar *base); 60 | XMLPUBFUN xmlURIPtr XMLCALL 61 | xmlParseURI (const char *str); 62 | XMLPUBFUN xmlURIPtr XMLCALL 63 | xmlParseURIRaw (const char *str, 64 | int raw); 65 | XMLPUBFUN int XMLCALL 66 | xmlParseURIReference (xmlURIPtr uri, 67 | const char *str); 68 | XMLPUBFUN xmlChar * XMLCALL 69 | xmlSaveUri (xmlURIPtr uri); 70 | XMLPUBFUN void XMLCALL 71 | xmlPrintURI (FILE *stream, 72 | xmlURIPtr uri); 73 | XMLPUBFUN xmlChar * XMLCALL 74 | xmlURIEscapeStr (const xmlChar *str, 75 | const xmlChar *list); 76 | XMLPUBFUN char * XMLCALL 77 | xmlURIUnescapeString (const char *str, 78 | int len, 79 | char *target); 80 | XMLPUBFUN int XMLCALL 81 | xmlNormalizeURIPath (char *path); 82 | XMLPUBFUN xmlChar * XMLCALL 83 | xmlURIEscape (const xmlChar *str); 84 | XMLPUBFUN void XMLCALL 85 | xmlFreeURI (xmlURIPtr uri); 86 | XMLPUBFUN xmlChar* XMLCALL 87 | xmlCanonicPath (const xmlChar *path); 88 | XMLPUBFUN xmlChar* XMLCALL 89 | xmlPathToURI (const xmlChar *path); 90 | 91 | #ifdef __cplusplus 92 | } 93 | #endif 94 | #endif /* __XML_URI_H__ */ 95 | -------------------------------------------------------------------------------- /lxml/includes/libxml/xinclude.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: implementation of XInclude 3 | * Description: API to handle XInclude processing, 4 | * implements the 5 | * World Wide Web Consortium Last Call Working Draft 10 November 2003 6 | * http://www.w3.org/TR/2003/WD-xinclude-20031110 7 | * 8 | * Copy: See Copyright for the status of this software. 9 | * 10 | * Author: Daniel Veillard 11 | */ 12 | 13 | #ifndef __XML_XINCLUDE_H__ 14 | #define __XML_XINCLUDE_H__ 15 | 16 | #include 17 | #include 18 | 19 | #ifdef LIBXML_XINCLUDE_ENABLED 20 | 21 | #ifdef __cplusplus 22 | extern "C" { 23 | #endif 24 | 25 | /** 26 | * XINCLUDE_NS: 27 | * 28 | * Macro defining the Xinclude namespace: http://www.w3.org/2003/XInclude 29 | */ 30 | #define XINCLUDE_NS (const xmlChar *) "http://www.w3.org/2003/XInclude" 31 | /** 32 | * XINCLUDE_OLD_NS: 33 | * 34 | * Macro defining the draft Xinclude namespace: http://www.w3.org/2001/XInclude 35 | */ 36 | #define XINCLUDE_OLD_NS (const xmlChar *) "http://www.w3.org/2001/XInclude" 37 | /** 38 | * XINCLUDE_NODE: 39 | * 40 | * Macro defining "include" 41 | */ 42 | #define XINCLUDE_NODE (const xmlChar *) "include" 43 | /** 44 | * XINCLUDE_FALLBACK: 45 | * 46 | * Macro defining "fallback" 47 | */ 48 | #define XINCLUDE_FALLBACK (const xmlChar *) "fallback" 49 | /** 50 | * XINCLUDE_HREF: 51 | * 52 | * Macro defining "href" 53 | */ 54 | #define XINCLUDE_HREF (const xmlChar *) "href" 55 | /** 56 | * XINCLUDE_PARSE: 57 | * 58 | * Macro defining "parse" 59 | */ 60 | #define XINCLUDE_PARSE (const xmlChar *) "parse" 61 | /** 62 | * XINCLUDE_PARSE_XML: 63 | * 64 | * Macro defining "xml" 65 | */ 66 | #define XINCLUDE_PARSE_XML (const xmlChar *) "xml" 67 | /** 68 | * XINCLUDE_PARSE_TEXT: 69 | * 70 | * Macro defining "text" 71 | */ 72 | #define XINCLUDE_PARSE_TEXT (const xmlChar *) "text" 73 | /** 74 | * XINCLUDE_PARSE_ENCODING: 75 | * 76 | * Macro defining "encoding" 77 | */ 78 | #define XINCLUDE_PARSE_ENCODING (const xmlChar *) "encoding" 79 | /** 80 | * XINCLUDE_PARSE_XPOINTER: 81 | * 82 | * Macro defining "xpointer" 83 | */ 84 | #define XINCLUDE_PARSE_XPOINTER (const xmlChar *) "xpointer" 85 | 86 | typedef struct _xmlXIncludeCtxt xmlXIncludeCtxt; 87 | typedef xmlXIncludeCtxt *xmlXIncludeCtxtPtr; 88 | 89 | /* 90 | * standalone processing 91 | */ 92 | XMLPUBFUN int XMLCALL 93 | xmlXIncludeProcess (xmlDocPtr doc); 94 | XMLPUBFUN int XMLCALL 95 | xmlXIncludeProcessFlags (xmlDocPtr doc, 96 | int flags); 97 | XMLPUBFUN int XMLCALL 98 | xmlXIncludeProcessFlagsData(xmlDocPtr doc, 99 | int flags, 100 | void *data); 101 | XMLPUBFUN int XMLCALL 102 | xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, 103 | int flags, 104 | void *data); 105 | XMLPUBFUN int XMLCALL 106 | xmlXIncludeProcessTree (xmlNodePtr tree); 107 | XMLPUBFUN int XMLCALL 108 | xmlXIncludeProcessTreeFlags(xmlNodePtr tree, 109 | int flags); 110 | /* 111 | * contextual processing 112 | */ 113 | XMLPUBFUN xmlXIncludeCtxtPtr XMLCALL 114 | xmlXIncludeNewContext (xmlDocPtr doc); 115 | XMLPUBFUN int XMLCALL 116 | xmlXIncludeSetFlags (xmlXIncludeCtxtPtr ctxt, 117 | int flags); 118 | XMLPUBFUN void XMLCALL 119 | xmlXIncludeFreeContext (xmlXIncludeCtxtPtr ctxt); 120 | XMLPUBFUN int XMLCALL 121 | xmlXIncludeProcessNode (xmlXIncludeCtxtPtr ctxt, 122 | xmlNodePtr tree); 123 | #ifdef __cplusplus 124 | } 125 | #endif 126 | 127 | #endif /* LIBXML_XINCLUDE_ENABLED */ 128 | 129 | #endif /* __XML_XINCLUDE_H__ */ 130 | -------------------------------------------------------------------------------- /lxml/includes/libxml/xlink.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: unfinished XLink detection module 3 | * Description: unfinished XLink detection module 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Daniel Veillard 8 | */ 9 | 10 | #ifndef __XML_XLINK_H__ 11 | #define __XML_XLINK_H__ 12 | 13 | #include 14 | #include 15 | 16 | #ifdef LIBXML_XPTR_ENABLED 17 | 18 | #ifdef __cplusplus 19 | extern "C" { 20 | #endif 21 | 22 | /** 23 | * Various defines for the various Link properties. 24 | * 25 | * NOTE: the link detection layer will try to resolve QName expansion 26 | * of namespaces. If "foo" is the prefix for "http://foo.com/" 27 | * then the link detection layer will expand role="foo:myrole" 28 | * to "http://foo.com/:myrole". 29 | * NOTE: the link detection layer will expand URI-References found on 30 | * href attributes by using the base mechanism if found. 31 | */ 32 | typedef xmlChar *xlinkHRef; 33 | typedef xmlChar *xlinkRole; 34 | typedef xmlChar *xlinkTitle; 35 | 36 | typedef enum { 37 | XLINK_TYPE_NONE = 0, 38 | XLINK_TYPE_SIMPLE, 39 | XLINK_TYPE_EXTENDED, 40 | XLINK_TYPE_EXTENDED_SET 41 | } xlinkType; 42 | 43 | typedef enum { 44 | XLINK_SHOW_NONE = 0, 45 | XLINK_SHOW_NEW, 46 | XLINK_SHOW_EMBED, 47 | XLINK_SHOW_REPLACE 48 | } xlinkShow; 49 | 50 | typedef enum { 51 | XLINK_ACTUATE_NONE = 0, 52 | XLINK_ACTUATE_AUTO, 53 | XLINK_ACTUATE_ONREQUEST 54 | } xlinkActuate; 55 | 56 | /** 57 | * xlinkNodeDetectFunc: 58 | * @ctx: user data pointer 59 | * @node: the node to check 60 | * 61 | * This is the prototype for the link detection routine. 62 | * It calls the default link detection callbacks upon link detection. 63 | */ 64 | typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node); 65 | 66 | /* 67 | * The link detection module interact with the upper layers using 68 | * a set of callback registered at parsing time. 69 | */ 70 | 71 | /** 72 | * xlinkSimpleLinkFunk: 73 | * @ctx: user data pointer 74 | * @node: the node carrying the link 75 | * @href: the target of the link 76 | * @role: the role string 77 | * @title: the link title 78 | * 79 | * This is the prototype for a simple link detection callback. 80 | */ 81 | typedef void 82 | (*xlinkSimpleLinkFunk) (void *ctx, 83 | xmlNodePtr node, 84 | const xlinkHRef href, 85 | const xlinkRole role, 86 | const xlinkTitle title); 87 | 88 | /** 89 | * xlinkExtendedLinkFunk: 90 | * @ctx: user data pointer 91 | * @node: the node carrying the link 92 | * @nbLocators: the number of locators detected on the link 93 | * @hrefs: pointer to the array of locator hrefs 94 | * @roles: pointer to the array of locator roles 95 | * @nbArcs: the number of arcs detected on the link 96 | * @from: pointer to the array of source roles found on the arcs 97 | * @to: pointer to the array of target roles found on the arcs 98 | * @show: array of values for the show attributes found on the arcs 99 | * @actuate: array of values for the actuate attributes found on the arcs 100 | * @nbTitles: the number of titles detected on the link 101 | * @title: array of titles detected on the link 102 | * @langs: array of xml:lang values for the titles 103 | * 104 | * This is the prototype for a extended link detection callback. 105 | */ 106 | typedef void 107 | (*xlinkExtendedLinkFunk)(void *ctx, 108 | xmlNodePtr node, 109 | int nbLocators, 110 | const xlinkHRef *hrefs, 111 | const xlinkRole *roles, 112 | int nbArcs, 113 | const xlinkRole *from, 114 | const xlinkRole *to, 115 | xlinkShow *show, 116 | xlinkActuate *actuate, 117 | int nbTitles, 118 | const xlinkTitle *titles, 119 | const xmlChar **langs); 120 | 121 | /** 122 | * xlinkExtendedLinkSetFunk: 123 | * @ctx: user data pointer 124 | * @node: the node carrying the link 125 | * @nbLocators: the number of locators detected on the link 126 | * @hrefs: pointer to the array of locator hrefs 127 | * @roles: pointer to the array of locator roles 128 | * @nbTitles: the number of titles detected on the link 129 | * @title: array of titles detected on the link 130 | * @langs: array of xml:lang values for the titles 131 | * 132 | * This is the prototype for a extended link set detection callback. 133 | */ 134 | typedef void 135 | (*xlinkExtendedLinkSetFunk) (void *ctx, 136 | xmlNodePtr node, 137 | int nbLocators, 138 | const xlinkHRef *hrefs, 139 | const xlinkRole *roles, 140 | int nbTitles, 141 | const xlinkTitle *titles, 142 | const xmlChar **langs); 143 | 144 | /** 145 | * This is the structure containing a set of Links detection callbacks. 146 | * 147 | * There is no default xlink callbacks, if one want to get link 148 | * recognition activated, those call backs must be provided before parsing. 149 | */ 150 | typedef struct _xlinkHandler xlinkHandler; 151 | typedef xlinkHandler *xlinkHandlerPtr; 152 | struct _xlinkHandler { 153 | xlinkSimpleLinkFunk simple; 154 | xlinkExtendedLinkFunk extended; 155 | xlinkExtendedLinkSetFunk set; 156 | }; 157 | 158 | /* 159 | * The default detection routine, can be overridden, they call the default 160 | * detection callbacks. 161 | */ 162 | 163 | XMLPUBFUN xlinkNodeDetectFunc XMLCALL 164 | xlinkGetDefaultDetect (void); 165 | XMLPUBFUN void XMLCALL 166 | xlinkSetDefaultDetect (xlinkNodeDetectFunc func); 167 | 168 | /* 169 | * Routines to set/get the default handlers. 170 | */ 171 | XMLPUBFUN xlinkHandlerPtr XMLCALL 172 | xlinkGetDefaultHandler (void); 173 | XMLPUBFUN void XMLCALL 174 | xlinkSetDefaultHandler (xlinkHandlerPtr handler); 175 | 176 | /* 177 | * Link detection module itself. 178 | */ 179 | XMLPUBFUN xlinkType XMLCALL 180 | xlinkIsLink (xmlDocPtr doc, 181 | xmlNodePtr node); 182 | 183 | #ifdef __cplusplus 184 | } 185 | #endif 186 | 187 | #endif /* LIBXML_XPTR_ENABLED */ 188 | 189 | #endif /* __XML_XLINK_H__ */ 190 | -------------------------------------------------------------------------------- /lxml/includes/libxml/xmlautomata.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: API to build regexp automata 3 | * Description: the API to build regexp automata 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Daniel Veillard 8 | */ 9 | 10 | #ifndef __XML_AUTOMATA_H__ 11 | #define __XML_AUTOMATA_H__ 12 | 13 | #include 14 | #include 15 | 16 | #ifdef LIBXML_REGEXP_ENABLED 17 | #ifdef LIBXML_AUTOMATA_ENABLED 18 | #include 19 | 20 | #ifdef __cplusplus 21 | extern "C" { 22 | #endif 23 | 24 | /** 25 | * xmlAutomataPtr: 26 | * 27 | * A libxml automata description, It can be compiled into a regexp 28 | */ 29 | typedef struct _xmlAutomata xmlAutomata; 30 | typedef xmlAutomata *xmlAutomataPtr; 31 | 32 | /** 33 | * xmlAutomataStatePtr: 34 | * 35 | * A state int the automata description, 36 | */ 37 | typedef struct _xmlAutomataState xmlAutomataState; 38 | typedef xmlAutomataState *xmlAutomataStatePtr; 39 | 40 | /* 41 | * Building API 42 | */ 43 | XMLPUBFUN xmlAutomataPtr XMLCALL 44 | xmlNewAutomata (void); 45 | XMLPUBFUN void XMLCALL 46 | xmlFreeAutomata (xmlAutomataPtr am); 47 | 48 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 49 | xmlAutomataGetInitState (xmlAutomataPtr am); 50 | XMLPUBFUN int XMLCALL 51 | xmlAutomataSetFinalState (xmlAutomataPtr am, 52 | xmlAutomataStatePtr state); 53 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 54 | xmlAutomataNewState (xmlAutomataPtr am); 55 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 56 | xmlAutomataNewTransition (xmlAutomataPtr am, 57 | xmlAutomataStatePtr from, 58 | xmlAutomataStatePtr to, 59 | const xmlChar *token, 60 | void *data); 61 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 62 | xmlAutomataNewTransition2 (xmlAutomataPtr am, 63 | xmlAutomataStatePtr from, 64 | xmlAutomataStatePtr to, 65 | const xmlChar *token, 66 | const xmlChar *token2, 67 | void *data); 68 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 69 | xmlAutomataNewNegTrans (xmlAutomataPtr am, 70 | xmlAutomataStatePtr from, 71 | xmlAutomataStatePtr to, 72 | const xmlChar *token, 73 | const xmlChar *token2, 74 | void *data); 75 | 76 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 77 | xmlAutomataNewCountTrans (xmlAutomataPtr am, 78 | xmlAutomataStatePtr from, 79 | xmlAutomataStatePtr to, 80 | const xmlChar *token, 81 | int min, 82 | int max, 83 | void *data); 84 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 85 | xmlAutomataNewCountTrans2 (xmlAutomataPtr am, 86 | xmlAutomataStatePtr from, 87 | xmlAutomataStatePtr to, 88 | const xmlChar *token, 89 | const xmlChar *token2, 90 | int min, 91 | int max, 92 | void *data); 93 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 94 | xmlAutomataNewOnceTrans (xmlAutomataPtr am, 95 | xmlAutomataStatePtr from, 96 | xmlAutomataStatePtr to, 97 | const xmlChar *token, 98 | int min, 99 | int max, 100 | void *data); 101 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 102 | xmlAutomataNewOnceTrans2 (xmlAutomataPtr am, 103 | xmlAutomataStatePtr from, 104 | xmlAutomataStatePtr to, 105 | const xmlChar *token, 106 | const xmlChar *token2, 107 | int min, 108 | int max, 109 | void *data); 110 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 111 | xmlAutomataNewAllTrans (xmlAutomataPtr am, 112 | xmlAutomataStatePtr from, 113 | xmlAutomataStatePtr to, 114 | int lax); 115 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 116 | xmlAutomataNewEpsilon (xmlAutomataPtr am, 117 | xmlAutomataStatePtr from, 118 | xmlAutomataStatePtr to); 119 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 120 | xmlAutomataNewCountedTrans (xmlAutomataPtr am, 121 | xmlAutomataStatePtr from, 122 | xmlAutomataStatePtr to, 123 | int counter); 124 | XMLPUBFUN xmlAutomataStatePtr XMLCALL 125 | xmlAutomataNewCounterTrans (xmlAutomataPtr am, 126 | xmlAutomataStatePtr from, 127 | xmlAutomataStatePtr to, 128 | int counter); 129 | XMLPUBFUN int XMLCALL 130 | xmlAutomataNewCounter (xmlAutomataPtr am, 131 | int min, 132 | int max); 133 | 134 | XMLPUBFUN xmlRegexpPtr XMLCALL 135 | xmlAutomataCompile (xmlAutomataPtr am); 136 | XMLPUBFUN int XMLCALL 137 | xmlAutomataIsDeterminist (xmlAutomataPtr am); 138 | 139 | #ifdef __cplusplus 140 | } 141 | #endif 142 | 143 | #endif /* LIBXML_AUTOMATA_ENABLED */ 144 | #endif /* LIBXML_REGEXP_ENABLED */ 145 | 146 | #endif /* __XML_AUTOMATA_H__ */ 147 | -------------------------------------------------------------------------------- /lxml/includes/libxml/xmlexports.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: macros for marking symbols as exportable/importable. 3 | * Description: macros for marking symbols as exportable/importable. 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | */ 7 | 8 | #ifndef __XML_EXPORTS_H__ 9 | #define __XML_EXPORTS_H__ 10 | 11 | #if defined(_WIN32) || defined(__CYGWIN__) 12 | /** DOC_DISABLE */ 13 | 14 | #ifdef LIBXML_STATIC 15 | #define XMLPUBLIC 16 | #elif defined(IN_LIBXML) 17 | #define XMLPUBLIC __declspec(dllexport) 18 | #else 19 | #define XMLPUBLIC __declspec(dllimport) 20 | #endif 21 | 22 | #if defined(LIBXML_FASTCALL) 23 | #define XMLCALL __fastcall 24 | #else 25 | #define XMLCALL __cdecl 26 | #endif 27 | #define XMLCDECL __cdecl 28 | 29 | /** DOC_ENABLE */ 30 | #else /* not Windows */ 31 | 32 | /** 33 | * XMLPUBLIC: 34 | * 35 | * Macro which declares a public symbol 36 | */ 37 | #define XMLPUBLIC 38 | 39 | /** 40 | * XMLCALL: 41 | * 42 | * Macro which declares the calling convention for exported functions 43 | */ 44 | #define XMLCALL 45 | 46 | /** 47 | * XMLCDECL: 48 | * 49 | * Macro which declares the calling convention for exported functions that 50 | * use '...'. 51 | */ 52 | #define XMLCDECL 53 | 54 | #endif /* platform switch */ 55 | 56 | /* 57 | * XMLPUBFUN: 58 | * 59 | * Macro which declares an exportable function 60 | */ 61 | #define XMLPUBFUN XMLPUBLIC 62 | 63 | /** 64 | * XMLPUBVAR: 65 | * 66 | * Macro which declares an exportable variable 67 | */ 68 | #define XMLPUBVAR XMLPUBLIC extern 69 | 70 | /* Compatibility */ 71 | #if !defined(LIBXML_DLL_IMPORT) 72 | #define LIBXML_DLL_IMPORT XMLPUBVAR 73 | #endif 74 | 75 | #endif /* __XML_EXPORTS_H__ */ 76 | 77 | 78 | -------------------------------------------------------------------------------- /lxml/includes/libxml/xmlmodule.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: dynamic module loading 3 | * Description: basic API for dynamic module loading, used by 4 | * libexslt added in 2.6.17 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Joel W. Reed 9 | */ 10 | 11 | #ifndef __XML_MODULE_H__ 12 | #define __XML_MODULE_H__ 13 | 14 | #include 15 | 16 | #ifdef LIBXML_MODULES_ENABLED 17 | 18 | #ifdef __cplusplus 19 | extern "C" { 20 | #endif 21 | 22 | /** 23 | * xmlModulePtr: 24 | * 25 | * A handle to a dynamically loaded module 26 | */ 27 | typedef struct _xmlModule xmlModule; 28 | typedef xmlModule *xmlModulePtr; 29 | 30 | /** 31 | * xmlModuleOption: 32 | * 33 | * enumeration of options that can be passed down to xmlModuleOpen() 34 | */ 35 | typedef enum { 36 | XML_MODULE_LAZY = 1, /* lazy binding */ 37 | XML_MODULE_LOCAL= 2 /* local binding */ 38 | } xmlModuleOption; 39 | 40 | XMLPUBFUN xmlModulePtr XMLCALL xmlModuleOpen (const char *filename, 41 | int options); 42 | 43 | XMLPUBFUN int XMLCALL xmlModuleSymbol (xmlModulePtr module, 44 | const char* name, 45 | void **result); 46 | 47 | XMLPUBFUN int XMLCALL xmlModuleClose (xmlModulePtr module); 48 | 49 | XMLPUBFUN int XMLCALL xmlModuleFree (xmlModulePtr module); 50 | 51 | #ifdef __cplusplus 52 | } 53 | #endif 54 | 55 | #endif /* LIBXML_MODULES_ENABLED */ 56 | 57 | #endif /*__XML_MODULE_H__ */ 58 | -------------------------------------------------------------------------------- /lxml/includes/libxml/xmlsave.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: the XML document serializer 3 | * Description: API to save document or subtree of document 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Daniel Veillard 8 | */ 9 | 10 | #ifndef __XML_XMLSAVE_H__ 11 | #define __XML_XMLSAVE_H__ 12 | 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #ifdef LIBXML_OUTPUT_ENABLED 19 | #ifdef __cplusplus 20 | extern "C" { 21 | #endif 22 | 23 | /** 24 | * xmlSaveOption: 25 | * 26 | * This is the set of XML save options that can be passed down 27 | * to the xmlSaveToFd() and similar calls. 28 | */ 29 | typedef enum { 30 | XML_SAVE_FORMAT = 1<<0, /* format save output */ 31 | XML_SAVE_NO_DECL = 1<<1, /* drop the xml declaration */ 32 | XML_SAVE_NO_EMPTY = 1<<2, /* no empty tags */ 33 | XML_SAVE_NO_XHTML = 1<<3, /* disable XHTML1 specific rules */ 34 | XML_SAVE_XHTML = 1<<4, /* force XHTML1 specific rules */ 35 | XML_SAVE_AS_XML = 1<<5, /* force XML serialization on HTML doc */ 36 | XML_SAVE_AS_HTML = 1<<6, /* force HTML serialization on XML doc */ 37 | XML_SAVE_WSNONSIG = 1<<7 /* format with non-significant whitespace */ 38 | } xmlSaveOption; 39 | 40 | 41 | typedef struct _xmlSaveCtxt xmlSaveCtxt; 42 | typedef xmlSaveCtxt *xmlSaveCtxtPtr; 43 | 44 | XMLPUBFUN xmlSaveCtxtPtr XMLCALL 45 | xmlSaveToFd (int fd, 46 | const char *encoding, 47 | int options); 48 | XMLPUBFUN xmlSaveCtxtPtr XMLCALL 49 | xmlSaveToFilename (const char *filename, 50 | const char *encoding, 51 | int options); 52 | 53 | XMLPUBFUN xmlSaveCtxtPtr XMLCALL 54 | xmlSaveToBuffer (xmlBufferPtr buffer, 55 | const char *encoding, 56 | int options); 57 | 58 | XMLPUBFUN xmlSaveCtxtPtr XMLCALL 59 | xmlSaveToIO (xmlOutputWriteCallback iowrite, 60 | xmlOutputCloseCallback ioclose, 61 | void *ioctx, 62 | const char *encoding, 63 | int options); 64 | 65 | XMLPUBFUN long XMLCALL 66 | xmlSaveDoc (xmlSaveCtxtPtr ctxt, 67 | xmlDocPtr doc); 68 | XMLPUBFUN long XMLCALL 69 | xmlSaveTree (xmlSaveCtxtPtr ctxt, 70 | xmlNodePtr node); 71 | 72 | XMLPUBFUN int XMLCALL 73 | xmlSaveFlush (xmlSaveCtxtPtr ctxt); 74 | XMLPUBFUN int XMLCALL 75 | xmlSaveClose (xmlSaveCtxtPtr ctxt); 76 | XMLPUBFUN int XMLCALL 77 | xmlSaveSetEscape (xmlSaveCtxtPtr ctxt, 78 | xmlCharEncodingOutputFunc escape); 79 | XMLPUBFUN int XMLCALL 80 | xmlSaveSetAttrEscape (xmlSaveCtxtPtr ctxt, 81 | xmlCharEncodingOutputFunc escape); 82 | #ifdef __cplusplus 83 | } 84 | #endif 85 | #endif /* LIBXML_OUTPUT_ENABLED */ 86 | #endif /* __XML_XMLSAVE_H__ */ 87 | 88 | 89 | -------------------------------------------------------------------------------- /lxml/includes/libxml/xmlschemastypes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: implementation of XML Schema Datatypes 3 | * Description: module providing the XML Schema Datatypes implementation 4 | * both definition and validity checking 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | 12 | #ifndef __XML_SCHEMA_TYPES_H__ 13 | #define __XML_SCHEMA_TYPES_H__ 14 | 15 | #include 16 | 17 | #ifdef LIBXML_SCHEMAS_ENABLED 18 | 19 | #include 20 | #include 21 | 22 | #ifdef __cplusplus 23 | extern "C" { 24 | #endif 25 | 26 | typedef enum { 27 | XML_SCHEMA_WHITESPACE_UNKNOWN = 0, 28 | XML_SCHEMA_WHITESPACE_PRESERVE = 1, 29 | XML_SCHEMA_WHITESPACE_REPLACE = 2, 30 | XML_SCHEMA_WHITESPACE_COLLAPSE = 3 31 | } xmlSchemaWhitespaceValueType; 32 | 33 | XMLPUBFUN void XMLCALL 34 | xmlSchemaInitTypes (void); 35 | XMLPUBFUN void XMLCALL 36 | xmlSchemaCleanupTypes (void); 37 | XMLPUBFUN xmlSchemaTypePtr XMLCALL 38 | xmlSchemaGetPredefinedType (const xmlChar *name, 39 | const xmlChar *ns); 40 | XMLPUBFUN int XMLCALL 41 | xmlSchemaValidatePredefinedType (xmlSchemaTypePtr type, 42 | const xmlChar *value, 43 | xmlSchemaValPtr *val); 44 | XMLPUBFUN int XMLCALL 45 | xmlSchemaValPredefTypeNode (xmlSchemaTypePtr type, 46 | const xmlChar *value, 47 | xmlSchemaValPtr *val, 48 | xmlNodePtr node); 49 | XMLPUBFUN int XMLCALL 50 | xmlSchemaValidateFacet (xmlSchemaTypePtr base, 51 | xmlSchemaFacetPtr facet, 52 | const xmlChar *value, 53 | xmlSchemaValPtr val); 54 | XMLPUBFUN int XMLCALL 55 | xmlSchemaValidateFacetWhtsp (xmlSchemaFacetPtr facet, 56 | xmlSchemaWhitespaceValueType fws, 57 | xmlSchemaValType valType, 58 | const xmlChar *value, 59 | xmlSchemaValPtr val, 60 | xmlSchemaWhitespaceValueType ws); 61 | XMLPUBFUN void XMLCALL 62 | xmlSchemaFreeValue (xmlSchemaValPtr val); 63 | XMLPUBFUN xmlSchemaFacetPtr XMLCALL 64 | xmlSchemaNewFacet (void); 65 | XMLPUBFUN int XMLCALL 66 | xmlSchemaCheckFacet (xmlSchemaFacetPtr facet, 67 | xmlSchemaTypePtr typeDecl, 68 | xmlSchemaParserCtxtPtr ctxt, 69 | const xmlChar *name); 70 | XMLPUBFUN void XMLCALL 71 | xmlSchemaFreeFacet (xmlSchemaFacetPtr facet); 72 | XMLPUBFUN int XMLCALL 73 | xmlSchemaCompareValues (xmlSchemaValPtr x, 74 | xmlSchemaValPtr y); 75 | XMLPUBFUN xmlSchemaTypePtr XMLCALL 76 | xmlSchemaGetBuiltInListSimpleTypeItemType (xmlSchemaTypePtr type); 77 | XMLPUBFUN int XMLCALL 78 | xmlSchemaValidateListSimpleTypeFacet (xmlSchemaFacetPtr facet, 79 | const xmlChar *value, 80 | unsigned long actualLen, 81 | unsigned long *expectedLen); 82 | XMLPUBFUN xmlSchemaTypePtr XMLCALL 83 | xmlSchemaGetBuiltInType (xmlSchemaValType type); 84 | XMLPUBFUN int XMLCALL 85 | xmlSchemaIsBuiltInTypeFacet (xmlSchemaTypePtr type, 86 | int facetType); 87 | XMLPUBFUN xmlChar * XMLCALL 88 | xmlSchemaCollapseString (const xmlChar *value); 89 | XMLPUBFUN xmlChar * XMLCALL 90 | xmlSchemaWhiteSpaceReplace (const xmlChar *value); 91 | XMLPUBFUN unsigned long XMLCALL 92 | xmlSchemaGetFacetValueAsULong (xmlSchemaFacetPtr facet); 93 | XMLPUBFUN int XMLCALL 94 | xmlSchemaValidateLengthFacet (xmlSchemaTypePtr type, 95 | xmlSchemaFacetPtr facet, 96 | const xmlChar *value, 97 | xmlSchemaValPtr val, 98 | unsigned long *length); 99 | XMLPUBFUN int XMLCALL 100 | xmlSchemaValidateLengthFacetWhtsp(xmlSchemaFacetPtr facet, 101 | xmlSchemaValType valType, 102 | const xmlChar *value, 103 | xmlSchemaValPtr val, 104 | unsigned long *length, 105 | xmlSchemaWhitespaceValueType ws); 106 | XMLPUBFUN int XMLCALL 107 | xmlSchemaValPredefTypeNodeNoNorm(xmlSchemaTypePtr type, 108 | const xmlChar *value, 109 | xmlSchemaValPtr *val, 110 | xmlNodePtr node); 111 | XMLPUBFUN int XMLCALL 112 | xmlSchemaGetCanonValue (xmlSchemaValPtr val, 113 | const xmlChar **retValue); 114 | XMLPUBFUN int XMLCALL 115 | xmlSchemaGetCanonValueWhtsp (xmlSchemaValPtr val, 116 | const xmlChar **retValue, 117 | xmlSchemaWhitespaceValueType ws); 118 | XMLPUBFUN int XMLCALL 119 | xmlSchemaValueAppend (xmlSchemaValPtr prev, 120 | xmlSchemaValPtr cur); 121 | XMLPUBFUN xmlSchemaValPtr XMLCALL 122 | xmlSchemaValueGetNext (xmlSchemaValPtr cur); 123 | XMLPUBFUN const xmlChar * XMLCALL 124 | xmlSchemaValueGetAsString (xmlSchemaValPtr val); 125 | XMLPUBFUN int XMLCALL 126 | xmlSchemaValueGetAsBoolean (xmlSchemaValPtr val); 127 | XMLPUBFUN xmlSchemaValPtr XMLCALL 128 | xmlSchemaNewStringValue (xmlSchemaValType type, 129 | const xmlChar *value); 130 | XMLPUBFUN xmlSchemaValPtr XMLCALL 131 | xmlSchemaNewNOTATIONValue (const xmlChar *name, 132 | const xmlChar *ns); 133 | XMLPUBFUN xmlSchemaValPtr XMLCALL 134 | xmlSchemaNewQNameValue (const xmlChar *namespaceName, 135 | const xmlChar *localName); 136 | XMLPUBFUN int XMLCALL 137 | xmlSchemaCompareValuesWhtsp (xmlSchemaValPtr x, 138 | xmlSchemaWhitespaceValueType xws, 139 | xmlSchemaValPtr y, 140 | xmlSchemaWhitespaceValueType yws); 141 | XMLPUBFUN xmlSchemaValPtr XMLCALL 142 | xmlSchemaCopyValue (xmlSchemaValPtr val); 143 | XMLPUBFUN xmlSchemaValType XMLCALL 144 | xmlSchemaGetValType (xmlSchemaValPtr val); 145 | 146 | #ifdef __cplusplus 147 | } 148 | #endif 149 | 150 | #endif /* LIBXML_SCHEMAS_ENABLED */ 151 | #endif /* __XML_SCHEMA_TYPES_H__ */ 152 | -------------------------------------------------------------------------------- /lxml/includes/libxml/xpointer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: API to handle XML Pointers 3 | * Description: API to handle XML Pointers 4 | * Base implementation was made accordingly to 5 | * W3C Candidate Recommendation 7 June 2000 6 | * http://www.w3.org/TR/2000/CR-xptr-20000607 7 | * 8 | * Added support for the element() scheme described in: 9 | * W3C Proposed Recommendation 13 November 2002 10 | * http://www.w3.org/TR/2002/PR-xptr-element-20021113/ 11 | * 12 | * Copy: See Copyright for the status of this software. 13 | * 14 | * Author: Daniel Veillard 15 | */ 16 | 17 | #ifndef __XML_XPTR_H__ 18 | #define __XML_XPTR_H__ 19 | 20 | #include 21 | 22 | #ifdef LIBXML_XPTR_ENABLED 23 | 24 | #include 25 | #include 26 | 27 | #ifdef __cplusplus 28 | extern "C" { 29 | #endif 30 | 31 | /* 32 | * A Location Set 33 | */ 34 | typedef struct _xmlLocationSet xmlLocationSet; 35 | typedef xmlLocationSet *xmlLocationSetPtr; 36 | struct _xmlLocationSet { 37 | int locNr; /* number of locations in the set */ 38 | int locMax; /* size of the array as allocated */ 39 | xmlXPathObjectPtr *locTab;/* array of locations */ 40 | }; 41 | 42 | /* 43 | * Handling of location sets. 44 | */ 45 | 46 | XMLPUBFUN xmlLocationSetPtr XMLCALL 47 | xmlXPtrLocationSetCreate (xmlXPathObjectPtr val); 48 | XMLPUBFUN void XMLCALL 49 | xmlXPtrFreeLocationSet (xmlLocationSetPtr obj); 50 | XMLPUBFUN xmlLocationSetPtr XMLCALL 51 | xmlXPtrLocationSetMerge (xmlLocationSetPtr val1, 52 | xmlLocationSetPtr val2); 53 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 54 | xmlXPtrNewRange (xmlNodePtr start, 55 | int startindex, 56 | xmlNodePtr end, 57 | int endindex); 58 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 59 | xmlXPtrNewRangePoints (xmlXPathObjectPtr start, 60 | xmlXPathObjectPtr end); 61 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 62 | xmlXPtrNewRangeNodePoint (xmlNodePtr start, 63 | xmlXPathObjectPtr end); 64 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 65 | xmlXPtrNewRangePointNode (xmlXPathObjectPtr start, 66 | xmlNodePtr end); 67 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 68 | xmlXPtrNewRangeNodes (xmlNodePtr start, 69 | xmlNodePtr end); 70 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 71 | xmlXPtrNewLocationSetNodes (xmlNodePtr start, 72 | xmlNodePtr end); 73 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 74 | xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set); 75 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 76 | xmlXPtrNewRangeNodeObject (xmlNodePtr start, 77 | xmlXPathObjectPtr end); 78 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 79 | xmlXPtrNewCollapsedRange (xmlNodePtr start); 80 | XMLPUBFUN void XMLCALL 81 | xmlXPtrLocationSetAdd (xmlLocationSetPtr cur, 82 | xmlXPathObjectPtr val); 83 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 84 | xmlXPtrWrapLocationSet (xmlLocationSetPtr val); 85 | XMLPUBFUN void XMLCALL 86 | xmlXPtrLocationSetDel (xmlLocationSetPtr cur, 87 | xmlXPathObjectPtr val); 88 | XMLPUBFUN void XMLCALL 89 | xmlXPtrLocationSetRemove (xmlLocationSetPtr cur, 90 | int val); 91 | 92 | /* 93 | * Functions. 94 | */ 95 | XMLPUBFUN xmlXPathContextPtr XMLCALL 96 | xmlXPtrNewContext (xmlDocPtr doc, 97 | xmlNodePtr here, 98 | xmlNodePtr origin); 99 | XMLPUBFUN xmlXPathObjectPtr XMLCALL 100 | xmlXPtrEval (const xmlChar *str, 101 | xmlXPathContextPtr ctx); 102 | XMLPUBFUN void XMLCALL 103 | xmlXPtrRangeToFunction (xmlXPathParserContextPtr ctxt, 104 | int nargs); 105 | XMLPUBFUN xmlNodePtr XMLCALL 106 | xmlXPtrBuildNodeList (xmlXPathObjectPtr obj); 107 | XMLPUBFUN void XMLCALL 108 | xmlXPtrEvalRangePredicate (xmlXPathParserContextPtr ctxt); 109 | #ifdef __cplusplus 110 | } 111 | #endif 112 | 113 | #endif /* LIBXML_XPTR_ENABLED */ 114 | #endif /* __XML_XPTR_H__ */ 115 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/libxslt/__init__.py -------------------------------------------------------------------------------- /lxml/includes/libxslt/__pycache__/__init__.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/includes/libxslt/__pycache__/__init__.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/includes/libxslt/attributes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the XSLT attribute handling 3 | * Description: this module handles the specificities of attribute 4 | * and attribute groups processing. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_XSLT_ATTRIBUTES_H__ 12 | #define __XML_XSLT_ATTRIBUTES_H__ 13 | 14 | #include 15 | #include "xsltexports.h" 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | XSLTPUBFUN void XSLTCALL 22 | xsltParseStylesheetAttributeSet (xsltStylesheetPtr style, 23 | xmlNodePtr cur); 24 | XSLTPUBFUN void XSLTCALL 25 | xsltFreeAttributeSetsHashes (xsltStylesheetPtr style); 26 | XSLTPUBFUN void XSLTCALL 27 | xsltApplyAttributeSet (xsltTransformContextPtr ctxt, 28 | xmlNodePtr node, 29 | xmlNodePtr inst, 30 | const xmlChar *attributes); 31 | XSLTPUBFUN void XSLTCALL 32 | xsltResolveStylesheetAttributeSet(xsltStylesheetPtr style); 33 | #ifdef __cplusplus 34 | } 35 | #endif 36 | 37 | #endif /* __XML_XSLT_ATTRIBUTES_H__ */ 38 | 39 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/documents.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the document handling 3 | * Description: implements document loading and cache (multiple 4 | * document() reference for the same resources must 5 | * be equal. 6 | * 7 | * Copy: See Copyright for the status of this software. 8 | * 9 | * Author: Daniel Veillard 10 | */ 11 | 12 | #ifndef __XML_XSLT_DOCUMENTS_H__ 13 | #define __XML_XSLT_DOCUMENTS_H__ 14 | 15 | #include 16 | #include "xsltexports.h" 17 | #include "xsltInternals.h" 18 | 19 | #ifdef __cplusplus 20 | extern "C" { 21 | #endif 22 | 23 | XSLTPUBFUN xsltDocumentPtr XSLTCALL 24 | xsltNewDocument (xsltTransformContextPtr ctxt, 25 | xmlDocPtr doc); 26 | XSLTPUBFUN xsltDocumentPtr XSLTCALL 27 | xsltLoadDocument (xsltTransformContextPtr ctxt, 28 | const xmlChar *URI); 29 | XSLTPUBFUN xsltDocumentPtr XSLTCALL 30 | xsltFindDocument (xsltTransformContextPtr ctxt, 31 | xmlDocPtr doc); 32 | XSLTPUBFUN void XSLTCALL 33 | xsltFreeDocuments (xsltTransformContextPtr ctxt); 34 | 35 | XSLTPUBFUN xsltDocumentPtr XSLTCALL 36 | xsltLoadStyleDocument (xsltStylesheetPtr style, 37 | const xmlChar *URI); 38 | XSLTPUBFUN xsltDocumentPtr XSLTCALL 39 | xsltNewStyleDocument (xsltStylesheetPtr style, 40 | xmlDocPtr doc); 41 | XSLTPUBFUN void XSLTCALL 42 | xsltFreeStyleDocuments (xsltStylesheetPtr style); 43 | 44 | /* 45 | * Hooks for document loading 46 | */ 47 | 48 | /** 49 | * xsltLoadType: 50 | * 51 | * Enum defining the kind of loader requirement. 52 | */ 53 | typedef enum { 54 | XSLT_LOAD_START = 0, /* loading for a top stylesheet */ 55 | XSLT_LOAD_STYLESHEET = 1, /* loading for a stylesheet include/import */ 56 | XSLT_LOAD_DOCUMENT = 2 /* loading document at transformation time */ 57 | } xsltLoadType; 58 | 59 | /** 60 | * xsltDocLoaderFunc: 61 | * @URI: the URI of the document to load 62 | * @dict: the dictionary to use when parsing that document 63 | * @options: parsing options, a set of xmlParserOption 64 | * @ctxt: the context, either a stylesheet or a transformation context 65 | * @type: the xsltLoadType indicating the kind of loading required 66 | * 67 | * An xsltDocLoaderFunc is a signature for a function which can be 68 | * registered to load document not provided by the compilation or 69 | * transformation API themselve, for example when an xsl:import, 70 | * xsl:include is found at compilation time or when a document() 71 | * call is made at runtime. 72 | * 73 | * Returns the pointer to the document (which will be modified and 74 | * freed by the engine later), or NULL in case of error. 75 | */ 76 | typedef xmlDocPtr (*xsltDocLoaderFunc) (const xmlChar *URI, 77 | xmlDictPtr dict, 78 | int options, 79 | void *ctxt, 80 | xsltLoadType type); 81 | 82 | XSLTPUBFUN void XSLTCALL 83 | xsltSetLoaderFunc (xsltDocLoaderFunc f); 84 | 85 | /* the loader may be needed by extension libraries so it is exported */ 86 | XSLTPUBVAR xsltDocLoaderFunc xsltDocDefaultLoader; 87 | 88 | #ifdef __cplusplus 89 | } 90 | #endif 91 | 92 | #endif /* __XML_XSLT_DOCUMENTS_H__ */ 93 | 94 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/extra.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the non-standard features 3 | * Description: implement some extension outside the XSLT namespace 4 | * but not EXSLT with is in a different library. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_XSLT_EXTRA_H__ 12 | #define __XML_XSLT_EXTRA_H__ 13 | 14 | #include 15 | #include "xsltexports.h" 16 | #include "xsltInternals.h" 17 | 18 | #ifdef __cplusplus 19 | extern "C" { 20 | #endif 21 | 22 | /** 23 | * XSLT_LIBXSLT_NAMESPACE: 24 | * 25 | * This is the libxslt namespace for specific extensions. 26 | */ 27 | #define XSLT_LIBXSLT_NAMESPACE ((xmlChar *) "http://xmlsoft.org/XSLT/namespace") 28 | 29 | /** 30 | * XSLT_SAXON_NAMESPACE: 31 | * 32 | * This is Michael Kay's Saxon processor namespace for extensions. 33 | */ 34 | #define XSLT_SAXON_NAMESPACE ((xmlChar *) "http://icl.com/saxon") 35 | 36 | /** 37 | * XSLT_XT_NAMESPACE: 38 | * 39 | * This is James Clark's XT processor namespace for extensions. 40 | */ 41 | #define XSLT_XT_NAMESPACE ((xmlChar *) "http://www.jclark.com/xt") 42 | 43 | /** 44 | * XSLT_XALAN_NAMESPACE: 45 | * 46 | * This is the Apache project XALAN processor namespace for extensions. 47 | */ 48 | #define XSLT_XALAN_NAMESPACE ((xmlChar *) \ 49 | "org.apache.xalan.xslt.extensions.Redirect") 50 | 51 | 52 | XSLTPUBFUN void XSLTCALL 53 | xsltFunctionNodeSet (xmlXPathParserContextPtr ctxt, 54 | int nargs); 55 | XSLTPUBFUN void XSLTCALL 56 | xsltDebug (xsltTransformContextPtr ctxt, 57 | xmlNodePtr node, 58 | xmlNodePtr inst, 59 | xsltElemPreCompPtr comp); 60 | 61 | 62 | XSLTPUBFUN void XSLTCALL 63 | xsltRegisterExtras (xsltTransformContextPtr ctxt); 64 | XSLTPUBFUN void XSLTCALL 65 | xsltRegisterAllExtras (void); 66 | 67 | #ifdef __cplusplus 68 | } 69 | #endif 70 | 71 | #endif /* __XML_XSLT_EXTRA_H__ */ 72 | 73 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/functions.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the XSLT functions not from XPath 3 | * Description: a set of extra functions coming from XSLT but not in XPath 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Daniel Veillard and Bjorn Reese 8 | */ 9 | 10 | #ifndef __XML_XSLT_FUNCTIONS_H__ 11 | #define __XML_XSLT_FUNCTIONS_H__ 12 | 13 | #include 14 | #include 15 | #include "xsltexports.h" 16 | #include "xsltInternals.h" 17 | 18 | #ifdef __cplusplus 19 | extern "C" { 20 | #endif 21 | 22 | /** 23 | * XSLT_REGISTER_FUNCTION_LOOKUP: 24 | * 25 | * Registering macro, not general purpose at all but used in different modules. 26 | */ 27 | #define XSLT_REGISTER_FUNCTION_LOOKUP(ctxt) \ 28 | xmlXPathRegisterFuncLookup((ctxt)->xpathCtxt, \ 29 | xsltXPathFunctionLookup, \ 30 | (void *)(ctxt->xpathCtxt)); 31 | 32 | XSLTPUBFUN xmlXPathFunction XSLTCALL 33 | xsltXPathFunctionLookup (void *vctxt, 34 | const xmlChar *name, 35 | const xmlChar *ns_uri); 36 | 37 | /* 38 | * Interfaces for the functions implementations. 39 | */ 40 | 41 | XSLTPUBFUN void XSLTCALL 42 | xsltDocumentFunction (xmlXPathParserContextPtr ctxt, 43 | int nargs); 44 | XSLTPUBFUN void XSLTCALL 45 | xsltKeyFunction (xmlXPathParserContextPtr ctxt, 46 | int nargs); 47 | XSLTPUBFUN void XSLTCALL 48 | xsltUnparsedEntityURIFunction (xmlXPathParserContextPtr ctxt, 49 | int nargs); 50 | XSLTPUBFUN void XSLTCALL 51 | xsltFormatNumberFunction (xmlXPathParserContextPtr ctxt, 52 | int nargs); 53 | XSLTPUBFUN void XSLTCALL 54 | xsltGenerateIdFunction (xmlXPathParserContextPtr ctxt, 55 | int nargs); 56 | XSLTPUBFUN void XSLTCALL 57 | xsltSystemPropertyFunction (xmlXPathParserContextPtr ctxt, 58 | int nargs); 59 | XSLTPUBFUN void XSLTCALL 60 | xsltElementAvailableFunction (xmlXPathParserContextPtr ctxt, 61 | int nargs); 62 | XSLTPUBFUN void XSLTCALL 63 | xsltFunctionAvailableFunction (xmlXPathParserContextPtr ctxt, 64 | int nargs); 65 | 66 | /* 67 | * And the registration 68 | */ 69 | 70 | XSLTPUBFUN void XSLTCALL 71 | xsltRegisterAllFunctions (xmlXPathContextPtr ctxt); 72 | 73 | #ifdef __cplusplus 74 | } 75 | #endif 76 | 77 | #endif /* __XML_XSLT_FUNCTIONS_H__ */ 78 | 79 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/imports.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the XSLT import support 3 | * Description: macros and fuctions needed to implement and 4 | * access the import tree 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_XSLT_IMPORTS_H__ 12 | #define __XML_XSLT_IMPORTS_H__ 13 | 14 | #include 15 | #include "xsltexports.h" 16 | #include "xsltInternals.h" 17 | 18 | #ifdef __cplusplus 19 | extern "C" { 20 | #endif 21 | 22 | /** 23 | * XSLT_GET_IMPORT_PTR: 24 | * 25 | * A macro to import pointers from the stylesheet cascading order. 26 | */ 27 | #define XSLT_GET_IMPORT_PTR(res, style, name) { \ 28 | xsltStylesheetPtr st = style; \ 29 | res = NULL; \ 30 | while (st != NULL) { \ 31 | if (st->name != NULL) { res = st->name; break; } \ 32 | st = xsltNextImport(st); \ 33 | }} 34 | 35 | /** 36 | * XSLT_GET_IMPORT_INT: 37 | * 38 | * A macro to import intergers from the stylesheet cascading order. 39 | */ 40 | #define XSLT_GET_IMPORT_INT(res, style, name) { \ 41 | xsltStylesheetPtr st = style; \ 42 | res = -1; \ 43 | while (st != NULL) { \ 44 | if (st->name != -1) { res = st->name; break; } \ 45 | st = xsltNextImport(st); \ 46 | }} 47 | 48 | /* 49 | * Module interfaces 50 | */ 51 | XSLTPUBFUN int XSLTCALL 52 | xsltParseStylesheetImport(xsltStylesheetPtr style, 53 | xmlNodePtr cur); 54 | XSLTPUBFUN int XSLTCALL 55 | xsltParseStylesheetInclude 56 | (xsltStylesheetPtr style, 57 | xmlNodePtr cur); 58 | XSLTPUBFUN xsltStylesheetPtr XSLTCALL 59 | xsltNextImport (xsltStylesheetPtr style); 60 | XSLTPUBFUN int XSLTCALL 61 | xsltNeedElemSpaceHandling(xsltTransformContextPtr ctxt); 62 | XSLTPUBFUN int XSLTCALL 63 | xsltFindElemSpaceHandling(xsltTransformContextPtr ctxt, 64 | xmlNodePtr node); 65 | XSLTPUBFUN xsltTemplatePtr XSLTCALL 66 | xsltFindTemplate (xsltTransformContextPtr ctxt, 67 | const xmlChar *name, 68 | const xmlChar *nameURI); 69 | 70 | #ifdef __cplusplus 71 | } 72 | #endif 73 | 74 | #endif /* __XML_XSLT_IMPORTS_H__ */ 75 | 76 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/keys.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the key matching used in key() and template matches. 3 | * Description: implementation of the key mechanims. 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Daniel Veillard 8 | */ 9 | 10 | #ifndef __XML_XSLT_KEY_H__ 11 | #define __XML_XSLT_KEY_H__ 12 | 13 | #include 14 | #include "xsltexports.h" 15 | #include "xsltInternals.h" 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | /** 22 | * NODE_IS_KEYED: 23 | * 24 | * check for bit 15 set 25 | */ 26 | #define NODE_IS_KEYED (1 >> 15) 27 | 28 | XSLTPUBFUN int XSLTCALL 29 | xsltAddKey (xsltStylesheetPtr style, 30 | const xmlChar *name, 31 | const xmlChar *nameURI, 32 | const xmlChar *match, 33 | const xmlChar *use, 34 | xmlNodePtr inst); 35 | XSLTPUBFUN xmlNodeSetPtr XSLTCALL 36 | xsltGetKey (xsltTransformContextPtr ctxt, 37 | const xmlChar *name, 38 | const xmlChar *nameURI, 39 | const xmlChar *value); 40 | XSLTPUBFUN void XSLTCALL 41 | xsltInitCtxtKeys (xsltTransformContextPtr ctxt, 42 | xsltDocumentPtr doc); 43 | XSLTPUBFUN void XSLTCALL 44 | xsltFreeKeys (xsltStylesheetPtr style); 45 | XSLTPUBFUN void XSLTCALL 46 | xsltFreeDocumentKeys (xsltDocumentPtr doc); 47 | 48 | #ifdef __cplusplus 49 | } 50 | #endif 51 | 52 | #endif /* __XML_XSLT_H__ */ 53 | 54 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/libxslt.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: internal header only used during the compilation of libxslt 3 | * Description: internal header only used during the compilation of libxslt 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Daniel Veillard 8 | */ 9 | 10 | #ifndef __XSLT_LIBXSLT_H__ 11 | #define __XSLT_LIBXSLT_H__ 12 | 13 | #if defined(_WIN32) && !defined (__CYGWIN__) && !defined (__MINGW32__) 14 | #include 15 | #else 16 | #include "config.h" 17 | #endif 18 | 19 | #include 20 | #include 21 | 22 | #if !defined LIBXSLT_PUBLIC 23 | #if (defined (__CYGWIN__) || defined _MSC_VER) && !defined IN_LIBXSLT && !defined LIBXSLT_STATIC 24 | #define LIBXSLT_PUBLIC __declspec(dllimport) 25 | #else 26 | #define LIBXSLT_PUBLIC 27 | #endif 28 | #endif 29 | 30 | #if defined(_MSC_VER) || defined(__MINGW32__) 31 | #include 32 | #include 33 | #define mkdir(p,m) _mkdir(p) 34 | #endif 35 | 36 | #endif /* ! __XSLT_LIBXSLT_H__ */ 37 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/namespaces.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the XSLT namespace handling 3 | * Description: set of function easing the processing and generation 4 | * of namespace nodes in XSLT. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_XSLT_NAMESPACES_H__ 12 | #define __XML_XSLT_NAMESPACES_H__ 13 | 14 | #include 15 | #include "xsltexports.h" 16 | 17 | #ifdef __cplusplus 18 | extern "C" { 19 | #endif 20 | 21 | /* 22 | * Used within nsAliases hashtable when the default namespace is required 23 | * but it's not been explicitly defined 24 | */ 25 | /** 26 | * UNDEFINED_DEFAULT_NS: 27 | * 28 | * Special value for undefined namespace, internal 29 | */ 30 | #define UNDEFINED_DEFAULT_NS (const xmlChar *) -1L 31 | 32 | XSLTPUBFUN void XSLTCALL 33 | xsltNamespaceAlias (xsltStylesheetPtr style, 34 | xmlNodePtr node); 35 | XSLTPUBFUN xmlNsPtr XSLTCALL 36 | xsltGetNamespace (xsltTransformContextPtr ctxt, 37 | xmlNodePtr cur, 38 | xmlNsPtr ns, 39 | xmlNodePtr out); 40 | XSLTPUBFUN xmlNsPtr XSLTCALL 41 | xsltGetPlainNamespace (xsltTransformContextPtr ctxt, 42 | xmlNodePtr cur, 43 | xmlNsPtr ns, 44 | xmlNodePtr out); 45 | XSLTPUBFUN xmlNsPtr XSLTCALL 46 | xsltGetSpecialNamespace (xsltTransformContextPtr ctxt, 47 | xmlNodePtr cur, 48 | const xmlChar *URI, 49 | const xmlChar *prefix, 50 | xmlNodePtr out); 51 | XSLTPUBFUN xmlNsPtr XSLTCALL 52 | xsltCopyNamespace (xsltTransformContextPtr ctxt, 53 | xmlNodePtr elem, 54 | xmlNsPtr ns); 55 | XSLTPUBFUN xmlNsPtr XSLTCALL 56 | xsltCopyNamespaceList (xsltTransformContextPtr ctxt, 57 | xmlNodePtr node, 58 | xmlNsPtr cur); 59 | XSLTPUBFUN void XSLTCALL 60 | xsltFreeNamespaceAliasHashes 61 | (xsltStylesheetPtr style); 62 | 63 | #ifdef __cplusplus 64 | } 65 | #endif 66 | 67 | #endif /* __XML_XSLT_NAMESPACES_H__ */ 68 | 69 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/numbersInternals.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: Implementation of the XSLT number functions 3 | * Description: Implementation of the XSLT number functions 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Bjorn Reese and Daniel Veillard 8 | */ 9 | 10 | #ifndef __XML_XSLT_NUMBERSINTERNALS_H__ 11 | #define __XML_XSLT_NUMBERSINTERNALS_H__ 12 | 13 | #include 14 | #include "xsltexports.h" 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | struct _xsltCompMatch; 21 | 22 | /** 23 | * xsltNumberData: 24 | * 25 | * This data structure is just a wrapper to pass xsl:number data in. 26 | */ 27 | typedef struct _xsltNumberData xsltNumberData; 28 | typedef xsltNumberData *xsltNumberDataPtr; 29 | 30 | struct _xsltNumberData { 31 | const xmlChar *level; 32 | const xmlChar *count; 33 | const xmlChar *from; 34 | const xmlChar *value; 35 | const xmlChar *format; 36 | int has_format; 37 | int digitsPerGroup; 38 | int groupingCharacter; 39 | int groupingCharacterLen; 40 | xmlDocPtr doc; 41 | xmlNodePtr node; 42 | struct _xsltCompMatch *countPat; 43 | struct _xsltCompMatch *fromPat; 44 | 45 | /* 46 | * accelerators 47 | */ 48 | }; 49 | 50 | /** 51 | * xsltFormatNumberInfo,: 52 | * 53 | * This data structure lists the various parameters needed to format numbers. 54 | */ 55 | typedef struct _xsltFormatNumberInfo xsltFormatNumberInfo; 56 | typedef xsltFormatNumberInfo *xsltFormatNumberInfoPtr; 57 | 58 | struct _xsltFormatNumberInfo { 59 | int integer_hash; /* Number of '#' in integer part */ 60 | int integer_digits; /* Number of '0' in integer part */ 61 | int frac_digits; /* Number of '0' in fractional part */ 62 | int frac_hash; /* Number of '#' in fractional part */ 63 | int group; /* Number of chars per display 'group' */ 64 | int multiplier; /* Scaling for percent or permille */ 65 | char add_decimal; /* Flag for whether decimal point appears in pattern */ 66 | char is_multiplier_set; /* Flag to catch multiple occurences of percent/permille */ 67 | char is_negative_pattern;/* Flag for processing -ve prefix/suffix */ 68 | }; 69 | 70 | #ifdef __cplusplus 71 | } 72 | #endif 73 | #endif /* __XML_XSLT_NUMBERSINTERNALS_H__ */ 74 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/preproc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: precomputing stylesheets 3 | * Description: this is the compilation phase, where most of the 4 | * stylesheet is "compiled" into faster to use data. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_XSLT_PRECOMP_H__ 12 | #define __XML_XSLT_PRECOMP_H__ 13 | 14 | #include 15 | #include "xsltexports.h" 16 | #include "xsltInternals.h" 17 | 18 | #ifdef __cplusplus 19 | extern "C" { 20 | #endif 21 | 22 | /* 23 | * Interfaces 24 | */ 25 | extern const xmlChar *xsltExtMarker; 26 | 27 | XSLTPUBFUN xsltElemPreCompPtr XSLTCALL 28 | xsltDocumentComp (xsltStylesheetPtr style, 29 | xmlNodePtr inst, 30 | xsltTransformFunction function); 31 | 32 | XSLTPUBFUN void XSLTCALL 33 | xsltStylePreCompute (xsltStylesheetPtr style, 34 | xmlNodePtr inst); 35 | XSLTPUBFUN void XSLTCALL 36 | xsltFreeStylePreComps (xsltStylesheetPtr style); 37 | 38 | #ifdef __cplusplus 39 | } 40 | #endif 41 | 42 | #endif /* __XML_XSLT_PRECOMP_H__ */ 43 | 44 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/security.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the libxslt security framework 3 | * Description: the libxslt security framework allow to restrict 4 | * the access to new resources (file or URL) from 5 | * the stylesheet at runtime. 6 | * 7 | * Copy: See Copyright for the status of this software. 8 | * 9 | * Author: Daniel Veillard 10 | */ 11 | 12 | #ifndef __XML_XSLT_SECURITY_H__ 13 | #define __XML_XSLT_SECURITY_H__ 14 | 15 | #include 16 | #include "xsltexports.h" 17 | #include "xsltInternals.h" 18 | 19 | #ifdef __cplusplus 20 | extern "C" { 21 | #endif 22 | 23 | /** 24 | * xsltSecurityPref: 25 | * 26 | * structure to indicate the preferences for security in the XSLT 27 | * transformation. 28 | */ 29 | typedef struct _xsltSecurityPrefs xsltSecurityPrefs; 30 | typedef xsltSecurityPrefs *xsltSecurityPrefsPtr; 31 | 32 | /** 33 | * xsltSecurityOption: 34 | * 35 | * the set of option that can be configured 36 | */ 37 | typedef enum { 38 | XSLT_SECPREF_READ_FILE = 1, 39 | XSLT_SECPREF_WRITE_FILE, 40 | XSLT_SECPREF_CREATE_DIRECTORY, 41 | XSLT_SECPREF_READ_NETWORK, 42 | XSLT_SECPREF_WRITE_NETWORK 43 | } xsltSecurityOption; 44 | 45 | /** 46 | * xsltSecurityCheck: 47 | * 48 | * User provided function to check the value of a string like a file 49 | * path or an URL ... 50 | */ 51 | typedef int (*xsltSecurityCheck) (xsltSecurityPrefsPtr sec, 52 | xsltTransformContextPtr ctxt, 53 | const char *value); 54 | 55 | /* 56 | * Module interfaces 57 | */ 58 | XSLTPUBFUN xsltSecurityPrefsPtr XSLTCALL 59 | xsltNewSecurityPrefs (void); 60 | XSLTPUBFUN void XSLTCALL 61 | xsltFreeSecurityPrefs (xsltSecurityPrefsPtr sec); 62 | XSLTPUBFUN int XSLTCALL 63 | xsltSetSecurityPrefs (xsltSecurityPrefsPtr sec, 64 | xsltSecurityOption option, 65 | xsltSecurityCheck func); 66 | XSLTPUBFUN xsltSecurityCheck XSLTCALL 67 | xsltGetSecurityPrefs (xsltSecurityPrefsPtr sec, 68 | xsltSecurityOption option); 69 | 70 | XSLTPUBFUN void XSLTCALL 71 | xsltSetDefaultSecurityPrefs (xsltSecurityPrefsPtr sec); 72 | XSLTPUBFUN xsltSecurityPrefsPtr XSLTCALL 73 | xsltGetDefaultSecurityPrefs (void); 74 | 75 | XSLTPUBFUN int XSLTCALL 76 | xsltSetCtxtSecurityPrefs (xsltSecurityPrefsPtr sec, 77 | xsltTransformContextPtr ctxt); 78 | 79 | XSLTPUBFUN int XSLTCALL 80 | xsltSecurityAllow (xsltSecurityPrefsPtr sec, 81 | xsltTransformContextPtr ctxt, 82 | const char *value); 83 | XSLTPUBFUN int XSLTCALL 84 | xsltSecurityForbid (xsltSecurityPrefsPtr sec, 85 | xsltTransformContextPtr ctxt, 86 | const char *value); 87 | /* 88 | * internal interfaces 89 | */ 90 | XSLTPUBFUN int XSLTCALL 91 | xsltCheckWrite (xsltSecurityPrefsPtr sec, 92 | xsltTransformContextPtr ctxt, 93 | const xmlChar *URL); 94 | XSLTPUBFUN int XSLTCALL 95 | xsltCheckRead (xsltSecurityPrefsPtr sec, 96 | xsltTransformContextPtr ctxt, 97 | const xmlChar *URL); 98 | 99 | #ifdef __cplusplus 100 | } 101 | #endif 102 | 103 | #endif /* __XML_XSLT_SECURITY_H__ */ 104 | 105 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/templates.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the template processing 3 | * Description: This set of routine encapsulates XPath calls 4 | * and Attribute Value Templates evaluation. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_XSLT_TEMPLATES_H__ 12 | #define __XML_XSLT_TEMPLATES_H__ 13 | 14 | #include 15 | #include 16 | #include "xsltexports.h" 17 | #include "xsltInternals.h" 18 | 19 | #ifdef __cplusplus 20 | extern "C" { 21 | #endif 22 | 23 | XSLTPUBFUN int XSLTCALL 24 | xsltEvalXPathPredicate (xsltTransformContextPtr ctxt, 25 | xmlXPathCompExprPtr comp, 26 | xmlNsPtr *nsList, 27 | int nsNr); 28 | XSLTPUBFUN xmlChar * XSLTCALL 29 | xsltEvalTemplateString (xsltTransformContextPtr ctxt, 30 | xmlNodePtr contextNode, 31 | xmlNodePtr inst); 32 | XSLTPUBFUN xmlChar * XSLTCALL 33 | xsltEvalAttrValueTemplate (xsltTransformContextPtr ctxt, 34 | xmlNodePtr node, 35 | const xmlChar *name, 36 | const xmlChar *ns); 37 | XSLTPUBFUN const xmlChar * XSLTCALL 38 | xsltEvalStaticAttrValueTemplate (xsltStylesheetPtr style, 39 | xmlNodePtr node, 40 | const xmlChar *name, 41 | const xmlChar *ns, 42 | int *found); 43 | 44 | /* TODO: this is obviously broken ... the namespaces should be passed too ! */ 45 | XSLTPUBFUN xmlChar * XSLTCALL 46 | xsltEvalXPathString (xsltTransformContextPtr ctxt, 47 | xmlXPathCompExprPtr comp); 48 | XSLTPUBFUN xmlChar * XSLTCALL 49 | xsltEvalXPathStringNs (xsltTransformContextPtr ctxt, 50 | xmlXPathCompExprPtr comp, 51 | int nsNr, 52 | xmlNsPtr *nsList); 53 | 54 | XSLTPUBFUN xmlNodePtr * XSLTCALL 55 | xsltTemplateProcess (xsltTransformContextPtr ctxt, 56 | xmlNodePtr node); 57 | XSLTPUBFUN xmlAttrPtr XSLTCALL 58 | xsltAttrListTemplateProcess (xsltTransformContextPtr ctxt, 59 | xmlNodePtr target, 60 | xmlAttrPtr cur); 61 | XSLTPUBFUN xmlAttrPtr XSLTCALL 62 | xsltAttrTemplateProcess (xsltTransformContextPtr ctxt, 63 | xmlNodePtr target, 64 | xmlAttrPtr attr); 65 | XSLTPUBFUN xmlChar * XSLTCALL 66 | xsltAttrTemplateValueProcess (xsltTransformContextPtr ctxt, 67 | const xmlChar* attr); 68 | XSLTPUBFUN xmlChar * XSLTCALL 69 | xsltAttrTemplateValueProcessNode(xsltTransformContextPtr ctxt, 70 | const xmlChar* str, 71 | xmlNodePtr node); 72 | #ifdef __cplusplus 73 | } 74 | #endif 75 | 76 | #endif /* __XML_XSLT_TEMPLATES_H__ */ 77 | 78 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/variables.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: interface for the variable matching and lookup. 3 | * Description: interface for the variable matching and lookup. 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Daniel Veillard 8 | */ 9 | 10 | #ifndef __XML_XSLT_VARIABLES_H__ 11 | #define __XML_XSLT_VARIABLES_H__ 12 | 13 | #include 14 | #include 15 | #include "xsltexports.h" 16 | #include "xsltInternals.h" 17 | #include "functions.h" 18 | 19 | #ifdef __cplusplus 20 | extern "C" { 21 | #endif 22 | 23 | 24 | /** 25 | * XSLT_REGISTER_VARIABLE_LOOKUP: 26 | * 27 | * Registering macro, not general purpose at all but used in different modules. 28 | */ 29 | 30 | #define XSLT_REGISTER_VARIABLE_LOOKUP(ctxt) \ 31 | xmlXPathRegisterVariableLookup((ctxt)->xpathCtxt, \ 32 | xsltXPathVariableLookup, (void *)(ctxt)); \ 33 | xsltRegisterAllFunctions((ctxt)->xpathCtxt); \ 34 | xsltRegisterAllElement(ctxt); \ 35 | (ctxt)->xpathCtxt->extra = ctxt 36 | 37 | /* 38 | * Flags for memory management of RVTs 39 | */ 40 | 41 | /** 42 | * XSLT_RVT_LOCAL: 43 | * 44 | * RVT is destroyed after the current instructions ends. 45 | */ 46 | #define XSLT_RVT_LOCAL ((void *)1) 47 | 48 | /** 49 | * XSLT_RVT_FUNC_RESULT: 50 | * 51 | * RVT is part of results returned with func:result. The RVT won't be 52 | * destroyed after exiting a template and will be reset to XSLT_RVT_LOCAL or 53 | * XSLT_RVT_VARIABLE in the template that receives the return value. 54 | */ 55 | #define XSLT_RVT_FUNC_RESULT ((void *)2) 56 | 57 | /** 58 | * XSLT_RVT_GLOBAL: 59 | * 60 | * RVT is part of a global variable. 61 | */ 62 | #define XSLT_RVT_GLOBAL ((void *)3) 63 | 64 | /* 65 | * Interfaces for the variable module. 66 | */ 67 | 68 | XSLTPUBFUN int XSLTCALL 69 | xsltEvalGlobalVariables (xsltTransformContextPtr ctxt); 70 | XSLTPUBFUN int XSLTCALL 71 | xsltEvalUserParams (xsltTransformContextPtr ctxt, 72 | const char **params); 73 | XSLTPUBFUN int XSLTCALL 74 | xsltQuoteUserParams (xsltTransformContextPtr ctxt, 75 | const char **params); 76 | XSLTPUBFUN int XSLTCALL 77 | xsltEvalOneUserParam (xsltTransformContextPtr ctxt, 78 | const xmlChar * name, 79 | const xmlChar * value); 80 | XSLTPUBFUN int XSLTCALL 81 | xsltQuoteOneUserParam (xsltTransformContextPtr ctxt, 82 | const xmlChar * name, 83 | const xmlChar * value); 84 | 85 | XSLTPUBFUN void XSLTCALL 86 | xsltParseGlobalVariable (xsltStylesheetPtr style, 87 | xmlNodePtr cur); 88 | XSLTPUBFUN void XSLTCALL 89 | xsltParseGlobalParam (xsltStylesheetPtr style, 90 | xmlNodePtr cur); 91 | XSLTPUBFUN void XSLTCALL 92 | xsltParseStylesheetVariable (xsltTransformContextPtr ctxt, 93 | xmlNodePtr cur); 94 | XSLTPUBFUN void XSLTCALL 95 | xsltParseStylesheetParam (xsltTransformContextPtr ctxt, 96 | xmlNodePtr cur); 97 | XSLTPUBFUN xsltStackElemPtr XSLTCALL 98 | xsltParseStylesheetCallerParam (xsltTransformContextPtr ctxt, 99 | xmlNodePtr cur); 100 | XSLTPUBFUN int XSLTCALL 101 | xsltAddStackElemList (xsltTransformContextPtr ctxt, 102 | xsltStackElemPtr elems); 103 | XSLTPUBFUN void XSLTCALL 104 | xsltFreeGlobalVariables (xsltTransformContextPtr ctxt); 105 | XSLTPUBFUN xmlXPathObjectPtr XSLTCALL 106 | xsltVariableLookup (xsltTransformContextPtr ctxt, 107 | const xmlChar *name, 108 | const xmlChar *ns_uri); 109 | XSLTPUBFUN xmlXPathObjectPtr XSLTCALL 110 | xsltXPathVariableLookup (void *ctxt, 111 | const xmlChar *name, 112 | const xmlChar *ns_uri); 113 | #ifdef __cplusplus 114 | } 115 | #endif 116 | 117 | #endif /* __XML_XSLT_VARIABLES_H__ */ 118 | 119 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/win32config.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: Windows configuration header 3 | * Description: Windows configuration header 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Igor Zlatkovic 8 | */ 9 | #ifndef __LIBXSLT_WIN32_CONFIG__ 10 | #define __LIBXSLT_WIN32_CONFIG__ 11 | 12 | #define HAVE_CTYPE_H 1 13 | #define HAVE_STDLIB_H 1 14 | #define HAVE_STDARG_H 1 15 | #define HAVE_MALLOC_H 1 16 | #define HAVE_TIME_H 1 17 | #define HAVE_LOCALTIME 1 18 | #define HAVE_GMTIME 1 19 | #define HAVE_TIME 1 20 | #define HAVE_MATH_H 1 21 | #define HAVE_FCNTL_H 1 22 | 23 | #include 24 | 25 | #define HAVE_ISINF 26 | #define HAVE_ISNAN 27 | 28 | #include 29 | #if defined _MSC_VER || defined __MINGW32__ 30 | /* MS C-runtime has functions which can be used in order to determine if 31 | a given floating-point variable contains NaN, (+-)INF. These are 32 | preferred, because floating-point technology is considered propriatary 33 | by MS and we can assume that their functions know more about their 34 | oddities than we do. */ 35 | #include 36 | /* Bjorn Reese figured a quite nice construct for isinf() using the 37 | _fpclass() function. */ 38 | #ifndef isinf 39 | #define isinf(d) ((_fpclass(d) == _FPCLASS_PINF) ? 1 \ 40 | : ((_fpclass(d) == _FPCLASS_NINF) ? -1 : 0)) 41 | #endif 42 | /* _isnan(x) returns nonzero if (x == NaN) and zero otherwise. */ 43 | #ifndef isnan 44 | #define isnan(d) (_isnan(d)) 45 | #endif 46 | #else /* _MSC_VER */ 47 | static int isinf (double d) { 48 | int expon = 0; 49 | double val = frexp (d, &expon); 50 | if (expon == 1025) { 51 | if (val == 0.5) { 52 | return 1; 53 | } else if (val == -0.5) { 54 | return -1; 55 | } else { 56 | return 0; 57 | } 58 | } else { 59 | return 0; 60 | } 61 | } 62 | static int isnan (double d) { 63 | int expon = 0; 64 | double val = frexp (d, &expon); 65 | if (expon == 1025) { 66 | if (val == 0.5) { 67 | return 0; 68 | } else if (val == -0.5) { 69 | return 0; 70 | } else { 71 | return 1; 72 | } 73 | } else { 74 | return 0; 75 | } 76 | } 77 | #endif /* _MSC_VER */ 78 | 79 | #include 80 | 81 | /* snprintf emulation taken from http://stackoverflow.com/a/8712996/1956010 */ 82 | #if defined(_MSC_VER) && _MSC_VER < 1900 83 | 84 | #include 85 | #include 86 | 87 | #define snprintf c99_snprintf 88 | #define vsnprintf c99_vsnprintf 89 | 90 | __inline int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap) 91 | { 92 | int count = -1; 93 | 94 | if (size != 0) 95 | count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap); 96 | if (count == -1) 97 | count = _vscprintf(format, ap); 98 | 99 | return count; 100 | } 101 | 102 | __inline int c99_snprintf(char *outBuf, size_t size, const char *format, ...) 103 | { 104 | int count; 105 | va_list ap; 106 | 107 | va_start(ap, format); 108 | count = c99_vsnprintf(outBuf, size, format, ap); 109 | va_end(ap); 110 | 111 | return count; 112 | } 113 | 114 | #endif /* defined(_MSC_VER) && _MSC_VER < 1900 */ 115 | 116 | #define HAVE_SYS_STAT_H 117 | #define HAVE__STAT 118 | #define HAVE_STRING_H 119 | 120 | #include 121 | 122 | #ifndef ATTRIBUTE_UNUSED 123 | #define ATTRIBUTE_UNUSED 124 | #endif 125 | 126 | #define _WINSOCKAPI_ 127 | 128 | #endif /* __LIBXSLT_WIN32_CONFIG__ */ 129 | 130 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/xslt.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: Interfaces, constants and types related to the XSLT engine 3 | * Description: Interfaces, constants and types related to the XSLT engine 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Daniel Veillard 8 | */ 9 | 10 | #ifndef __XML_XSLT_H__ 11 | #define __XML_XSLT_H__ 12 | 13 | #include 14 | #include "xsltexports.h" 15 | 16 | #ifdef __cplusplus 17 | extern "C" { 18 | #endif 19 | 20 | /** 21 | * XSLT_DEFAULT_VERSION: 22 | * 23 | * The default version of XSLT supported. 24 | */ 25 | #define XSLT_DEFAULT_VERSION "1.0" 26 | 27 | /** 28 | * XSLT_DEFAULT_VENDOR: 29 | * 30 | * The XSLT "vendor" string for this processor. 31 | */ 32 | #define XSLT_DEFAULT_VENDOR "libxslt" 33 | 34 | /** 35 | * XSLT_DEFAULT_URL: 36 | * 37 | * The XSLT "vendor" URL for this processor. 38 | */ 39 | #define XSLT_DEFAULT_URL "http://xmlsoft.org/XSLT/" 40 | 41 | /** 42 | * XSLT_NAMESPACE: 43 | * 44 | * The XSLT specification namespace. 45 | */ 46 | #define XSLT_NAMESPACE ((const xmlChar *)"http://www.w3.org/1999/XSL/Transform") 47 | 48 | /** 49 | * XSLT_PARSE_OPTIONS: 50 | * 51 | * The set of options to pass to an xmlReadxxx when loading files for 52 | * XSLT consumption. 53 | */ 54 | #define XSLT_PARSE_OPTIONS \ 55 | XML_PARSE_NOENT | XML_PARSE_DTDLOAD | XML_PARSE_DTDATTR | XML_PARSE_NOCDATA 56 | 57 | /** 58 | * xsltMaxDepth: 59 | * 60 | * This value is used to detect templates loops. 61 | */ 62 | XSLTPUBVAR int xsltMaxDepth; 63 | 64 | /** 65 | * * xsltMaxVars: 66 | * * 67 | * * This value is used to detect templates loops. 68 | * */ 69 | XSLTPUBVAR int xsltMaxVars; 70 | 71 | /** 72 | * xsltEngineVersion: 73 | * 74 | * The version string for libxslt. 75 | */ 76 | XSLTPUBVAR const char *xsltEngineVersion; 77 | 78 | /** 79 | * xsltLibxsltVersion: 80 | * 81 | * The version of libxslt compiled. 82 | */ 83 | XSLTPUBVAR const int xsltLibxsltVersion; 84 | 85 | /** 86 | * xsltLibxmlVersion: 87 | * 88 | * The version of libxml libxslt was compiled against. 89 | */ 90 | XSLTPUBVAR const int xsltLibxmlVersion; 91 | 92 | /* 93 | * Global initialization function. 94 | */ 95 | 96 | XSLTPUBFUN void XSLTCALL 97 | xsltInit (void); 98 | 99 | /* 100 | * Global cleanup function. 101 | */ 102 | XSLTPUBFUN void XSLTCALL 103 | xsltCleanupGlobals (void); 104 | 105 | #ifdef __cplusplus 106 | } 107 | #endif 108 | 109 | #endif /* __XML_XSLT_H__ */ 110 | 111 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/xsltconfig.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: compile-time version information for the XSLT engine 3 | * Description: compile-time version information for the XSLT engine 4 | * this module is autogenerated. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Daniel Veillard 9 | */ 10 | 11 | #ifndef __XML_XSLTCONFIG_H__ 12 | #define __XML_XSLTCONFIG_H__ 13 | 14 | #ifdef __cplusplus 15 | extern "C" { 16 | #endif 17 | 18 | /** 19 | * LIBXSLT_DOTTED_VERSION: 20 | * 21 | * the version string like "1.2.3" 22 | */ 23 | #define LIBXSLT_DOTTED_VERSION "1.1.34" 24 | 25 | /** 26 | * LIBXSLT_VERSION: 27 | * 28 | * the version number: 1.2.3 value is 10203 29 | */ 30 | #define LIBXSLT_VERSION 10134 31 | 32 | /** 33 | * LIBXSLT_VERSION_STRING: 34 | * 35 | * the version number string, 1.2.3 value is "10203" 36 | */ 37 | #define LIBXSLT_VERSION_STRING "10134" 38 | 39 | /** 40 | * LIBXSLT_VERSION_EXTRA: 41 | * 42 | * extra version information, used to show a CVS compilation 43 | */ 44 | #define LIBXSLT_VERSION_EXTRA "" 45 | 46 | /** 47 | * WITH_XSLT_DEBUG: 48 | * 49 | * Activate the compilation of the debug reporting. Speed penalty 50 | * is insignifiant and being able to run xsltpoc -v is useful. On 51 | * by default unless --without-debug is passed to configure 52 | */ 53 | #if 1 54 | #define WITH_XSLT_DEBUG 55 | #endif 56 | 57 | #if 0 58 | /** 59 | * DEBUG_MEMORY: 60 | * 61 | * should be activated only when debugging libxslt. It replaces the 62 | * allocator with a collect and debug shell to the libc allocator. 63 | * Use configure --with-mem-debug to activate it on both library 64 | */ 65 | #define DEBUG_MEMORY 66 | 67 | /** 68 | * DEBUG_MEMORY_LOCATION: 69 | * 70 | * should be activated only when debugging libxslt. 71 | * DEBUG_MEMORY_LOCATION should be activated only when libxml has 72 | * been configured with --with-debug-mem too 73 | */ 74 | #define DEBUG_MEMORY_LOCATION 75 | #endif 76 | 77 | /** 78 | * XSLT_NEED_TRIO: 79 | * 80 | * should be activated if the existing libc library lacks some of the 81 | * string formatting function, in that case reuse the Trio ones already 82 | * compiled in the libxml2 library. 83 | */ 84 | 85 | #if 0 86 | #define XSLT_NEED_TRIO 87 | #endif 88 | #ifdef __VMS 89 | #define HAVE_MATH_H 1 90 | #define HAVE_SYS_STAT_H 1 91 | #ifndef XSLT_NEED_TRIO 92 | #define XSLT_NEED_TRIO 93 | #endif 94 | #endif 95 | 96 | #ifdef XSLT_NEED_TRIO 97 | #define TRIO_REPLACE_STDIO 98 | #endif 99 | 100 | /** 101 | * WITH_XSLT_DEBUGGER: 102 | * 103 | * Activate the compilation of the debugger support. Speed penalty 104 | * is insignifiant. 105 | * On by default unless --without-debugger is passed to configure 106 | */ 107 | #if 1 108 | #ifndef WITH_DEBUGGER 109 | #define WITH_DEBUGGER 110 | #endif 111 | #endif 112 | 113 | /** 114 | * WITH_PROFILER: 115 | * 116 | * Activate the compilation of the profiler. Speed penalty 117 | * is insignifiant. 118 | * On by default unless --without-profiler is passed to configure 119 | */ 120 | #if 1 121 | #ifndef WITH_PROFILER 122 | #define WITH_PROFILER 123 | #endif 124 | #endif 125 | 126 | /** 127 | * WITH_MODULES: 128 | * 129 | * Whether module support is configured into libxslt 130 | * Note: no default module path for win32 platforms 131 | */ 132 | #if 0 133 | #ifndef WITH_MODULES 134 | #define WITH_MODULES 135 | #endif 136 | #define LIBXSLT_DEFAULT_PLUGINS_PATH() "NULL" 137 | #endif 138 | 139 | /** 140 | * ATTRIBUTE_UNUSED: 141 | * 142 | * This macro is used to flag unused function parameters to GCC 143 | */ 144 | #ifdef __GNUC__ 145 | #ifndef ATTRIBUTE_UNUSED 146 | #define ATTRIBUTE_UNUSED __attribute__((unused)) 147 | #endif 148 | #else 149 | #define ATTRIBUTE_UNUSED 150 | #endif 151 | 152 | /** 153 | * LIBXSLT_ATTR_FORMAT: 154 | * 155 | * This macro is used to indicate to GCC the parameters are printf-like 156 | */ 157 | #ifdef __GNUC__ 158 | #define LIBXSLT_ATTR_FORMAT(fmt,args) __attribute__((__format__(__printf__,fmt,args))) 159 | #else 160 | #define LIBXSLT_ATTR_FORMAT(fmt,args) 161 | #endif 162 | 163 | /** 164 | * LIBXSLT_PUBLIC: 165 | * 166 | * This macro is used to declare PUBLIC variables for Cygwin and for MSC on Windows 167 | */ 168 | #if !defined LIBXSLT_PUBLIC 169 | #if (defined(__CYGWIN__) || defined _MSC_VER) && !defined IN_LIBXSLT && !defined LIBXSLT_STATIC 170 | #define LIBXSLT_PUBLIC __declspec(dllimport) 171 | #else 172 | #define LIBXSLT_PUBLIC 173 | #endif 174 | #endif 175 | 176 | #ifdef __cplusplus 177 | } 178 | #endif 179 | 180 | #endif /* __XML_XSLTCONFIG_H__ */ 181 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/xsltexports.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: macros for marking symbols as exportable/importable. 3 | * Description: macros for marking symbols as exportable/importable. 4 | * 5 | * Copy: See Copyright for the status of this software. 6 | * 7 | * Author: Igor Zlatkovic 8 | */ 9 | 10 | #ifndef __XSLT_EXPORTS_H__ 11 | #define __XSLT_EXPORTS_H__ 12 | 13 | /** 14 | * XSLTPUBFUN: 15 | * XSLTPUBFUN, XSLTPUBVAR, XSLTCALL 16 | * 17 | * Macros which declare an exportable function, an exportable variable and 18 | * the calling convention used for functions. 19 | * 20 | * Please use an extra block for every platform/compiler combination when 21 | * modifying this, rather than overlong #ifdef lines. This helps 22 | * readability as well as the fact that different compilers on the same 23 | * platform might need different definitions. 24 | */ 25 | 26 | /** 27 | * XSLTPUBFUN: 28 | * 29 | * Macros which declare an exportable function 30 | */ 31 | #define XSLTPUBFUN 32 | /** 33 | * XSLTPUBVAR: 34 | * 35 | * Macros which declare an exportable variable 36 | */ 37 | #define XSLTPUBVAR extern 38 | /** 39 | * XSLTCALL: 40 | * 41 | * Macros which declare the called convention for exported functions 42 | */ 43 | #define XSLTCALL 44 | 45 | /** DOC_DISABLE */ 46 | 47 | /* Windows platform with MS compiler */ 48 | #if defined(_WIN32) && defined(_MSC_VER) 49 | #undef XSLTPUBFUN 50 | #undef XSLTPUBVAR 51 | #undef XSLTCALL 52 | #if defined(IN_LIBXSLT) && !defined(LIBXSLT_STATIC) 53 | #define XSLTPUBFUN __declspec(dllexport) 54 | #define XSLTPUBVAR __declspec(dllexport) 55 | #else 56 | #define XSLTPUBFUN 57 | #if !defined(LIBXSLT_STATIC) 58 | #define XSLTPUBVAR __declspec(dllimport) extern 59 | #else 60 | #define XSLTPUBVAR extern 61 | #endif 62 | #endif 63 | #define XSLTCALL __cdecl 64 | #if !defined _REENTRANT 65 | #define _REENTRANT 66 | #endif 67 | #endif 68 | 69 | /* Windows platform with Borland compiler */ 70 | #if defined(_WIN32) && defined(__BORLANDC__) 71 | #undef XSLTPUBFUN 72 | #undef XSLTPUBVAR 73 | #undef XSLTCALL 74 | #if defined(IN_LIBXSLT) && !defined(LIBXSLT_STATIC) 75 | #define XSLTPUBFUN __declspec(dllexport) 76 | #define XSLTPUBVAR __declspec(dllexport) extern 77 | #else 78 | #define XSLTPUBFUN 79 | #if !defined(LIBXSLT_STATIC) 80 | #define XSLTPUBVAR __declspec(dllimport) extern 81 | #else 82 | #define XSLTPUBVAR extern 83 | #endif 84 | #endif 85 | #define XSLTCALL __cdecl 86 | #if !defined _REENTRANT 87 | #define _REENTRANT 88 | #endif 89 | #endif 90 | 91 | /* Windows platform with GNU compiler (Mingw) */ 92 | #if defined(_WIN32) && defined(__MINGW32__) 93 | #undef XSLTPUBFUN 94 | #undef XSLTPUBVAR 95 | #undef XSLTCALL 96 | /* 97 | #if defined(IN_LIBXSLT) && !defined(LIBXSLT_STATIC) 98 | */ 99 | #if !defined(LIBXSLT_STATIC) 100 | #define XSLTPUBFUN __declspec(dllexport) 101 | #define XSLTPUBVAR __declspec(dllexport) extern 102 | #else 103 | #define XSLTPUBFUN 104 | #if !defined(LIBXSLT_STATIC) 105 | #define XSLTPUBVAR __declspec(dllimport) extern 106 | #else 107 | #define XSLTPUBVAR extern 108 | #endif 109 | #endif 110 | #define XSLTCALL __cdecl 111 | #if !defined _REENTRANT 112 | #define _REENTRANT 113 | #endif 114 | #endif 115 | 116 | /* Cygwin platform (does not define _WIN32), GNU compiler */ 117 | #if defined(__CYGWIN__) 118 | #undef XSLTPUBFUN 119 | #undef XSLTPUBVAR 120 | #undef XSLTCALL 121 | #if defined(IN_LIBXSLT) && !defined(LIBXSLT_STATIC) 122 | #define XSLTPUBFUN __declspec(dllexport) 123 | #define XSLTPUBVAR __declspec(dllexport) 124 | #else 125 | #define XSLTPUBFUN 126 | #if !defined(LIBXSLT_STATIC) 127 | #define XSLTPUBVAR __declspec(dllimport) extern 128 | #else 129 | #define XSLTPUBVAR extern 130 | #endif 131 | #endif 132 | #define XSLTCALL __cdecl 133 | #endif 134 | 135 | /* Compatibility */ 136 | #if !defined(LIBXSLT_PUBLIC) 137 | #define LIBXSLT_PUBLIC XSLTPUBVAR 138 | #endif 139 | 140 | #endif /* __XSLT_EXPORTS_H__ */ 141 | 142 | 143 | -------------------------------------------------------------------------------- /lxml/includes/libxslt/xsltlocale.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Summary: Locale handling 3 | * Description: Interfaces for locale handling. Needed for language dependent 4 | * sorting. 5 | * 6 | * Copy: See Copyright for the status of this software. 7 | * 8 | * Author: Nick Wellnhofer 9 | */ 10 | 11 | #ifndef __XML_XSLTLOCALE_H__ 12 | #define __XML_XSLTLOCALE_H__ 13 | 14 | #include 15 | #include "xsltexports.h" 16 | 17 | #ifdef HAVE_STRXFRM_L 18 | 19 | /* 20 | * XSLT_LOCALE_POSIX: 21 | * Macro indicating to use POSIX locale extensions 22 | */ 23 | #define XSLT_LOCALE_POSIX 24 | 25 | #ifdef HAVE_LOCALE_H 26 | #include 27 | #endif 28 | #ifdef HAVE_XLOCALE_H 29 | #include 30 | #endif 31 | 32 | typedef locale_t xsltLocale; 33 | typedef xmlChar xsltLocaleChar; 34 | 35 | #elif defined(_WIN32) && !defined(__CYGWIN__) 36 | 37 | /* 38 | * XSLT_LOCALE_WINAPI: 39 | * Macro indicating to use WinAPI for extended locale support 40 | */ 41 | #define XSLT_LOCALE_WINAPI 42 | 43 | #include 44 | #include 45 | 46 | typedef LCID xsltLocale; 47 | typedef wchar_t xsltLocaleChar; 48 | 49 | #else 50 | 51 | /* 52 | * XSLT_LOCALE_NONE: 53 | * Macro indicating that there's no extended locale support 54 | */ 55 | #define XSLT_LOCALE_NONE 56 | 57 | typedef void *xsltLocale; 58 | typedef xmlChar xsltLocaleChar; 59 | 60 | #endif 61 | 62 | XSLTPUBFUN xsltLocale XSLTCALL 63 | xsltNewLocale (const xmlChar *langName); 64 | XSLTPUBFUN void XSLTCALL 65 | xsltFreeLocale (xsltLocale locale); 66 | XSLTPUBFUN xsltLocaleChar * XSLTCALL 67 | xsltStrxfrm (xsltLocale locale, 68 | const xmlChar *string); 69 | XSLTPUBFUN int XSLTCALL 70 | xsltLocaleStrcmp (xsltLocale locale, 71 | const xsltLocaleChar *str1, 72 | const xsltLocaleChar *str2); 73 | XSLTPUBFUN void XSLTCALL 74 | xsltFreeLocales (void); 75 | 76 | #endif /* __XML_XSLTLOCALE_H__ */ 77 | -------------------------------------------------------------------------------- /lxml/includes/lxml-version.h: -------------------------------------------------------------------------------- 1 | #ifndef LXML_VERSION_STRING 2 | #define LXML_VERSION_STRING "4.8.0" 3 | #endif 4 | -------------------------------------------------------------------------------- /lxml/includes/relaxng.pxd: -------------------------------------------------------------------------------- 1 | from lxml.includes.tree cimport xmlDoc 2 | from lxml.includes.xmlerror cimport xmlStructuredErrorFunc 3 | 4 | cdef extern from "libxml/relaxng.h": 5 | ctypedef struct xmlRelaxNG 6 | ctypedef struct xmlRelaxNGParserCtxt 7 | 8 | ctypedef struct xmlRelaxNGValidCtxt 9 | 10 | ctypedef enum xmlRelaxNGValidErr: 11 | XML_RELAXNG_OK = 0 12 | XML_RELAXNG_ERR_MEMORY = 1 13 | XML_RELAXNG_ERR_TYPE = 2 14 | XML_RELAXNG_ERR_TYPEVAL = 3 15 | XML_RELAXNG_ERR_DUPID = 4 16 | XML_RELAXNG_ERR_TYPECMP = 5 17 | XML_RELAXNG_ERR_NOSTATE = 6 18 | XML_RELAXNG_ERR_NODEFINE = 7 19 | XML_RELAXNG_ERR_LISTEXTRA = 8 20 | XML_RELAXNG_ERR_LISTEMPTY = 9 21 | XML_RELAXNG_ERR_INTERNODATA = 10 22 | XML_RELAXNG_ERR_INTERSEQ = 11 23 | XML_RELAXNG_ERR_INTEREXTRA = 12 24 | XML_RELAXNG_ERR_ELEMNAME = 13 25 | XML_RELAXNG_ERR_ATTRNAME = 14 26 | XML_RELAXNG_ERR_ELEMNONS = 15 27 | XML_RELAXNG_ERR_ATTRNONS = 16 28 | XML_RELAXNG_ERR_ELEMWRONGNS = 17 29 | XML_RELAXNG_ERR_ATTRWRONGNS = 18 30 | XML_RELAXNG_ERR_ELEMEXTRANS = 19 31 | XML_RELAXNG_ERR_ATTREXTRANS = 20 32 | XML_RELAXNG_ERR_ELEMNOTEMPTY = 21 33 | XML_RELAXNG_ERR_NOELEM = 22 34 | XML_RELAXNG_ERR_NOTELEM = 23 35 | XML_RELAXNG_ERR_ATTRVALID = 24 36 | XML_RELAXNG_ERR_CONTENTVALID = 25 37 | XML_RELAXNG_ERR_EXTRACONTENT = 26 38 | XML_RELAXNG_ERR_INVALIDATTR = 27 39 | XML_RELAXNG_ERR_DATAELEM = 28 40 | XML_RELAXNG_ERR_VALELEM = 29 41 | XML_RELAXNG_ERR_LISTELEM = 30 42 | XML_RELAXNG_ERR_DATATYPE = 31 43 | XML_RELAXNG_ERR_VALUE = 32 44 | XML_RELAXNG_ERR_LIST = 33 45 | XML_RELAXNG_ERR_NOGRAMMAR = 34 46 | XML_RELAXNG_ERR_EXTRADATA = 35 47 | XML_RELAXNG_ERR_LACKDATA = 36 48 | XML_RELAXNG_ERR_INTERNAL = 37 49 | XML_RELAXNG_ERR_ELEMWRONG = 38 50 | XML_RELAXNG_ERR_TEXTWRONG = 39 51 | 52 | cdef xmlRelaxNGValidCtxt* xmlRelaxNGNewValidCtxt(xmlRelaxNG* schema) nogil 53 | cdef int xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxt* ctxt, xmlDoc* doc) nogil 54 | cdef xmlRelaxNG* xmlRelaxNGParse(xmlRelaxNGParserCtxt* ctxt) nogil 55 | cdef xmlRelaxNGParserCtxt* xmlRelaxNGNewParserCtxt(char* URL) nogil 56 | cdef xmlRelaxNGParserCtxt* xmlRelaxNGNewDocParserCtxt(xmlDoc* doc) nogil 57 | cdef void xmlRelaxNGFree(xmlRelaxNG* schema) nogil 58 | cdef void xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxt* ctxt) nogil 59 | cdef void xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxt* ctxt) nogil 60 | 61 | cdef void xmlRelaxNGSetValidStructuredErrors( 62 | xmlRelaxNGValidCtxt* ctxt, xmlStructuredErrorFunc serror, void *ctx) nogil 63 | cdef void xmlRelaxNGSetParserStructuredErrors( 64 | xmlRelaxNGParserCtxt* ctxt, xmlStructuredErrorFunc serror, void *ctx) nogil 65 | -------------------------------------------------------------------------------- /lxml/includes/schematron.pxd: -------------------------------------------------------------------------------- 1 | from lxml.includes cimport xmlerror 2 | from lxml.includes.tree cimport xmlDoc 3 | 4 | cdef extern from "libxml/schematron.h": 5 | ctypedef struct xmlSchematron 6 | ctypedef struct xmlSchematronParserCtxt 7 | ctypedef struct xmlSchematronValidCtxt 8 | 9 | ctypedef enum xmlSchematronValidOptions: 10 | XML_SCHEMATRON_OUT_QUIET = 1 # quiet no report 11 | XML_SCHEMATRON_OUT_TEXT = 2 # build a textual report 12 | XML_SCHEMATRON_OUT_XML = 4 # output SVRL 13 | XML_SCHEMATRON_OUT_ERROR = 8 # output via xmlStructuredErrorFunc 14 | XML_SCHEMATRON_OUT_FILE = 256 # output to a file descriptor 15 | XML_SCHEMATRON_OUT_BUFFER = 512 # output to a buffer 16 | XML_SCHEMATRON_OUT_IO = 1024 # output to I/O mechanism 17 | 18 | cdef xmlSchematronParserCtxt* xmlSchematronNewDocParserCtxt( 19 | xmlDoc* doc) nogil 20 | cdef xmlSchematronParserCtxt* xmlSchematronNewParserCtxt( 21 | char* filename) nogil 22 | cdef xmlSchematronValidCtxt* xmlSchematronNewValidCtxt( 23 | xmlSchematron* schema, int options) nogil 24 | 25 | cdef xmlSchematron* xmlSchematronParse(xmlSchematronParserCtxt* ctxt) nogil 26 | cdef int xmlSchematronValidateDoc(xmlSchematronValidCtxt* ctxt, 27 | xmlDoc* instance) nogil 28 | 29 | cdef void xmlSchematronFreeParserCtxt(xmlSchematronParserCtxt* ctxt) nogil 30 | cdef void xmlSchematronFreeValidCtxt(xmlSchematronValidCtxt* ctxt) nogil 31 | cdef void xmlSchematronFree(xmlSchematron* schema) nogil 32 | cdef void xmlSchematronSetValidStructuredErrors( 33 | xmlSchematronValidCtxt* ctxt, 34 | xmlerror.xmlStructuredErrorFunc error_func, void *data) 35 | -------------------------------------------------------------------------------- /lxml/includes/uri.pxd: -------------------------------------------------------------------------------- 1 | cdef extern from "libxml/uri.h": 2 | ctypedef struct xmlURI 3 | 4 | cdef xmlURI* xmlParseURI(char* str) 5 | cdef void xmlFreeURI(xmlURI* uri) 6 | -------------------------------------------------------------------------------- /lxml/includes/xinclude.pxd: -------------------------------------------------------------------------------- 1 | from lxml.includes.tree cimport xmlDoc, xmlNode 2 | 3 | cdef extern from "libxml/xinclude.h": 4 | 5 | ctypedef struct xmlXIncludeCtxt 6 | 7 | cdef int xmlXIncludeProcess(xmlDoc* doc) nogil 8 | cdef int xmlXIncludeProcessFlags(xmlDoc* doc, int parser_opts) nogil 9 | cdef int xmlXIncludeProcessTree(xmlNode* doc) nogil 10 | cdef int xmlXIncludeProcessTreeFlags(xmlNode* doc, int parser_opts) nogil 11 | 12 | # libxml2 >= 2.7.4 13 | cdef int xmlXIncludeProcessTreeFlagsData( 14 | xmlNode* doc, int parser_opts, void* data) nogil 15 | 16 | cdef xmlXIncludeCtxt* xmlXIncludeNewContext(xmlDoc* doc) nogil 17 | cdef int xmlXIncludeProcessNode(xmlXIncludeCtxt* ctxt, xmlNode* node) nogil 18 | cdef int xmlXIncludeSetFlags(xmlXIncludeCtxt* ctxt, int flags) nogil 19 | 20 | # libxml2 >= 2.6.27 21 | cdef int xmlXIncludeProcessFlagsData( 22 | xmlDoc* doc, int flags, void* data) nogil 23 | -------------------------------------------------------------------------------- /lxml/includes/xmlschema.pxd: -------------------------------------------------------------------------------- 1 | from lxml.includes.tree cimport xmlDoc 2 | from lxml.includes.xmlparser cimport xmlSAXHandler 3 | from lxml.includes.xmlerror cimport xmlStructuredErrorFunc 4 | 5 | cdef extern from "libxml/xmlschemas.h": 6 | ctypedef struct xmlSchema 7 | ctypedef struct xmlSchemaParserCtxt 8 | 9 | ctypedef struct xmlSchemaSAXPlugStruct 10 | ctypedef struct xmlSchemaValidCtxt 11 | 12 | ctypedef enum xmlSchemaValidOption: 13 | XML_SCHEMA_VAL_VC_I_CREATE = 1 14 | 15 | cdef xmlSchemaValidCtxt* xmlSchemaNewValidCtxt(xmlSchema* schema) nogil 16 | cdef void xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxt* ctxt, 17 | xmlStructuredErrorFunc serror, void *ctx) 18 | cdef void xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxt* ctxt, 19 | xmlStructuredErrorFunc serror, void *ctx) 20 | 21 | cdef int xmlSchemaValidateDoc(xmlSchemaValidCtxt* ctxt, xmlDoc* doc) nogil 22 | cdef xmlSchema* xmlSchemaParse(xmlSchemaParserCtxt* ctxt) nogil 23 | cdef xmlSchemaParserCtxt* xmlSchemaNewParserCtxt(char* URL) nogil 24 | cdef xmlSchemaParserCtxt* xmlSchemaNewDocParserCtxt(xmlDoc* doc) nogil 25 | cdef void xmlSchemaFree(xmlSchema* schema) nogil 26 | cdef void xmlSchemaFreeParserCtxt(xmlSchemaParserCtxt* ctxt) nogil 27 | cdef void xmlSchemaFreeValidCtxt(xmlSchemaValidCtxt* ctxt) nogil 28 | cdef int xmlSchemaSetValidOptions(xmlSchemaValidCtxt* ctxt, 29 | int options) nogil 30 | 31 | cdef xmlSchemaSAXPlugStruct* xmlSchemaSAXPlug(xmlSchemaValidCtxt* ctxt, 32 | xmlSAXHandler** sax, 33 | void** data) nogil 34 | cdef int xmlSchemaSAXUnplug(xmlSchemaSAXPlugStruct* sax_plug) 35 | cdef int xmlSchemaIsValid(xmlSchemaValidCtxt* ctxt) 36 | -------------------------------------------------------------------------------- /lxml/isoschematron/__pycache__/__init__.cpython-310.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/isoschematron/__pycache__/__init__.cpython-310.pyc -------------------------------------------------------------------------------- /lxml/isoschematron/resources/xsl/RNG2Schtrn.xsl: -------------------------------------------------------------------------------- 1 | 2 | 8 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | -------------------------------------------------------------------------------- /lxml/isoschematron/resources/xsl/XSD2Schtrn.xsl: -------------------------------------------------------------------------------- 1 | 2 | 8 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 40 | 41 | 42 | 43 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | -------------------------------------------------------------------------------- /lxml/isoschematron/resources/xsl/iso-schematron-xslt1/iso_schematron_message.xsl: -------------------------------------------------------------------------------- 1 | 2 | 25 | 26 | 27 | 28 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 44 | 45 | 46 | 47 | 48 | 49 | ( 51 | / 52 | ) 53 | 54 | 55 | -------------------------------------------------------------------------------- /lxml/isoschematron/resources/xsl/iso-schematron-xslt1/readme.txt: -------------------------------------------------------------------------------- 1 | ISO SCHEMATRON 2010 2 | 3 | XSLT implementation by Rick Jelliffe with assistance from members of Schematron-love-in maillist. 4 | 5 | 2010-04-21 6 | 7 | Two distributions are available. One is for XSLT1 engines. 8 | The other is for XSLT2 engines, such as SAXON 9. 9 | 10 | 11 | This version of Schematron splits the process into a pipeline of several different XSLT stages. 12 | 13 | 1) First, preprocess your Schematron schema with iso_dsdl_include.xsl. 14 | This is a macro processor to assemble the schema from various parts. 15 | If your schema is not in separate parts, you can skip this stage. 16 | This stage also generates error messages for some common XPath syntax problems. 17 | 18 | 2) Second, preprocess the output from stage 1 with iso_abstract_expand.xsl. 19 | This is a macro processor to convert abstract patterns to real patterns. 20 | If your schema does not use abstract patterns, you can skip this 21 | stage. 22 | 23 | 3) Third, compile the Schematron schema into an XSLT script. 24 | This will typically use iso_svrl_for_xslt1.xsl or iso_svrl_for_xslt2.xsl 25 | (which in turn invoke iso_schematron_skeleton_for_xslt1.xsl or iso_schematron_skeleton_for_saxon.xsl) 26 | However, other "meta-stylesheets" are also in common use; the principle of operation is the same. 27 | If your schema uses Schematron phases, supply these as command line/invocation parameters 28 | to this process. 29 | 30 | 4) Fourth, run the script generated by stage 3 against the document being validated. 31 | If you are using the SVRL script, then the output of validation will be an XML document. 32 | If your schema uses Schematron parameters, supply these as command line/invocation parameters 33 | to this process. 34 | 35 | 36 | The XSLT2 distribution also features several next generation features, 37 | such as validating multiple documents. See the source code for details. 38 | 39 | Schematron assertions can be written in any language, of course; the file 40 | sch-messages-en.xhtml contains the diagnostics messages from the XSLT2 skeleton 41 | in English, and this can be used as template to localize the skeleton's 42 | error messages. Note that typically programming errors in Schematron are XPath 43 | errors, which requires localized messages from the XSLT engine. 44 | 45 | ANT 46 | --- 47 | To give an example of how to process a document, here is a sample ANT task. 48 | 49 | 50 | 51 | 52 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 80 | 81 | 82 | 83 | 84 | 85 | -------------------------------------------------------------------------------- /lxml/objectify.cp310-win_amd64.pyd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/objectify.cp310-win_amd64.pyd -------------------------------------------------------------------------------- /lxml/pyclasslookup.py: -------------------------------------------------------------------------------- 1 | # dummy module for backwards compatibility 2 | 3 | from lxml.etree import PythonElementClassLookup 4 | -------------------------------------------------------------------------------- /lxml/sax.cp310-win_amd64.pyd: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahmoudamr512/PythonYoutubeScrapper/83014eccfa229093d56b04f0bc25366b276104c5/lxml/sax.cp310-win_amd64.pyd -------------------------------------------------------------------------------- /lxml/usedoctest.py: -------------------------------------------------------------------------------- 1 | """Doctest module for XML comparison. 2 | 3 | Usage:: 4 | 5 | >>> import lxml.usedoctest 6 | >>> # now do your XML doctests ... 7 | 8 | See `lxml.doctestcompare` 9 | """ 10 | 11 | from lxml import doctestcompare 12 | 13 | doctestcompare.temp_install(del_module=__name__) 14 | --------------------------------------------------------------------------------