%global basever 7.0

Name:           pypy3

Version:        %{basever}.0

%global pyversion 3.5

Release:        2%{?dist}

Summary:        Python 3 implementation with a Just-In-Time compiler

# LGPL and another free license we'd need to ask spot about are present in some

# java jars that we're not building with atm (in fact, we're deleting them

# before building).  If we restore those we'll have to work out the new

# licensing terms

License:        MIT and Python and UCD

URL:            http://pypy.org/

# aarch64: Not available yet

# ppc64: Broken on F29+ https://bugzilla.redhat.com/show_bug.cgi?id=1619601

ExcludeArch: aarch64 %{power64}

# High-level configuration of the build:

# Whether to use RPM build wheels from the python-{pip,setuptools}-wheel package

# Uses upstream bundled prebuilt wheels otherwise

%bcond_without rpmwheels

# PyPy consists of an implementation of an interpreter (with JIT compilation)

# for the full Python language  written in a high-level language, leaving many

# of the implementation details as "pluggable" policies.

#

# The implementation language is then compiled down to .c code, from which we

# obtain a binary.

#

# This allows us to build a near-arbitrary collection of different

# implementations of Python with differing tradeoffs

#

# (As it happens, the implementation language is itself Python, albeit a

# restricted subset "RPython", chosen to making it amenable to being compiled.

# The result implements the full Python language though)

# We could build many different implementations of Python.

# For now, let's focus on the implementation that appears to be receiving the

# most attention upstream: the JIT-enabled build, with all standard

# optimizations

# Building a configuration can take significant time:

# A build of pypy (with jit) on i686 took 77 mins:

#  [Timer] Timings:

#  [Timer] annotate                       ---  583.3 s

#  [Timer] rtype_lltype                   ---  760.9 s

#  [Timer] pyjitpl_lltype                 ---  567.3 s

#  [Timer] backendopt_lltype              ---  375.6 s

#  [Timer] stackcheckinsertion_lltype     ---   54.1 s

#  [Timer] database_c                     ---  852.2 s

#  [Timer] source_c                       --- 1007.3 s

#  [Timer] compile_c                      ---  419.9 s

#  [Timer] ===========================================

#  [Timer] Total:                         --- 4620.5 s

#

# A build of pypy (nojit) on x86_64 took about an hour:

#  [Timer] Timings:

#  [Timer] annotate                       ---  537.5 s

#  [Timer] rtype_lltype                   ---  667.3 s

#  [Timer] backendopt_lltype              ---  385.4 s

#  [Timer] stackcheckinsertion_lltype     ---   42.5 s

#  [Timer] database_c                     ---  625.3 s

#  [Timer] source_c                       --- 1040.2 s

#  [Timer] compile_c                      ---  273.9 s

#  [Timer] ===========================================

#  [Timer] Total:                         --- 3572.0 s

#

#

# A build of pypy-stackless on i686 took about 87 mins:

#  [Timer] Timings:

#  [Timer] annotate                       ---  584.2 s

#  [Timer] rtype_lltype                   ---  777.3 s

#  [Timer] backendopt_lltype              ---  365.9 s

#  [Timer] stackcheckinsertion_lltype     ---   39.3 s

#  [Timer] database_c                     --- 1089.6 s

#  [Timer] source_c                       --- 1868.6 s

#  [Timer] compile_c                      ---  490.4 s

#  [Timer] ===========================================

#  [Timer] Total:                         --- 5215.3 s

# We will build a "pypy" binary.

#

# Unfortunately, the JIT support is only available on some architectures.

#

# rpython/jit/backend/detect_cpu.py:getcpuclassname currently supports the

# following options:

#  'i386', 'x86'

#  'x86-without-sse2':

#  'x86_64'

#  'armv6', 'armv7' (versions 6 and 7, hard- and soft-float ABI)

#  'cli'

#  'llvm'

#

# We will only build with JIT support on those architectures, and build without

# it on the other archs.  The resulting binary will typically be slower than

# CPython for the latter case.

