From e60a94965eb6c29e1959afd87289153e6a573b67 Mon Sep 17 00:00:00 2001 From: CoprDistGit Date: Fri, 5 May 2023 10:07:25 +0000 Subject: automatic import of python-pcpp --- .gitignore | 1 + python-pcpp.spec | 207 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ sources | 1 + 3 files changed, 209 insertions(+) create mode 100644 python-pcpp.spec create mode 100644 sources diff --git a/.gitignore b/.gitignore index e69de29..f132a81 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1 @@ +/pcpp-1.30.tar.gz diff --git a/python-pcpp.spec b/python-pcpp.spec new file mode 100644 index 0000000..7e030fd --- /dev/null +++ b/python-pcpp.spec @@ -0,0 +1,207 @@ +%global _empty_manifest_terminate_build 0 +Name: python-pcpp +Version: 1.30 +Release: 1 +Summary: A C99 preprocessor written in pure Python +License: BSD +URL: https://github.com/ned14/pcpp +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/41/07/876153f611f2c610bdb8f706a5ab560d888c938ea9ea65ed18c374a9014a/pcpp-1.30.tar.gz +BuildArch: noarch + + +%description +\(C) 2018-2021 Niall Douglas http://www.nedproductions.biz/ and (C) 2007-2020 David Beazley http://www.dabeaz.com/ +PyPI: https://pypi.python.org/pypi/pcpp Github: https://github.com/ned14/pcpp API reference docs: https://ned14.github.io/pcpp/ +Travis master branch all tests passing for Python v2, v3 and PyPy v2, v3: |travis| +A pure universal Python C (pre-)preprocessor implementation very useful for pre-preprocessing header only +C++ libraries into single file includes and other such build or packaging stage malarky. +The implementation can be used as a Python module (`see API reference `_) +or as a command line tool ``pcpp`` which +can stand in for a conventional C preprocessor (i.e. it'll accept similar arguments). +Works great under PyPy, and you can expect performance gains of between 0.84x and 2.62x +(average = 2.2x, median = 2.31x). +Your includes can be benchmarked for heft in order to improve your build times! See +the ``--times`` and ``--filetimes`` options, and you can see graphs from pcpp for the +C++ STLs at https://github.com/ned14/stl-header-heft. +A very unique facility of this C preprocessor is *partial* preprocessing so you can +programmatically control how much preprocessing is done by ``pcpp`` and how much is +done by the C or C++ compiler's preprocessor. The ultimate control is by subclassing +the :c:`Preprocessor` class in Python from which you can do anything you like, however +for your convenience the ``pcpp`` command line tool comes with the following canned +partial preprocessing algorithms: +**passthru-defines** + Pass through but still execute #defines and #undefs if not always removed by + preprocessor logic. This ensures that including the output sets exactly the same + macros as if you included the original, plus include guards work. +**passthru-unfound-includes** + If an :c:`#include` is not found, pass it through unmodified. This is very useful + for passing through includes of system headers. +**passthru-undefined-exprs** + This is one of the most powerful pass through algorithms. If an expression passed to + known macros and pass through *unexecuted*, and then pass through the remaining block. + Each :c:`#elif` is evaluated in turn and if it does not contain unknown macros, it will be + executed immediately. Finally, any :c:`#else` clause is always passed through *unexecuted*. + Note that include guards normally defeat this algorithm, so those are specially detected and + ignored. +**passthru-comments** + A major use case for ``pcpp`` is as a preprocessor for the `doxygen `_ + reference documentation tool whose preprocessor is unable to handle any preprocessing + of any complexity. ``pcpp`` can partially execute the preprocessing which doxygen + is incapable of, thus generating output which produces good results with doxygen. + Hence the ability to pass through comments containing doxygen markup is very useful. +**passthru-magic-macros** + Don't expand ``__DATE__``, ``__TIME__``, ``__FILE__``, ``__LINE__`` nor ``__COUNTER__``. +**passthru-includes** + Don't expand those ``#include`` whose arguments match the supplied regular expression + into the output, however still execute those includes. This lets you generate output + with macros from nested includes expanded, however those ``#include`` matching + the regular expression are passed through into the output. + +%package -n python3-pcpp +Summary: A C99 preprocessor written in pure Python +Provides: python-pcpp +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-pcpp +\(C) 2018-2021 Niall Douglas http://www.nedproductions.biz/ and (C) 2007-2020 David Beazley http://www.dabeaz.com/ +PyPI: https://pypi.python.org/pypi/pcpp Github: https://github.com/ned14/pcpp API reference docs: https://ned14.github.io/pcpp/ +Travis master branch all tests passing for Python v2, v3 and PyPy v2, v3: |travis| +A pure universal Python C (pre-)preprocessor implementation very useful for pre-preprocessing header only +C++ libraries into single file includes and other such build or packaging stage malarky. +The implementation can be used as a Python module (`see API reference `_) +or as a command line tool ``pcpp`` which +can stand in for a conventional C preprocessor (i.e. it'll accept similar arguments). +Works great under PyPy, and you can expect performance gains of between 0.84x and 2.62x +(average = 2.2x, median = 2.31x). +Your includes can be benchmarked for heft in order to improve your build times! See +the ``--times`` and ``--filetimes`` options, and you can see graphs from pcpp for the +C++ STLs at https://github.com/ned14/stl-header-heft. +A very unique facility of this C preprocessor is *partial* preprocessing so you can +programmatically control how much preprocessing is done by ``pcpp`` and how much is +done by the C or C++ compiler's preprocessor. The ultimate control is by subclassing +the :c:`Preprocessor` class in Python from which you can do anything you like, however +for your convenience the ``pcpp`` command line tool comes with the following canned +partial preprocessing algorithms: +**passthru-defines** + Pass through but still execute #defines and #undefs if not always removed by + preprocessor logic. This ensures that including the output sets exactly the same + macros as if you included the original, plus include guards work. +**passthru-unfound-includes** + If an :c:`#include` is not found, pass it through unmodified. This is very useful + for passing through includes of system headers. +**passthru-undefined-exprs** + This is one of the most powerful pass through algorithms. If an expression passed to + known macros and pass through *unexecuted*, and then pass through the remaining block. + Each :c:`#elif` is evaluated in turn and if it does not contain unknown macros, it will be + executed immediately. Finally, any :c:`#else` clause is always passed through *unexecuted*. + Note that include guards normally defeat this algorithm, so those are specially detected and + ignored. +**passthru-comments** + A major use case for ``pcpp`` is as a preprocessor for the `doxygen `_ + reference documentation tool whose preprocessor is unable to handle any preprocessing + of any complexity. ``pcpp`` can partially execute the preprocessing which doxygen + is incapable of, thus generating output which produces good results with doxygen. + Hence the ability to pass through comments containing doxygen markup is very useful. +**passthru-magic-macros** + Don't expand ``__DATE__``, ``__TIME__``, ``__FILE__``, ``__LINE__`` nor ``__COUNTER__``. +**passthru-includes** + Don't expand those ``#include`` whose arguments match the supplied regular expression + into the output, however still execute those includes. This lets you generate output + with macros from nested includes expanded, however those ``#include`` matching + the regular expression are passed through into the output. + +%package help +Summary: Development documents and examples for pcpp +Provides: python3-pcpp-doc +%description help +\(C) 2018-2021 Niall Douglas http://www.nedproductions.biz/ and (C) 2007-2020 David Beazley http://www.dabeaz.com/ +PyPI: https://pypi.python.org/pypi/pcpp Github: https://github.com/ned14/pcpp API reference docs: https://ned14.github.io/pcpp/ +Travis master branch all tests passing for Python v2, v3 and PyPy v2, v3: |travis| +A pure universal Python C (pre-)preprocessor implementation very useful for pre-preprocessing header only +C++ libraries into single file includes and other such build or packaging stage malarky. +The implementation can be used as a Python module (`see API reference `_) +or as a command line tool ``pcpp`` which +can stand in for a conventional C preprocessor (i.e. it'll accept similar arguments). +Works great under PyPy, and you can expect performance gains of between 0.84x and 2.62x +(average = 2.2x, median = 2.31x). +Your includes can be benchmarked for heft in order to improve your build times! See +the ``--times`` and ``--filetimes`` options, and you can see graphs from pcpp for the +C++ STLs at https://github.com/ned14/stl-header-heft. +A very unique facility of this C preprocessor is *partial* preprocessing so you can +programmatically control how much preprocessing is done by ``pcpp`` and how much is +done by the C or C++ compiler's preprocessor. The ultimate control is by subclassing +the :c:`Preprocessor` class in Python from which you can do anything you like, however +for your convenience the ``pcpp`` command line tool comes with the following canned +partial preprocessing algorithms: +**passthru-defines** + Pass through but still execute #defines and #undefs if not always removed by + preprocessor logic. This ensures that including the output sets exactly the same + macros as if you included the original, plus include guards work. +**passthru-unfound-includes** + If an :c:`#include` is not found, pass it through unmodified. This is very useful + for passing through includes of system headers. +**passthru-undefined-exprs** + This is one of the most powerful pass through algorithms. If an expression passed to + known macros and pass through *unexecuted*, and then pass through the remaining block. + Each :c:`#elif` is evaluated in turn and if it does not contain unknown macros, it will be + executed immediately. Finally, any :c:`#else` clause is always passed through *unexecuted*. + Note that include guards normally defeat this algorithm, so those are specially detected and + ignored. +**passthru-comments** + A major use case for ``pcpp`` is as a preprocessor for the `doxygen `_ + reference documentation tool whose preprocessor is unable to handle any preprocessing + of any complexity. ``pcpp`` can partially execute the preprocessing which doxygen + is incapable of, thus generating output which produces good results with doxygen. + Hence the ability to pass through comments containing doxygen markup is very useful. +**passthru-magic-macros** + Don't expand ``__DATE__``, ``__TIME__``, ``__FILE__``, ``__LINE__`` nor ``__COUNTER__``. +**passthru-includes** + Don't expand those ``#include`` whose arguments match the supplied regular expression + into the output, however still execute those includes. This lets you generate output + with macros from nested includes expanded, however those ``#include`` matching + the regular expression are passed through into the output. + +%prep +%autosetup -n pcpp-1.30 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-pcpp -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Fri May 05 2023 Python_Bot - 1.30-1 +- Package Spec generated diff --git a/sources b/sources new file mode 100644 index 0000000..55c8a14 --- /dev/null +++ b/sources @@ -0,0 +1 @@ +87d56b52a6e1c41ee67b13d3c1d32a16 pcpp-1.30.tar.gz -- cgit v1.2.3