1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
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 <https://ned14.github.io/pcpp/>`_)
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 <http://www.stack.nl/~dimitri/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 <https://ned14.github.io/pcpp/>`_)
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 <http://www.stack.nl/~dimitri/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 <https://ned14.github.io/pcpp/>`_)
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 <http://www.stack.nl/~dimitri/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 <Python_Bot@openeuler.org> - 1.30-1
- Package Spec generated
|