%ifarch %{ix86} x86_64 %{arm} %{power64} s390x

%global with_jit 1

%else

%global with_jit 0

%endif

# Should we build a "pypy-stackless" binary?

%global with_stackless 0

# Should we build the emacs JIT-viewing mode?

%if 0%{?rhel} == 6

%global with_emacs 0

%else

%global with_emacs 1

%endif

# Easy way to enable/disable verbose logging:

%global verbose_logs 0

# Forcibly use the shadow-stack option for detecting GC roots, rather than

# relying on hacking up generated assembler with regexps:

%global shadow_stack 1

# Easy way to turn off the selftests:

%global run_selftests 1

%global pypyprefix %{_libdir}/pypy3-%{basever}

%global pylibver 3

# We refer to this subdir of the source tree in a few places during the build:

%global goal_dir pypy/goal

# Turn off the brp-python-bytecompile postprocessing script

# We manually invoke it later on, using the freshly built pypy binary

%global __os_install_post \

  %(echo '%{__os_install_post}' | sed -e 's!/usr/lib[^[:space:]]*/brp-python-bytecompile[[:space:]].*$!!g')

# Source and patches:

Source0: https://bitbucket.org/pypy/pypy/downloads/pypy%{pyversion}-v%{version}-src.tar.bz2

# Supply various useful RPM macros for building python modules against pypy:

#  __pypy, pypy_sitelib, pypy_sitearch

Source2: macros.pypy3

# By default, if built at a tty, the translation process renders a Mandelbrot

# set to indicate progress.

# This obscures useful messages, and may waste CPU cycles, so suppress it, and

# merely render dots:

Patch1: 001-nevertty.patch

# Patch pypy.translator.platform so that stdout from "make" etc gets logged,

# rather than just stderr, so that the command-line invocations of the compiler

# and linker are captured:

Patch6: 006-always-log-stdout.patch

# Disable the printing of a quote from IRC on startup (these are stored in

# ROT13 form in lib_pypy/_pypy_irc_topic.py).  Some are cute, but some could

# cause confusion for end-users (and many are in-jokes within the PyPy

# community that won't make sense outside of it).  [Sorry to be a killjoy]

Patch7: 007-remove-startup-message.patch

# Glibc's libcrypt was replaced with libxcrypt in f28, crypt.h header has

# to be added to privent compilation error.

# https://fedoraproject.org/wiki/Changes/Replace_glibc_libcrypt_with_libxcrypt

Patch9: 009-add-libxcrypt-support.patch

# It seems ppc64 has no faulthandler

Patch11: 011-no-faulthandler.patch

# Instead of bundled wheels, use our RPM packaged wheels from

# /usr/share/python-wheels

# We conditionally apply this, but we use autosetup, so we use Source here

Source189: 189-use-rpm-wheels.patch

# Build-time requirements:

# pypy's can be rebuilt using itself, rather than with CPython; doing so

# halves the build time.

#

# Turn it off with this boolean, to revert back to rebuilding using CPython

# and avoid a cycle in the build-time dependency graph:

# Note, pypy3 is built with pypy2, so no dependency cycle

%ifarch %{power64}

# the build is unreliable with pypy+power, getting random failures

# so better have a bit slower build than having to build until it pass

%global use_self_when_building 0

%else

%global use_self_when_building 1

%endif

%if 0%{use_self_when_building}

# pypy3 can only be build with pypy2

BuildRequires: pypy2

# no pypy-pycparser available ATM

%global bootstrap_python_interp pypy2

%else

# pypy3 can only be build with python2

BuildRequires: python2-devel

BuildRequires: python2-pycparser

%global bootstrap_python_interp python2

%endif

BuildRequires:  gcc

BuildRequires:  libffi-devel

BuildRequires:  tcl-devel

BuildRequires:  tk-devel

BuildRequires:  sqlite-devel

BuildRequires:  zlib-devel

BuildRequires:  bzip2-devel

BuildRequires:  ncurses-devel

BuildRequires:  expat-devel

BuildRequires:  openssl-devel

