/[gentoo-x86]/eclass/python-utils-r1.eclass
Gentoo

Contents of /eclass/python-utils-r1.eclass

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.18 - (show annotations) (download)
Mon Feb 4 13:53:54 2013 UTC (18 months, 3 weeks ago) by mgorny
Branch: MAIN
Changes since 1.17: +44 -1 lines
Introduce python_get_library_path() to obtain the path to the Python library. Required by dev-python/shiboken.

1 # Copyright 1999-2013 Gentoo Foundation
2 # Distributed under the terms of the GNU General Public License v2
3 # $Header: /var/cvsroot/gentoo-x86/eclass/python-utils-r1.eclass,v 1.17 2013/02/04 13:52:09 mgorny Exp $
4
5 # @ECLASS: python-utils-r1
6 # @MAINTAINER:
7 # Python team <python@gentoo.org>
8 # @AUTHOR:
9 # Author: Michał Górny <mgorny@gentoo.org>
10 # Based on work of: Krzysztof Pawlik <nelchael@gentoo.org>
11 # @BLURB: Utility functions for packages with Python parts.
12 # @DESCRIPTION:
13 # An utility eclass providing functions to query Python implementations,
14 # install Python modules and scripts.
15 #
16 # This eclass does not set any metadata variables nor export any phase
17 # functions. It can be inherited safely.
18 #
19 # For more information, please see the python-r1 Developer's Guide:
20 # http://www.gentoo.org/proj/en/Python/python-r1/dev-guide.xml
21
22 case "${EAPI:-0}" in
23 0|1|2|3|4|5)
24 # EAPI=4 makes die behavior clear
25 ;;
26 *)
27 die "Unsupported EAPI=${EAPI} (unknown) for ${ECLASS}"
28 ;;
29 esac
30
31 if [[ ${_PYTHON_ECLASS_INHERITED} ]]; then
32 die 'python-r1 suite eclasses can not be used with python.eclass.'
33 fi
34
35 if [[ ! ${_PYTHON_UTILS_R1} ]]; then
36
37 inherit multilib
38
39 # @ECLASS-VARIABLE: _PYTHON_ALL_IMPLS
40 # @INTERNAL
41 # @DESCRIPTION:
42 # All supported Python implementations, most preferred last.
43 _PYTHON_ALL_IMPLS=(
44 jython2_5
45 pypy1_9 pypy2_0
46 python3_1 python3_2 python3_3
47 python2_5 python2_6 python2_7
48 )
49
50 # @FUNCTION: _python_impl_supported
51 # @USAGE: <impl>
52 # @INTERNAL
53 # @DESCRIPTION:
54 # Check whether the implementation <impl> (PYTHON_COMPAT-form)
55 # is still supported.
56 #
57 # Returns 0 if the implementation is valid and supported. If it is
58 # unsupported, returns 1 -- and the caller should ignore the entry.
59 # If it is invalid, dies with an appopriate error messages.
60 _python_impl_supported() {
61 debug-print-function ${FUNCNAME} "${@}"
62
63 [[ ${#} -eq 1 ]] || die "${FUNCNAME}: takes exactly 1 argument (impl)."
64
65 local impl=${1}
66
67 # keep in sync with _PYTHON_ALL_IMPLS!
68 # (not using that list because inline patterns shall be faster)
69 case "${impl}" in
70 python2_[567]|python3_[123]|pypy1_9|pypy2_0|jython2_5)
71 return 0
72 ;;
73 pypy1_8)
74 return 1
75 ;;
76 *)
77 die "Invalid implementation in PYTHON_COMPAT: ${impl}"
78 esac
79 }
80
81 # @ECLASS-VARIABLE: PYTHON
82 # @DESCRIPTION:
83 # The absolute path to the current Python interpreter.
84 #
85 # Set and exported only in commands run by python_foreach_impl().
86 #
87 # Example value:
88 # @CODE
89 # /usr/bin/python2.6
90 # @CODE
91
92 # @ECLASS-VARIABLE: EPYTHON
93 # @DESCRIPTION:
94 # The executable name of the current Python interpreter.
95 #
96 # This variable is used consistently with python.eclass.
97 #
98 # Set and exported only in commands run by python_foreach_impl().
99 #
100 # Example value:
101 # @CODE
102 # python2.6
103 # @CODE
104
105 # @ECLASS-VARIABLE: PYTHON_SITEDIR
106 # @DESCRIPTION:
107 # The path to Python site-packages directory.
108 #
109 # Set and exported on request using python_export().
110 #
111 # Example value:
112 # @CODE
113 # /usr/lib64/python2.6/site-packages
114 # @CODE
115
116 # @ECLASS-VARIABLE: PYTHON_INCLUDEDIR
117 # @DESCRIPTION:
118 # The path to Python include directory.
119 #
120 # Set and exported on request using python_export().
121 #
122 # Example value:
123 # @CODE
124 # /usr/include/python2.6
125 # @CODE
126
127 # @ECLASS-VARIABLE: PYTHON_LIBPATH
128 # @DESCRIPTION:
129 # The path to Python library.
130 #
131 # Set and exported on request using python_export().
132 # Valid only for CPython.
133 #
134 # Example value:
135 # @CODE
136 # /usr/lib64/libpython2.6.so
137 # @CODE
138
139 # @ECLASS-VARIABLE: PYTHON_PKG_DEP
140 # @DESCRIPTION:
141 # The complete dependency on a particular Python package as a string.
142 #
143 # Set and exported on request using python_export().
144 #
145 # Example value:
146 # @CODE
147 # dev-lang/python:2.7[xml]
148 # @CODE
149
150 # @FUNCTION: python_export
151 # @USAGE: [<impl>] <variables>...
152 # @DESCRIPTION:
153 # Set and export the Python implementation-relevant variables passed
154 # as parameters.
155 #
156 # The optional first parameter may specify the requested Python
157 # implementation (either as PYTHON_TARGETS value, e.g. python2_7,
158 # or an EPYTHON one, e.g. python2.7). If no implementation passed,
159 # the current one will be obtained from ${EPYTHON}.
160 #
161 # The variables which can be exported are: PYTHON, EPYTHON,
162 # PYTHON_SITEDIR. They are described more completely in the eclass
163 # variable documentation.
164 python_export() {
165 debug-print-function ${FUNCNAME} "${@}"
166
167 local impl var
168
169 case "${1}" in
170 python*|jython*)
171 impl=${1/_/.}
172 shift
173 ;;
174 pypy-c*)
175 impl=${1}
176 shift
177 ;;
178 pypy*)
179 local v=${1#pypy}
180 impl=pypy-c${v/_/.}
181 shift
182 ;;
183 *)
184 impl=${EPYTHON}
185 [[ ${impl} ]] || die "python_export: no impl nor EPYTHON"
186 ;;
187 esac
188 debug-print "${FUNCNAME}: implementation: ${impl}"
189
190 for var; do
191 case "${var}" in
192 EPYTHON)
193 export EPYTHON=${impl}
194 debug-print "${FUNCNAME}: EPYTHON = ${EPYTHON}"
195 ;;
196 PYTHON)
197 export PYTHON=${EPREFIX}/usr/bin/${impl}
198 debug-print "${FUNCNAME}: PYTHON = ${PYTHON}"
199 ;;
200 PYTHON_SITEDIR)
201 local dir
202 case "${impl}" in
203 python*)
204 dir=/usr/$(get_libdir)/${impl}
205 ;;
206 jython*)
207 dir=/usr/share/${impl}/Lib
208 ;;
209 pypy*)
210 dir=/usr/$(get_libdir)/${impl/-c/}
211 ;;
212 esac
213
214 export PYTHON_SITEDIR=${EPREFIX}${dir}/site-packages
215 debug-print "${FUNCNAME}: PYTHON_SITEDIR = ${PYTHON_SITEDIR}"
216 ;;
217 PYTHON_INCLUDEDIR)
218 local dir
219 case "${impl}" in
220 python*)
221 dir=/usr/include/${impl}
222 ;;
223 jython*)
224 dir=/usr/share/${impl}/Include
225 ;;
226 pypy*)
227 dir=/usr/$(get_libdir)/${impl/-c/}/include
228 ;;
229 esac
230
231 export PYTHON_INCLUDEDIR=${EPREFIX}${dir}
232 debug-print "${FUNCNAME}: PYTHON_INCLUDEDIR = ${PYTHON_INCLUDEDIR}"
233 ;;
234 PYTHON_LIBPATH)
235 local libname
236 case "${impl}" in
237 python*)
238 libname=lib${impl}
239 ;;
240 *)
241 die "${EPYTHON} lacks a dynamic library"
242 ;;
243 esac
244
245 local path=${EPREFIX}/usr/$(get_libdir)
246
247 export PYTHON_LIBPATH=${path}/${libname}$(get_libname)
248 debug-print "${FUNCNAME}: PYTHON_LIBPATH = ${PYTHON_LIBPATH}"
249 ;;
250 PYTHON_PKG_DEP)
251 local d
252 case ${impl} in
253 python*)
254 PYTHON_PKG_DEP='dev-lang/python';;
255 jython*)
256 PYTHON_PKG_DEP='dev-java/jython';;
257 pypy*)
258 PYTHON_PKG_DEP='dev-python/pypy';;
259 *)
260 die "Invalid implementation: ${impl}"
261 esac
262
263 # slot
264 PYTHON_PKG_DEP+=:${impl##*[a-z-]}
265
266 # use-dep
267 if [[ ${PYTHON_REQ_USE} ]]; then
268 PYTHON_PKG_DEP+=[${PYTHON_REQ_USE}]
269 fi
270
271 export PYTHON_PKG_DEP
272 debug-print "${FUNCNAME}: PYTHON_PKG_DEP = ${PYTHON_PKG_DEP}"
273 ;;
274 *)
275 die "python_export: unknown variable ${var}"
276 esac
277 done
278 }
279
280 # @FUNCTION: python_get_PYTHON
281 # @USAGE: [<impl>]
282 # @DESCRIPTION:
283 # Obtain and print the path to the Python interpreter for the given
284 # implementation. If no implementation is provided, ${EPYTHON} will
285 # be used.
286 #
287 # If you just need to have PYTHON set (and exported), then it is better
288 # to use python_export() directly instead.
289 python_get_PYTHON() {
290 debug-print-function ${FUNCNAME} "${@}"
291
292 python_export "${@}" PYTHON
293 echo "${PYTHON}"
294 }
295
296 # @FUNCTION: python_get_EPYTHON
297 # @USAGE: <impl>
298 # @DESCRIPTION:
299 # Obtain and print the EPYTHON value for the given implementation.
300 #
301 # If you just need to have EPYTHON set (and exported), then it is better
302 # to use python_export() directly instead.
303 python_get_EPYTHON() {
304 debug-print-function ${FUNCNAME} "${@}"
305
306 python_export "${@}" EPYTHON
307 echo "${EPYTHON}"
308 }
309
310 # @FUNCTION: python_get_sitedir
311 # @USAGE: [<impl>]
312 # @DESCRIPTION:
313 # Obtain and print the 'site-packages' path for the given
314 # implementation. If no implementation is provided, ${EPYTHON} will
315 # be used.
316 #
317 # If you just need to have PYTHON_SITEDIR set (and exported), then it is
318 # better to use python_export() directly instead.
319 python_get_sitedir() {
320 debug-print-function ${FUNCNAME} "${@}"
321
322 python_export "${@}" PYTHON_SITEDIR
323 echo "${PYTHON_SITEDIR}"
324 }
325
326 # @FUNCTION: python_get_includedir
327 # @USAGE: [<impl>]
328 # @DESCRIPTION:
329 # Obtain and print the include path for the given implementation. If no
330 # implementation is provided, ${EPYTHON} will be used.
331 #
332 # If you just need to have PYTHON_INCLUDEDIR set (and exported), then it
333 # is better to use python_export() directly instead.
334 python_get_includedir() {
335 debug-print-function ${FUNCNAME} "${@}"
336
337 python_export "${@}" PYTHON_INCLUDEDIR
338 echo "${PYTHON_INCLUDEDIR}"
339 }
340
341 # @FUNCTION: python_get_library_path
342 # @USAGE: [<impl>]
343 # @DESCRIPTION:
344 # Obtain and print the Python library path for the given implementation.
345 # If no implementation is provided, ${EPYTHON} will be used.
346 #
347 # Please note that this function can be used with CPython only. Use
348 # in another implementation will result in a fatal failure.
349 python_get_library_path() {
350 debug-print-function ${FUNCNAME} "${@}"
351
352 python_export "${@}" PYTHON_LIBPATH
353 echo "${PYTHON_LIBPATH}"
354 }
355
356 # @FUNCTION: _python_rewrite_shebang
357 # @INTERNAL
358 # @USAGE: [<EPYTHON>] <path>...
359 # @DESCRIPTION:
360 # Replaces 'python' executable in the shebang with the executable name
361 # of the specified interpreter. If no EPYTHON value (implementation) is
362 # used, the current ${EPYTHON} will be used.
363 #
364 # All specified files must start with a 'python' shebang. A file not
365 # having a matching shebang will be refused. The exact shebang style
366 # will be preserved in order not to break anything.
367 #
368 # Example conversions:
369 # @CODE
370 # From: #!/usr/bin/python -R
371 # To: #!/usr/bin/python2.7 -R
372 #
373 # From: #!/usr/bin/env FOO=bar python
374 # To: #!/usr/bin/env FOO=bar python2.7
375 # @CODE
376 _python_rewrite_shebang() {
377 debug-print-function ${FUNCNAME} "${@}"
378
379 local impl
380 case "${1}" in
381 python*|jython*|pypy-c*)
382 impl=${1}
383 shift
384 ;;
385 *)
386 impl=${EPYTHON}
387 [[ ${impl} ]] || die "${FUNCNAME}: no impl nor EPYTHON"
388 ;;
389 esac
390 debug-print "${FUNCNAME}: implementation: ${impl}"
391
392 local f
393 for f; do
394 local shebang=$(head -n 1 "${f}")
395 local from
396 debug-print "${FUNCNAME}: path = ${f}"
397 debug-print "${FUNCNAME}: shebang = ${shebang}"
398
399 if [[ "${shebang} " == *'python '* ]]; then
400 from=python
401 elif [[ "${shebang} " == *'python2 '* ]]; then
402 from=python2
403 elif [[ "${shebang} " == *'python3 '* ]]; then
404 from=python3
405 else
406 eerror "A file does not seem to have a supported shebang:"
407 eerror " file: ${f}"
408 eerror " shebang: ${shebang}"
409 die "${FUNCNAME}: ${f} does not seem to have a valid shebang"
410 fi
411
412 if [[ ${from} == python2 && ${impl} == python3*
413 || ${from} == python3 && ${impl} != python3* ]]; then
414 eerror "A file does have shebang not supporting requested impl:"
415 eerror " file: ${f}"
416 eerror " shebang: ${shebang}"
417 eerror " impl: ${impl}"
418 die "${FUNCNAME}: ${f} does have shebang not supporting ${EPYTHON}"
419 fi
420
421 sed -i -e "1s:${from}:${impl}:" "${f}" || die
422 done
423 }
424
425 # @FUNCTION: _python_ln_rel
426 # @INTERNAL
427 # @USAGE: <from> <to>
428 # @DESCRIPTION:
429 # Create a relative symlink.
430 _python_ln_rel() {
431 debug-print-function ${FUNCNAME} "${@}"
432
433 local from=${1}
434 local to=${2}
435
436 local frpath=${from%/*}/
437 local topath=${to%/*}/
438 local rel_path=
439
440 while [[ ${topath} ]]; do
441 local frseg= toseg=
442
443 while [[ ! ${frseg} && ${frpath} ]]; do
444 frseg=${frpath%%/*}
445 frpath=${frpath#${frseg}/}
446 done
447
448 while [[ ! ${toseg} && ${topath} ]]; do
449 toseg=${topath%%/*}
450 topath=${topath#${toseg}/}
451 done
452
453 if [[ ${frseg} != ${toseg} ]]; then
454 rel_path=../${rel_path}${frseg:+${frseg}/}
455 fi
456 done
457 rel_path+=${frpath}${1##*/}
458
459 debug-print "${FUNCNAME}: ${from} -> ${to}"
460 debug-print "${FUNCNAME}: rel_path = ${rel_path}"
461
462 ln -fs "${rel_path}" "${to}"
463 }
464
465 # @FUNCTION: python_optimize
466 # @USAGE: [<directory>...]
467 # @DESCRIPTION:
468 # Compile and optimize Python modules in specified directories (absolute
469 # paths). If no directories are provided, the default system paths
470 # are used (prepended with ${D}).
471 python_optimize() {
472 debug-print-function ${FUNCNAME} "${@}"
473
474 [[ ${EPYTHON} ]] || die 'No Python implementation set (EPYTHON is null).'
475
476 local PYTHON=${PYTHON}
477 [[ ${PYTHON} ]] || python_export PYTHON
478
479 # Note: python2.6 can't handle passing files to compileall...
480
481 # default to sys.path
482 if [[ ${#} -eq 0 ]]; then
483 local f
484 while IFS= read -r -d '' f; do
485 # 1) accept only absolute paths
486 # (i.e. skip '', '.' or anything like that)
487 # 2) skip paths which do not exist
488 # (python2.6 complains about them verbosely)
489
490 if [[ ${f} == /* && -d ${D}${f} ]]; then
491 set -- "${D}${f}" "${@}"
492 fi
493 done < <("${PYTHON}" -c 'import sys; print("\0".join(sys.path))')
494
495 debug-print "${FUNCNAME}: using sys.path: ${*/%/;}"
496 fi
497
498 local d
499 for d; do
500 # make sure to get a nice path without //
501 local instpath=${d#${D}}
502 instpath=/${instpath##/}
503
504 case "${EPYTHON}" in
505 python*)
506 "${PYTHON}" -m compileall -q -f -d "${instpath}" "${d}"
507 "${PYTHON}" -OO -m compileall -q -f -d "${instpath}" "${d}"
508 ;;
509 *)
510 "${PYTHON}" -m compileall -q -f -d "${instpath}" "${@}"
511 ;;
512 esac
513 done
514 }
515
516 # @ECLASS-VARIABLE: python_scriptroot
517 # @DEFAULT_UNSET
518 # @DESCRIPTION:
519 # The current script destination for python_doscript(). The path
520 # is relative to the installation root (${ED}).
521 #
522 # When unset, ${DESTTREE}/bin (/usr/bin by default) will be used.
523 #
524 # Can be set indirectly through the python_scriptinto() function.
525 #
526 # Example:
527 # @CODE
528 # src_install() {
529 # local python_scriptroot=${GAMES_BINDIR}
530 # python_foreach_impl python_doscript foo
531 # }
532 # @CODE
533
534 # @FUNCTION: python_scriptinto
535 # @USAGE: <new-path>
536 # @DESCRIPTION:
537 # Set the current scriptroot. The new value will be stored
538 # in the 'python_scriptroot' environment variable. The new value need
539 # be relative to the installation root (${ED}).
540 #
541 # Alternatively, you can set the variable directly.
542 python_scriptinto() {
543 debug-print-function ${FUNCNAME} "${@}"
544
545 python_scriptroot=${1}
546 }
547
548 # @FUNCTION: python_doscript
549 # @USAGE: <files>...
550 # @DESCRIPTION:
551 # Install the given scripts into current python_scriptroot,
552 # for the current Python implementation (${EPYTHON}).
553 #
554 # All specified files must start with a 'python' shebang. The shebang
555 # will be converted, the file will be renamed to be EPYTHON-suffixed
556 # and a wrapper will be installed in place of the original name.
557 #
558 # Example:
559 # @CODE
560 # src_install() {
561 # python_foreach_impl python_doscript ${PN}
562 # }
563 # @CODE
564 python_doscript() {
565 debug-print-function ${FUNCNAME} "${@}"
566
567 local f
568 for f; do
569 python_newscript "${f}" "${f##*/}"
570 done
571 }
572
573 # @FUNCTION: python_newscript
574 # @USAGE: <path> <new-name>
575 # @DESCRIPTION:
576 # Install the given script into current python_scriptroot
577 # for the current Python implementation (${EPYTHON}), and name it
578 # <new-name>.
579 #
580 # The file must start with a 'python' shebang. The shebang will be
581 # converted, the file will be renamed to be EPYTHON-suffixed
582 # and a wrapper will be installed in place of the <new-name>.
583 #
584 # Example:
585 # @CODE
586 # src_install() {
587 # python_foreach_impl python_newscript foo.py foo
588 # }
589 # @CODE
590 python_newscript() {
591 debug-print-function ${FUNCNAME} "${@}"
592
593 [[ ${EPYTHON} ]] || die 'No Python implementation set (EPYTHON is null).'
594 [[ ${#} -eq 2 ]] || die "Usage: ${FUNCNAME} <path> <new-name>"
595
596 local d=${python_scriptroot:-${DESTTREE}/bin}
597 local INSDESTTREE INSOPTIONS
598
599 insinto "${d}"
600 insopts -m755
601
602 local f=${1}
603 local barefn=${2}
604
605 local newfn=${barefn}-${EPYTHON}
606
607 debug-print "${FUNCNAME}: ${f} -> ${d}/${newfn}"
608 newins "${f}" "${newfn}" || die
609 _python_rewrite_shebang "${ED}/${d}/${newfn}"
610
611 # install the wrapper
612 _python_ln_rel "${ED}"/usr/bin/python-exec "${ED}/${d}/${barefn}" || die
613 }
614
615 # @ECLASS-VARIABLE: python_moduleroot
616 # @DEFAULT_UNSET
617 # @DESCRIPTION:
618 # The current module root for python_domodule(). The path can be either
619 # an absolute system path (it must start with a slash, and ${ED} will be
620 # prepended to it) or relative to the implementation's site-packages directory
621 # (then it must start with a non-slash character).
622 #
623 # When unset, the modules will be installed in the site-packages root.
624 #
625 # Can be set indirectly through the python_moduleinto() function.
626 #
627 # Example:
628 # @CODE
629 # src_install() {
630 # local python_moduleroot=bar
631 # # installs ${PYTHON_SITEDIR}/bar/baz.py
632 # python_foreach_impl python_domodule baz.py
633 # }
634 # @CODE
635
636 # @FUNCTION: python_moduleinto
637 # @USAGE: <new-path>
638 # @DESCRIPTION:
639 # Set the current module root. The new value will be stored
640 # in the 'python_moduleroot' environment variable. The new value need
641 # be relative to the site-packages root.
642 #
643 # Alternatively, you can set the variable directly.
644 python_moduleinto() {
645 debug-print-function ${FUNCNAME} "${@}"
646
647 python_moduleroot=${1}
648 }
649
650 # @FUNCTION: python_domodule
651 # @USAGE: <files>...
652 # @DESCRIPTION:
653 # Install the given modules (or packages) into the current
654 # python_moduleroot. The list can mention both modules (files)
655 # and packages (directories). All listed files will be installed
656 # for all enabled implementations, and compiled afterwards.
657 #
658 # Example:
659 # @CODE
660 # src_install() {
661 # # (${PN} being a directory)
662 # python_foreach_impl python_domodule ${PN}
663 # }
664 # @CODE
665 python_domodule() {
666 debug-print-function ${FUNCNAME} "${@}"
667
668 [[ ${EPYTHON} ]] || die 'No Python implementation set (EPYTHON is null).'
669
670 local d
671 if [[ ${python_moduleroot} == /* ]]; then
672 # absolute path
673 d=${python_moduleroot}
674 else
675 # relative to site-packages
676 local PYTHON_SITEDIR=${PYTHON_SITEDIR}
677 [[ ${PYTHON_SITEDIR} ]] || python_export PYTHON_SITEDIR
678
679 d=${PYTHON_SITEDIR#${EPREFIX}}/${python_moduleroot}
680 fi
681
682 local INSDESTTREE
683
684 insinto "${d}"
685 doins -r "${@}" || die
686
687 python_optimize "${ED}/${d}"
688 }
689
690 # @FUNCTION: python_doheader
691 # @USAGE: <files>...
692 # @DESCRIPTION:
693 # Install the given headers into the implementation-specific include
694 # directory. This function is unconditionally recursive, i.e. you can
695 # pass directories instead of files.
696 #
697 # Example:
698 # @CODE
699 # src_install() {
700 # python_foreach_impl python_doheader foo.h bar.h
701 # }
702 # @CODE
703 python_doheader() {
704 debug-print-function ${FUNCNAME} "${@}"
705
706 [[ ${EPYTHON} ]] || die 'No Python implementation set (EPYTHON is null).'
707
708 local d PYTHON_INCLUDEDIR=${PYTHON_INCLUDEDIR}
709 [[ ${PYTHON_INCLUDEDIR} ]] || python_export PYTHON_INCLUDEDIR
710
711 d=${PYTHON_INCLUDEDIR#${EPREFIX}}
712
713 local INSDESTTREE
714
715 insinto "${d}"
716 doins -r "${@}" || die
717 }
718
719 _PYTHON_UTILS_R1=1
720 fi

  ViewVC Help
Powered by ViewVC 1.1.20