BuildRequires:  gdbm-devel

BuildRequires:  xz-devel

%ifnarch s390

BuildRequires:  valgrind-devel

%endif

%if %{run_selftests}

# Used by the selftests, though not by the build:

BuildRequires:  gc-devel

# For use in the selftests, for recording stats:

BuildRequires:  time

BuildRequires:  /usr/bin/free

# For use in the selftests, for imposing a per-test timeout:

BuildRequires:  perl-interpreter

%endif

BuildRequires:  /usr/bin/execstack

# For byte-compiling the JIT-viewing mode:

%if %{with_emacs}

BuildRequires:  emacs

%endif

# For %%autosetup -S git

BuildRequires:  %{_bindir}/git

%if %{with rpmwheels}

BuildRequires: python-setuptools-wheel

BuildRequires: python-pip-wheel

%endif

# Metadata for the core package (the JIT build):

Requires: %{name}-libs%{?_isa} = %{version}-%{release}

Provides: %{name}(abi) = %{basever}

Provides: pypy%{pyversion} = %{version}-%{release}

Provides: pypy%{pyversion}%{?_isa} = %{version}-%{release}

%description

PyPy's implementation of Python 3, featuring a Just-In-Time compiler on some CPU

architectures, and various optimized implementations of the standard types

(strings, dictionaries, etc)

%if 0%{with_jit}

This build of PyPy has JIT-compilation enabled.

%else

This build of PyPy has JIT-compilation disabled, as it is not supported on this

CPU architecture.

%endif

%package libs

Summary:  Run-time libraries used by PyPy implementations of Python 3

# We supply an emacs mode for the JIT viewer.

# (This doesn't bring in all of emacs, just the directory structure)

%if %{with_emacs}

Requires: emacs-filesystem >= %{_emacs_version}

%endif

Provides: pypy%{pyversion}-libs = %{version}-%{release}

Provides: pypy%{pyversion}-libs%{?_isa} = %{version}-%{release}

%if %{with rpmwheels}

Requires: python-setuptools-wheel

Requires: python-pip-wheel

%else

Provides: bundled(python3-pip) = 9.0.1

Provides: bundled(python3-setuptools) = 28.8.0

%endif

%description libs

Libraries required by the various PyPy implementations of Python 3.

%package devel

Summary:  Development tools for working with PyPy3

Requires: pypy3%{?_isa} = %{version}-%{release}

Provides: pypy%{pyversion}-devel = %{version}-%{release}

Provides: pypy%{pyversion}-devel%{?_isa} = %{version}-%{release}

%description devel

Header files for building C extension modules against PyPy3

%if 0%{with_stackless}

%package stackless

Summary:  Stackless Python interpreter built using PyPy3

Requires: pypy3-libs%{?_isa} = %{version}-%{release}

Provides: pypy%{pyversion}-stackless = %{version}-%{release}

Provides: pypy%{pyversion}-stackless%{?_isa} = %{version}-%{release}

%description stackless

Build of PyPy3 with support for micro-threads for massive concurrency

%endif

%prep

%autosetup -n pypy%{pyversion}-v%{version}-src -p1 -S git

# While this is 7.0.0, it has 7.1.0-alpha0 listed inside

# We sed it out to avoid user confusion

sed -i 's/7\.1\.0/7.0.0/' pypy/doc/conf.py

sed -i 's/7\.1\.0-alpha0/7.0.0/g' pypy/module/cpyext/include/patchlevel.h pypy/doc/how-to-release.rst

sed -i 's/0x07010000/0x07000000/' pypy/module/cpyext/include/patchlevel.h

sed -i 's/7, 1, 0, "alpha"/7, 0, 0, "final"/' pypy/module/sys/version.py

%if %{with rpmwheels}

%apply_patch -m %(basename %{SOURCE189}) %{SOURCE189}

rm lib-python/3/ensurepip/_bundled/*.whl

rmdir lib-python/3/ensurepip/_bundled

%else

# we don't want to ship the old ones anyway

rm lib-python/3/ensurepip/_bundled/pip-8.1.2-*

rm lib-python/3/ensurepip/_bundled/setuptools-21.2.1-*

%endif

# Replace /usr/local/bin/python or /usr/bin/env python shebangs with /usr/bin/python2 or pypy2:

find -name "*.py" -exec \

  sed \

    -i -r -e "s@/usr/(local/)?bin/(env )?python(2|3)?@/usr/bin/%{bootstrap_python_interp}@" \

    "{}" \

    \;

for f in rpython/translator/goal/bpnn.py ; do

   # Detect shebang lines && remove them:

   sed -e '/^#!/Q 0' -e 'Q 1' $f \

      && sed -i '1d' $f

   chmod a-x $f

done

# Replace all lib-python and lib_pypy python shebangs with pypy3 (those will be shipped with pypy3-libs)

find lib-python/%{pylibver} lib_pypy -name "*.py" -exec \

  sed -r -i '1s@^#!\s*/usr/bin.*(python|pypy).*@#!/usr/bin/%{name}@' \

    "{}" \

    \;

# Not needed on Linux

rm lib-python/3/idlelib/idle.bat

%ifarch %{ix86} x86_64 %{arm}

  sed -i -r 's/\$\(LDFLAGSEXTRA\)/& -fuse-ld=gold/' ./rpython/translator/platform/posix.py

%endif

%build

%ifarch s390 s390x

# pypy3 requires z10 at least

%global optflags %(echo %{optflags} | sed 's/-march=z9-109 /-march=z10 /')

%endif

# Top memory usage is about 4.5GB on arm7hf

free

BuildPyPy() {

  ExeName=$1

  Options=$2

  echo "--------------------------------------------------------------"

  echo "--------------------------------------------------------------"

  echo "--------------------------------------------------------------"

  echo "STARTING BUILD OF: $ExeName"

  echo "--------------------------------------------------------------"

  echo "--------------------------------------------------------------"

  echo "--------------------------------------------------------------"

  pushd %{goal_dir}

  # The build involves invoking a python script, passing in particular

  # arguments, environment variables, etc.

  # Some notes on those follow:

  # The generated binary embeds copies of the values of all environment

  # variables.  We need to unset "RPM_BUILD_ROOT" to avoid a fatal error from

  #  /usr/lib/rpm/check-buildroot

  # during the postprocessing of the rpmbuild, complaining about this

  # reference to the buildroot

  # By default, pypy's autogenerated C code is placed in

  #    /tmp/usession-N

  #  

  # and it appears that this stops rpm from extracting the source code to the

  # debuginfo package

  #

  # The logic in pypy-1.4/pypy/tool/udir.py indicates that it is generated in:

  #    $PYPY_USESSION_DIR/usession-$PYPY_USESSION_BASENAME-N    

  # and so we set PYPY_USESSION_DIR so that this tempdir is within the build

  # location, and set $PYPY_USESSION_BASENAME so that the tempdir is unique

  # for each invocation of BuildPyPy

  # Compilation flags for C code:

  #   pypy-1.4/pypy/translator/c/genc.py:gen_makefile

  # assembles a Makefile within

  #   THE_UDIR/testing_1/Makefile

  # calling out to platform.gen_makefile

  # For us, that's

  #   pypy-1.4/pypy/translator/platform/linux.py: class BaseLinux(BasePosix):

  # which by default has:

  #   CFLAGS = ['-O3', '-pthread', '-fomit-frame-pointer',

  #             '-Wall', '-Wno-unused']

  # plus all substrings from CFLAGS in the environment.

  # This is used to generate a value for CFLAGS that's written into the Makefile

  # How will we track garbage-collection roots in the generated code?

  #   http://pypy.readthedocs.org/en/latest/config/translation.gcrootfinder.html

%if 0%{shadow_stack}

  # This is the most portable option, and avoids a reliance on non-guaranteed

  # behaviors within GCC's code generator: use an explicitly-maintained stack

  # of root pointers:

  %global gcrootfinder_options --gcrootfinder=shadowstack

  export CFLAGS=$(echo "$RPM_OPT_FLAGS")

%else

  # Go with the default, which is "asmgcc"

  %global gcrootfinder_options %{nil}

  # https://bugzilla.redhat.com/show_bug.cgi?id=588941#c18

  # The generated Makefile compiles the .c files into assembler (.s), rather

  # than direct to .o  It then post-processes this assembler to locate

  # garbage-collection roots (building .lbl.s and .gcmap files, and a

  # "gcmaptable.s").  (The modified .lbl.s files have extra code injected

  # within them).

  # Unfortunately, the code to do this:

  #   pypy-1.4/pypy/translator/c/gcc/trackgcroot.py

  # doesn't interract well with the results of using our standard build flags.

  # For now, filter our CFLAGS of everything that could be conflicting with

  # pypy.  Need to check these and reenable ones that are okay later.

  # Filed as https://bugzilla.redhat.com/show_bug.cgi?id=666966

  export CFLAGS=$(echo "$RPM_OPT_FLAGS" | sed -e 's/-Wp,-D_FORTIFY_SOURCE=2//' -e 's/-fexceptions//' -e 's/-fstack-protector//' -e 's/--param=ssp-buffer-size=4//' -e 's/-O2//' -e 's/-fasynchronous-unwind-tables//' -e 's/-march=i686//' -e 's/-mtune=atom//')

%endif

  # The generated C code leads to many thousands of warnings of the form:

  #   warning: variable 'l_v26003' set but not used [-Wunused-but-set-variable]

  # Suppress them:

  export CFLAGS=$(echo "$CFLAGS" -Wno-unused -fPIC)

  # If we're already built the JIT-enabled "pypy", then use it for subsequent

  # builds (of other configurations):

  if test -x './pypy' ; then

    INTERP='./pypy'

  else

    # First pypy build within this rpm build?

    # Fall back to using the bootstrap python interpreter, which might be a

    # system copy of pypy from an earlier rpm, or be cpython's /usr/bin/python:

    INTERP='%{bootstrap_python_interp}'

  fi

  # Here's where we actually invoke the build:

  time \

    RPM_BUILD_ROOT= \

    PYPY_USESSION_DIR=$(pwd) \

    PYPY_USESSION_BASENAME=$ExeName \

    $INTERP ../../rpython/bin/rpython  \

    %{gcrootfinder_options} \

    $Options \

    targetpypystandalone

  echo "--------------------------------------------------------------"

  echo "--------------------------------------------------------------"

  echo "--------------------------------------------------------------"

  echo "FINISHED BUILDING: $ExeName"

  echo "--------------------------------------------------------------"

  echo "--------------------------------------------------------------"

  echo "--------------------------------------------------------------"

  popd

}

BuildPyPy \

  pypy3 \

%if 0%{with_jit}

  "-Ojit" \

%else

  "-O2" \

%endif

  %{nil}

%if 0%{with_stackless}

BuildPyPy \

  pypy3-stackless \

   "--stackless"

%endif

%if %{with_emacs}

%{_emacs_bytecompile} rpython/jit/tool/pypytrace-mode.el

%endif

%install

mkdir -p %{buildroot}/%{_bindir}

mkdir -p %{buildroot}/%{pypyprefix}

# Run installing script,  archive-name  %{name}-%{basever} in %{buildroot}/%{_libdir} == %{pypyprefix}

%{bootstrap_python_interp} pypy/tool/release/package.py --archive-name %{name}-%{basever} --builddir %{buildroot}/%{_libdir}

# Remove shebang lines from .py files that aren't executable, and

# remove executability from .py files that don't have a shebang line:

find \

  %{buildroot}                                                           \

  -name "*.py"                                                           \

    \(                                                                   \

       \( \! -perm /u+x,g+x,o+x -exec sed -e '/^#!/Q 0' -e 'Q 1' {} \;   \

             -print -exec sed -i '1d' {} \;                              \

          \)                                                             \

       -o                                                                \

       \(                                                                \

             -perm /u+x,g+x,o+x ! -exec grep -m 1 -q '^#!' {} \;         \

             -exec chmod a-x {} \;                                       \

        \)                                                               \

    \)

mkdir -p %{buildroot}/%{pypyprefix}/site-packages

# The generated machine code doesn't need an executable stack,  but

# one of the assembler files (gcmaptable.s) doesn't have the necessary

# metadata to inform gcc of that, and thus gcc pessimistically assumes

# that the built binary does need an executable stack.

#

# Reported upstream as: https://codespeak.net/issue/pypy-dev/issue610

#

# I tried various approaches involving fixing the build, but the simplest

# approach is to postprocess the ELF file:

execstack --clear-execstack %{buildroot}/%{pypyprefix}/bin/pypy3

ln -s ./pypy3 %{buildroot}%{pypyprefix}/bin/pypy%{pyversion}

ln -s %{pypyprefix}/bin/pypy%{pyversion} %{buildroot}%{_bindir}/pypy%{pyversion}

ln -s pypy%{pyversion} %{buildroot}%{_bindir}/pypy3

# pypy uses .pyc files by default (--objspace-usepycfiles), but has a slightly

# different bytecode format to CPython.  It doesn't use .pyo files: the -O flag

# is treated as a "dummy optimization flag for compatibility with C Python"

#

# pypy-1.4/pypy/module/imp/importing.py has this comment:

    # XXX picking a magic number is a mess.  So far it works because we

    # have only two extra opcodes, which bump the magic number by +1 and

    # +2 respectively, and CPython leaves a gap of 10 when it increases

    # its own magic number.  To avoid assigning exactly the same numbers

    # as CPython we always add a +2.  We'll have to think again when we

    # get at the fourth new opcode :-(

    #

    #  * CALL_LIKELY_BUILTIN    +1

    #  * CALL_METHOD            +2

    #

    # In other words:

    #

    #     default_magic        -- used by CPython without the -U option

    #     default_magic + 1    -- used by CPython with the -U option

    #     default_magic + 2    -- used by PyPy without any extra opcode

    #     ...

    #     default_magic + 5    -- used by PyPy with both extra opcodes

#

# pypy-1.4/pypy/interpreter/pycode.py has:

#

#  default_magic = (62141+2) | 0x0a0d0000                  # this PyPy's magic

#                                                          # (62131=CPython 2.5.1)

# giving a value for "default_magic" for PyPy of 0xa0df2bf.

# Note that this corresponds to the "default_magic + 2" from the comment above

# In my builds:

#   $ ./pypy --info | grep objspace.opcodes

#                objspace.opcodes.CALL_LIKELY_BUILTIN: False

#                        objspace.opcodes.CALL_METHOD: True

# so I'd expect the magic number to be:

#    0x0a0df2bf + 2 (the flag for CALL_METHOD)

# giving

#    0x0a0df2c1

#

# I'm seeing

#   c1 f2 0d 0a

# as the first four bytes of the .pyc files, which is consistent with this.

# Bytecompile all of the .py files we ship, using our pypy binary, giving us

# .pyc files for pypy.  The script actually does the work twice (passing in -O

# the second time) but it's simplest to reuse that script.

#

# The script has special-casing for .py files below

#    /usr/lib{64}/python[0-9].[0-9]

# but given that we're installing into a different path, the supplied "default"

# implementation gets used instead.

#

# Note that some of the test files deliberately contain syntax errors, so

# we pass 0 for the second argument ("errors_terminate"):

/usr/lib/rpm/brp-python-bytecompile \

  %{buildroot}%{pypyprefix}/bin/pypy3 \

  0

%{buildroot}%{pypyprefix}/bin/pypy3 -c 'import _tkinter'

%{buildroot}%{pypyprefix}/bin/pypy3 -c 'import tkinter'

%{buildroot}%{pypyprefix}/bin/pypy3 -c 'import _sqlite3'

%{buildroot}%{pypyprefix}/bin/pypy3 -c 'import _curses'

%{buildroot}%{pypyprefix}/bin/pypy3 -c 'import curses'

%{buildroot}%{pypyprefix}/bin/pypy3 -c 'import syslog'

%{buildroot}%{pypyprefix}/bin/pypy3 -c 'from _sqlite3 import *'

# Header files for C extension modules.

# Upstream's packaging process (pypy/tool/release/package.py)

# creates an "include" subdir and copies all *.h/*.inl from "include" there

# (it also has an apparently out-of-date comment about copying them from

# pypy/_interfaces, but this directory doesn't seem to exist, and it doesn't

# seem to do this as of 2011-01-13)

# FIXME: arguably these should be instead put into a subdir below /usr/include,

# it's not yet clear to me how upstream plan to deal with the C extension

# interface going forward, so let's just mimic upstream for now.

%global pypy_include_dir  %{pypyprefix}/include

mkdir -p %{buildroot}%{pypy_include_dir}

rm -f %{buildroot}%{pypy_include_dir}/README

# Capture the RPython source code files from the build within the debuginfo

# package (rhbz#666975)

%global pypy_debuginfo_dir /usr/src/debug/pypy-%{version}-src

mkdir -p %{buildroot}%{pypy_debuginfo_dir}

# copy over everything:

cp -a pypy %{buildroot}%{pypy_debuginfo_dir}

# ...then delete files that aren't:

#   - *.py files

#   - the Makefile

#   - typeids.txt

#   - dynamic-symbols-*

find \

  %{buildroot}%{pypy_debuginfo_dir}  \

  \( -type f                         \

     -a                              \

     \! \( -name "*.py"              \

           -o                        \

           -name "Makefile"          \

           -o                        \

           -name "typeids.txt"       \

           -o                        \

           -name "dynamic-symbols-*" \

        \)                           \

  \)                                 \

  -delete

# Alternatively, we could simply keep everything.  This leads to a ~350MB

# debuginfo package, but it makes it easy to hack on the Makefile and C build

# flags by rebuilding/linking the sources.

# To do so, remove the above "find" command.

# We don't need bytecode for these files; they are being included for reference

# purposes.

# There are some rpmlint warnings from these files:

#   non-executable-script

#   wrong-script-interpreter

#   zero-length

#   script-without-shebang

#   dangling-symlink

# but given that the objective is to preserve a copy of the source code, those

# are acceptable.

# Install the JIT trace mode for Emacs:

%if %{with_emacs}

mkdir -p %{buildroot}/%{_emacs_sitelispdir}

cp -a rpython/jit/tool/pypytrace-mode.el %{buildroot}/%{_emacs_sitelispdir}/pypy3trace-mode.el

cp -a rpython/jit/tool/pypytrace-mode.elc %{buildroot}/%{_emacs_sitelispdir}/pypy3trace-mode.elc

%endif

# Install macros for rpm:

install -m0644 -p -D -t %{buildroot}/%{_rpmconfigdir}/macros.d %{SOURCE2}

# Remove files we don't want:

rm -f %{buildroot}%{_libdir}/%{name}-%{basever}.tar.bz2 \

   %{buildroot}%{pypyprefix}/LICENSE \

   %{buildroot}%{pypyprefix}/README.rst

# wtf? This is probably masking some bigger problem, but let's do this for now

mv -v lib-python/3/test/regrtest.py-new lib-python/3/test/regrtest.py || :

# since 5.10.0, the debug binaries are built and shipped, making the

# pypy3 package ~350 MiB. let's remove them here for now and TODO figure out why

rm -f %{buildroot}%{pypyprefix}/bin/pypy3.debug

rm -f %{buildroot}%{pypyprefix}/bin/libpypy3-c.so.debug

%check

topdir=$(pwd)

SkipTest() {

    TEST_NAME=$1

    sed -i -e"s|^$TEST_NAME$||g" testnames.txt

}

CheckPyPy() {

    # We'll be exercising one of the freshly-built binaries using the

    # test suite from the standard library (overridden in places by pypy's

    # modified version)