From Fedora Project Wiki

(Redirected page to Packaging:MinGW)
 
(One intermediate revision by the same user not shown)
Line 1: Line 1:
= Packaging Guidelines for MinGW Cross Compilers =
+
#REDIRECT [[Packaging:MinGW]]
 
 
{{admon/important|Future Guidelines|While these guidelines have been approved, they are not yet active. When Fedora contains the necessary MinGW components for these guidelines to be applicable, they will be activated. Current guidelines for all Fedora releases (including RHEL-6 and older) can be found here: [[Packaging:MinGW]] }}
 
 
 
 
 
= Introduction =
 
 
 
The Fedora MinGW project's mission is to provide an excellent development environment for Fedora users who wish to cross-compile their programs to run on Windows, minimizing the need to use Windows at all.  In the past developers have had to port and compile all of the libraries and tools they have needed, and this huge effort has happened independently many times over.  We aim to eliminate duplication of work for application developers by providing a range of libraries and development tools which have already been ported to the MinGW cross-compiler environment.  This means that developers will not need to recompile the application stack themselves, but can concentrate just on the changes needed to their own application.
 
 
 
As of Fedora 16 a set of RPM macros and packages have been introduced which help packagers compile binaries for multiple targets. The targets Win32 and Win64 will be supported.
 
 
 
= Track Fedora native package versions =
 
 
 
In general terms, cross-compiled MinGW versions of packages which are already natively available in Fedora, should follow the native Fedora package as closely as possible. This means they should stay at the same version, include all the same patches as the native
 
Fedora package, and be built with the same configuration options.
 
 
 
The MinGW SIG have written an RPM comparison tool which makes it possible to compare cross compiled MinGW packages with the Fedora native packages, in order to determine whether versions, patches and configuration are aligned.
 
 
 
= Follow Fedora policy =
 
 
 
Cross compiled MinGW packages must follow Fedora policy, except where noted in this document. Cross compiled packages go through the same review process, GIT admin process etc as other Fedora packages.
 
 
 
= Package naming =
 
 
 
MinGW source packages should be named by prefixing the Fedora native package name with <code>mingw-</code>.  The packages generated from this should be prefixed according to which platform they're being built for:
 
{|
 
| <code>mingw32-</code> || Used for packages which are built for Win32
 
|-
 
| <code>mingw64-</code> || Used for packages which are built for Win64
 
|}
 
 
 
{{admon/warning|Binary packages always specify platform|This means that there should never be built binary packages which are simply named <code>mingw-</code>.  The binary package names should all specify their platform.  This is achieved by having <code>%files -n mingw32-foo</code> and <code>%files -n mingw64-foo</code> section <b>but not</b> a <code>%files</code> section.}}
 
 
 
= Base packages =
 
 
 
The base packages provide a root filesystem, base libraries, binutils (basic programs like 'strip', 'ld' etc), the compiler (gcc) and the Win32/Win64 API.  Packages may need to depend on one or more of these. In particular, almost all packages should BuildRequire <code>mingw-filesystem</code>, <code>mingw32-gcc</code> and <code>mingw64-gcc</code>. The correct Requires flags will get added automatically when the __find_requires macro is overridden (as will be described later on in these guidelines)
 
 
 
{|
 
| <code>mingw-filesystem</code> || Core filesystem directory layout, and RPM macros for spec files.  Equivalent to 'filesystem' RPM
 
|-
 
| <code>mingw32-binutils</code> / <code>mingw64-binutils</code> || Cross-compiled binutils (utilities like 'strip', 'as', 'ld') which understand Windows executables and DLLs.  Equivalent to 'binutils' RPM
 
|-
 
| <code>mingw32-gcc</code> / <code>mingw64-gcc</code> || GNU compiler collection.  Compilers for C and C++ which cross-compile to a Windows target.  Equivalent to gcc RPM
 
|-
 
| <code>mingw32-crt</code> / <code>mingw64-crt</code> || Base libraries for core MinGW runtime & development environment.  Equivalent to 'glibc' RPM
 
|-
 
| <code>mingw32-headers</code> / <code>mingw64-headers</code> || Win32 and Win64 API.  A free (public domain) reimplementation of the header files required to link to the Win32 and Win64 API.  No direct equivalent in base Fedora - glibc-devel is closest
 
|}
 
 
 
= Build for multiple targets =
 
 
 
The goal of the MinGW framework is to provide an easy way for package maintainers to build their packages for multiple targets using one .spec file. To aid developers in this several RPM macros have been developed which are part of the mingw-filesystem package.
 
These RPM macros will be explained later on in these guidelines.
 
 
 
Several RPM macros depend on the package name minus the prefix, so each package must contain <code>%global mingw_pkg_name foo</code> (where <code>foo</code> is the name of the package, for example glib2)
 
 
 
To indicate which targets should be build, the package must contain at least one of the following lines:
 
{|
 
| <code>%global mingw_build_win32 1</code> || Build for the Win32 target
 
|-
 
| <code>%global mingw_build_win64 1</code> || Build for the Win64 target
 
|}
 
 
 
= One source RPM, separate binary RPMs per-target =
 
 
 
Each cross compiled MinGW package which builds binaries for a specific target should put the binaries for that target in a separate subpackage. So if a package <code>foo</code> builds binaries for the Win32 and Win64 targets, then the source RPM should provide two subpackages named <code>mingw32-foo</code> and <code>mingw64-foo</code>.
 
 
 
The main package (<code>mingw-foo</code> in our example) must have <code>Requires: xxx</code> tags for all the targets. To aid in this, the RPM macro <code>%{?mingw_default_requires}</code> should be added to the spec file.
 
 
 
This means that a spec file must contains %package and %files sections for all the targets.
 
 
 
If a package contains translations then all calls to the <code>%find_lang</code> must be replaced by <code>%mingw_find_lang</code>.
 
This causes all translation filelists to be split in per-target filelists.
 
For example: when a spec file contains something like this:
 
<pre>
 
%global mingw_build_win32 1
 
%global mingw_build_win64 1
 
<snip>
 
%install
 
<snip>
 
%mingw_find_lang foo
 
</pre>
 
then two files will get created named <code>mingw32-foo.lang</code> and <code>mingw64-foo.lang</code>.
 
These file lists can be included in the %files section for the targets:
 
<pre>
 
%files -n mingw32-foo -f mingw32-foo.lang
 
<snip>
 
%files -n mingw64-foo -f mingw64-foo.lang
 
</pre>
 
 
 
= Filesystem layout =
 
 
 
[root]
 
  |
 
  +- etc
 
  |  |
 
  |  +- rpm
 
  |      |
 
  |      +- macros.mingw
 
  |      +- macros.mingw32
 
  |      +- macros.mingw64
 
  |
 
  +- usr
 
      |
 
      +- bin  - Links to MinGW cross compiler toolchain
 
      |  |
 
      |  +- i686-w64-mingw32-cpp
 
      |  +- i686-w64-mingw32-gcc
 
      |  +- i686-w64-mingw32-g++
 
      |  +- x86_64-w64-mingw32-cpp
 
      |  +- x86_64-w64-mingw32-gcc
 
      |  +- x86_64-w64-mingw32-g++
 
      |  +- ... etc..
 
      |
 
      +- lib
 
      |  |
 
      |  +- rpm
 
      |      |
 
      |      +- mingw-find-debuginfo.sh - extract debug information from Win32 and Win64 binaries
 
      |      +- mingw-find-lang.sh - generates per-target file lists containing translations
 
      |      +- mingw-find-provides.sh - extra DLL names
 
      |      +- mingw-find-requires.sh - discover required DLL names
 
      |
 
      +- i686-w64-mingw32  - root of mingw toolchain and binaries for the Win32 target - see next diagram
 
      +- x86_64-w64-mingw32  - root of mingw toolchain and binaries for the Win64 target - see next diagram
 
 
 
 
 
/usr/i686-w64-mingw32
 
/usr/x86_64-w64-mingw32
 
  |
 
  +- bin  - Binutils toolchain binaries for the target
 
  |  |
 
  |  +- ar
 
  |  +- as
 
  |  +- dlltool
 
  |  +- ld
 
  |  +- ... etc ...
 
  |
 
  +- lib  - Binutils toolchain support libraries / files for the target
 
  |
 
  +- sys-root  - root for cross compiled MinGW binaries
 
      |
 
      +- mingw
 
          |
 
          +- bin    - cross-compiled MinGW binaries & runtime DLL parts
 
          +- etc    - configuration files
 
          +- include - include files for cross compiled MinGW libs
 
          +- lib    - cross-compiled static MinGW libraries & linktime DLL parts
 
          |  |
 
          |  +- pkgconfig  - pkg-config definitions for libraries
 
          |
 
          +- share
 
              |
 
              +- man
 
 
 
= Filenames of the cross-compilers and binutils =
 
 
 
The MinGW cross-compilers and binutils are Fedora binaries and are therefore placed in <code>%{_bindir}</code> (ie. <code>/usr/bin</code>) according to the FHS and Fedora guidelines.
 
 
 
The MinGW cross-compilers and binutils which generate i686 binaries for Windows are named:
 
<pre>
 
%{_bindir}/i686-w64-mingw32-gcc
 
%{_bindir}/i686-w64-mingw32-g++
 
%{_bindir}/i686-w64-mingw32-ld
 
%{_bindir}/i686-w64-mingw32-as
 
%{_bindir}/i686-w64-mingw32-strip
 
etc.
 
</pre>
 
 
 
The same binaries are present in
 
<code>%{_prefix}/i686-w64-mingw32/bin</code> without any prefix in the
 
name, ie:
 
<pre>
 
%{_prefix}/i686-w64-mingw32/bin/gcc
 
%{_prefix}/i686-w64-mingw32/bin/g++
 
%{_prefix}/i686-w64-mingw32/bin/ld
 
%{_prefix}/i686-w64-mingw32/bin/as
 
%{_prefix}/i686-w64-mingw32/bin/strip
 
etc.
 
</pre>
 
 
 
The same also applies for the x86_64 target. This target uses 'x86_64-w64-mingw32' as prefix instead of 'i686-w64-mingw32'
 
 
 
= Naming of the root filesystem =
 
 
 
The root filesystem contains Windows executables and DLLs and any other Windows-only files.  It is necessary both because we need to store Windows libraries in order to link further libraries which depend on them, and also because MinGW requires a root filesystem location.
 
 
 
The location for Win32 target is provided by the macro:
 
<pre>
 
%{mingw32_sysroot}  %{_prefix}/i686-w64-mingw32/sys-root
 
</pre>
 
And the Win64 target is provided by the macro:
 
<pre>
 
%{mingw64_sysroot}  %{_prefix}/x86_64-w64-mingw32/sys-root
 
</pre>
 
 
 
= Standard mingw RPM macros =
 
 
 
The <code>mingw-filesystem</code> package provides a number of convenience macros for the cross compiled sysroot directories, and
 
toolchain. It is mandatory to use these macros in all MinGW cross compiled packages submitted to Fedora.
 
 
 
== Toolchain macros ==
 
 
 
The following macros are for the %build and %install section of the spec
 
 
 
Generic macros:
 
{|
 
| mingw_cmake  || Call the cmake binary for all the configured targets (mingw_build_win32/mingw_build_win64)
 
|-
 
| mingw_configure || Call the configure command for all the configured targets (mingw_build_win32/mingw_build_win64)
 
|-
 
| mingw_make  || Call the 'make' command for all the configured targets (mingw_build_win32/mingw_build_win64)
 
|-
 
| mingw_make_install  || Call the 'make install' command for all the configured targets (mingw_build_win32/mingw_build_win64)
 
|-
 
| mingw_objcopy || cross compiler 'objcopy' binary (which supports both Win32 and Win64 binaries)
 
|-
 
| mingw_objdump || cross compiler 'objdump' binary (which supports both Win32 and Win64 binaries)
 
|-
 
| mingw_strip || cross compiler 'strip' binary (which supports both Win32 and Win64 binaries)
 
|}
 
 
 
 
 
Win32 specific macros:
 
{|
 
| mingw32_ar || i686-w64-mingw32-ar || cross compiler 'ar' binary
 
|-
 
| mingw32_cc || i686-w64-mingw32-gcc || cross compiler 'gcc' binary
 
|-
 
| mingw32_cflags  || -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions --param=ssp-buffer-size=4 -mms-bitfields|| Default compiler flags for C/C++ binaries
 
|-
 
| mingw32_cmake  ||  || Call the cmake binary for the Win32 target
 
|-
 
| mingw32_configure ||  || standard invocation for autotools 'configure' scripts
 
|-
 
| mingw32_cpp || i686-w64-mingw32-gcc -E || cross compiler 'cpp' binary
 
|-
 
| mingw32_env  ||  || Set the correct environment variables for the Win32 target
 
|-
 
| mingw32_host || i686-w64-mingw32  || Host platform for build
 
|-
 
| mingw32_objcopy ||  i686-w64-mingw32-objcopy || cross compiler 'objcopy' binary
 
|-
 
| mingw32_objdump || i686-w64-mingw32-objdump || cross compiler 'objdump' binary
 
|-
 
| mingw32_pkg_config  ||  || Call the pkg-config command for the Win32 target
 
|-
 
| mingw32_ranlib || i686-w64-mingw32-ranlib || cross compiler 'ranlib' binary
 
|-
 
| mingw32_strip || i686-w64-mingw32-strip || cross compiler 'strip' binary
 
|-
 
| mingw32_target || i686-w64-mingw32 || Target platform for build
 
|}
 
 
 
 
 
Win64 specific macros:
 
{|
 
| mingw64_ar || x86_64-w64-mingw32-ar || cross compiler 'ar' binary
 
|-
 
| mingw64_cc || x86_64-w64-mingw32-gcc || cross compiler 'gcc' binary
 
|-
 
| mingw64_cflags  || -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions --param=ssp-buffer-size=4 -mms-bitfields|| Default compiler flags for C/C++ binaries
 
|-
 
| mingw64_cmake  ||  || Call the cmake binary for the Win64 target
 
|-
 
| mingw64_configure ||  || standard invocation for autotools 'configure' scripts
 
|-
 
| mingw64_cpp || x86_64-w64-mingw32-gcc -E || cross compiler 'cpp' binary
 
|-
 
| mingw64_env  ||  || Set the correct environment variables for the Win64 target
 
|-
 
| mingw64_host || x86_64-w64-mingw32  || Host platform for build
 
|-
 
| mingw64_objcopy ||  x86_64-w64-mingw32-objcopy || cross compiler 'objcopy' binary
 
|-
 
| mingw64_objdump || x86_64-w64-mingw32-objdump || cross compiler 'objdump' binary
 
|-
 
| mingw64_pkg_config  ||  || Call the pkg-config command for the Win64 target
 
|-
 
| mingw64_ranlib || x86_64-w64-mingw32-ranlib || cross compiler 'ranlib' binary
 
|-
 
| mingw64_strip || x86_64-w64-mingw32-strip || cross compiler 'strip' binary
 
|-
 
| mingw64_target || x86_64-w64-mingw32 || Target platform for build
 
|}
 
 
 
== Filesystem location macros ==
 
 
 
The following macros are for use in %build, %install and %files sections of the RPM spec
 
 
 
For the Win32 target:
 
{|
 
| mingw32_bindir || %{mingw32_prefix}/bin || Location of Windows executables.
 
|-
 
| mingw32_datadir || %{mingw32_prefix}/share || Shared data used under Windows.
 
|-
 
| mingw32_docdir || %{mingw32_prefix}/share/doc || Documentation.
 
|-
 
| mingw32_infodir || %{mingw32_prefix}/share/info || Info files (see note below).
 
|-
 
| mingw32_includedir || %{mingw32_prefix}/include || Header files used when cross-compiling for Windows.
 
|-
 
| mingw32_libdir || %{mingw32_prefix}/lib || Windows libraries (see sections below).
 
|-
 
| mingw32_libexecdir || %{mingw32_prefix}/libexec ||
 
|-
 
| mingw32_mandir || %{mingw32_prefix}/share/man || Man pages (see note below).
 
|-
 
| mingw32_prefix || %{mingw32_sysroot}/mingw || Windows equivalent of %{_prefix}, required by MinGW.
 
|-
 
| mingw32_sbindir || %{mingw32_prefix}/sbin ||
 
|-
 
| mingw32_sysconfdir || %{mingw32_prefix}/etc || Configuration files used when running under Windows.
 
|-
 
| mingw32_sysroot || %{_prefix}/i686-w64-mingw32/sys-root || Windows system root.
 
|}
 
 
 
 
 
For the Win64 target:
 
{|
 
| mingw64_bindir || %{mingw64_prefix}/bin || Location of Windows executables.
 
|-
 
| mingw64_datadir || %{mingw64_prefix}/share || Shared data used under Windows.
 
|-
 
| mingw64_docdir || %{mingw64_prefix}/share/doc || Documentation.
 
|-
 
| mingw64_infodir || %{mingw64_prefix}/share/info || Info files (see note below).
 
|-
 
| mingw64_includedir || %{mingw64_prefix}/include || Header files used when cross-compiling for Windows.
 
|-
 
| mingw64_libdir || %{mingw64_prefix}/lib || Windows libraries (see sections below).
 
|-
 
| mingw64_libexecdir || %{mingw64_prefix}/libexec ||
 
|-
 
| mingw64_mandir || %{mingw64_prefix}/share/man || Man pages (see note below).
 
|-
 
| mingw64_prefix || %{mingw64_sysroot}/mingw || Windows equivalent of %{_prefix}, required by MinGW.
 
|-
 
| mingw64_sbindir || %{mingw64_prefix}/sbin ||
 
|-
 
| mingw64_sysconfdir || %{mingw64_prefix}/etc || Configuration files used when running under Windows.
 
|-
 
| mingw64_sysroot || %{_prefix}/x86_64-w64-mingw32/sys-root || Windows system root.
 
|}
 
 
 
= Compilation of binaries =
 
 
 
In order to build binaries for multiple targets we have to call commands like <code>./configure</code> and <code>make</code> multiple times (once for each target).
 
If one has to write this all out in a spec file then it will lead to duplicate code.
 
To reduce the amount of duplication, several RPM macros have been introduced to help with the compilation.
 
These macros are <code>%mingw_configure</code>, <code>%mingw_cmake</code>, <code>%mingw_make</code> and <code>%mingw_make_install</code>
 
 
 
These macros use out of source compilation to build binaries for all the targets.
 
Almost all packages support out of source compilation or require slight patching. The only known exceptions to date are zlib and openssl.
 
Packages which don't support out of source compilation may require a different approach like performing everything in the %install phase.
 
If you happen to stumble across a package which requires a different approach feel free to contact us on the Fedora MinGW mailing list
 
 
 
There's a difference in the behavior between these macros and the original <code>%{mingw32_xxx}</code> macros.
 
As all commands will get executed multiple times (once for each target) arguments to the macros cannot be given if the macro is in curly braces (<code>%{}</code>).  One has to invoke the macro without curly braces for things to work.  For example, with the original Fedora MinGW toolchain you could do:
 
%{mingw32_configure} --disable-xlib --enable-win32
 
This has to be changed to something like this:
 
%mingw_configure --disable-xlib --enable-win32
 
Note that the '{' '}' characters need to be omitted from the mingw_configure macro in this case.
 
 
 
Some packages need to be built multiple times for each target. Examples of this are packages which have to be built once for a static version and once for a shared version.
 
Such packages can add a custom suffix to the build directory used.
 
Say you've got something like below:
 
<pre>
 
mkdir build_shared
 
pushd build_shared
 
%{mingw32_configure} --enable-shared
 
popd
 
mkdir build_static
 
pushd build_static
 
%{mingw32_configure} --enable-static
 
popd
 
</pre>
 
This can be rewritten to something like this:
 
<pre>
 
%mingw_configure -s shared --enable-shared
 
%mingw_configure -s static --enable-static
 
</pre>
 
 
 
Most packages used the command <code>make %{?_smp_mflags}</code> to build the package.
 
In the MinGW cross compiler framework you have to use <code>%mingw_make %{?_smp_mflags}</code> to build the package for all configured targets
 
As with the <code>%mingw_configure</code> macro you can also use the <code>-s</code> argument to indicate a custom suffix to the build directory used
 
 
 
To install the package the command <code>make install DESTDIR=$RPM_BUILD_ROOT</code> was used in almost all cases.
 
This can be rewritten to <code>%mingw_make_install DESTDIR=$RPM_BUILD_ROOT</code> to install the package for all configured targets
 
The <code>-s</code> argument can also be used here
 
 
 
Some packages require some custom instructions before the files are ready to be packaged. Such code can remain as is. However, you may need to duplicate these instructions multiple times (for all configured targets).
 
 
 
= Dependencies =
 
 
 
If a package contains binaries which depend on a DLL provided by another package, these dependencies should be expressed in the form:
 
<pre>
 
mingw32(foo.dll)
 
</pre>
 
where <code>foo.dll</code> is the name of the DLL.  The name must be converted to lowercase because Windows binaries contain case
 
insensitive dependencies. The form 'mingw32(foo.dll)' should be used for Win32 binaries and the form 'mingw64(foo.dll)' for Win64 binaries.
 
 
 
Correct dependency generation is done automatically.  Packagers should include these lines in all library packages:
 
<pre>
 
%global _use_internal_dependency_generator 0
 
%global __find_requires %{mingw_findrequires}
 
%global __find_provides %{mingw_findprovides}
 
</pre>
 
All binary packages should depend on <code>mingw32-filesystem</code> or <code>mingw64-filesystem</code> (depending on the files in the package). If the lines mentioned above are used then it will be added automatically, so you don't have to add it yourself
 
 
 
All specfiles should BuildRequire at least:
 
 
 
BuildRequires:  mingw-filesystem >= minimum-version
 
 
 
and any other BuildRequires that they need.
 
 
 
= Build architecture =
 
 
 
All packages should have:
 
 
 
BuildArch: noarch
 
 
 
unless they contain Fedora native executables.
 
 
 
= Libraries (DLLs) =
 
 
 
All libraries must be built as DLLs.
 
 
 
Because of the peculiarity of Windows, DLLs are stored in the <code>%{mingw32_bindir}</code> directory, along with a control file in
 
the <code>%{mingw32_libdir}</code> directory.  For example, for a library called <code>foo</code> there would be:
 
<pre>
 
%{mingw32_bindir}/foo.dll
 
%{mingw32_libdir}/foo.dll.a
 
%{mingw32_libdir}/foo.la
 
</pre>
 
The <code>foo.dll</code> file is the main library, <code>foo.dll.a</code> is a stub linked to applications so they can find the library at runtime, and <code>foo.la</code> is a libtool archive so that libtool can link to dependent libraries at build time.  All of these files are required in those locations in order to link successfully. The <code>.dll</code> may contain a version number although not always (eg. <code>foo-0.dll</code>).
 
 
 
== Do not use %{mingw32_bindir}/* or %{mingw32_libdir}/* in %files section ==
 
 
 
The <code>%files</code> section must list DLLs separately.  Packages must NOT use <code>%{mingw32_bindir}/*</code> or
 
<code>%{mingw32_libdir}/*</code>
 
 
 
The reason for this is that libtool is very fragile and will give up on building a DLL very easily.  Therefore we force the name of the DLL to be listed explicitly in the <code>%files</code> section in order to catch this during RPM builds.
 
 
 
== Manpages and info files ==
 
 
 
If manpages or info files are simply duplicates of equivalent documentation found in Fedora native packages, then they should not be
 
packaged in the MinGW package.
 
 
 
 
 
 
 
== Stripping ==
 
 
 
Libraries and executables should be stripped.  This is done correctly and automatically if the spec file includes these lines:
 
 
 
<pre>
 
%global __strip %{mingw_strip}
 
%global __objdump %{mingw_objdump}
 
</pre>
 
 
 
(Note that if __strip and __objdump are not overridden in the specfile then this can sometimes cause Windows binaries to become corrupted).
 
 
 
== Debuginfo subpackage ==
 
 
 
Most binaries contain debugging symbols when the package gets built. To split the debugging symbols to a separate debuginfo package (as is done with native Fedora packages) the spec file must include these lines:
 
<pre>
 
%define __debug_install_post %{mingw_debug_install_post}
 
%{?mingw_debug_package}
 
</pre>
 
Note that <code>%define</code> really must be used here. If you use <code>%global</code> then the automatic generation of a debuginfo subpackage won't work.
 
 
 
= Example Specfile =
 
<pre>
 
%global __strip %{mingw_strip}
 
%global __objdump %{mingw_objdump}
 
%global _use_internal_dependency_generator 0
 
%global __find_requires %{mingw_findrequires}
 
%global __find_provides %{mingw_findprovides}
 
%define __debug_install_post %{mingw_debug_install_post}
 
 
 
%global mingw_pkg_name example
 
%global mingw_build_win32 1
 
%global mingw_build_win64 1
 
 
 
Name:          mingw-example
 
Version:        1.0.0
 
Release:        1%{?dist}
 
Summary:        MinGW compiled example library
 
 
 
License:        LGPLv2+
 
Group:          Development/Libraries
 
URL:            http://fedoraproject.org
 
Source0:        http://fedoraproject.org/example-%{version}.tar.bz2
 
 
 
BuildArch:      noarch
 
 
 
BuildRequires:  mingw-filesystem >= 65
 
BuildRequires:  mingw32-gcc
 
BuildRequires:  mingw64-gcc
 
BuildRequires:  mingw32-binutils
 
BuildRequires:  mingw32-binutils
 
BuildRequires:  mingw32-gettext
 
BuildRequires:  mingw64-gettext
 
BuildRequires:  mingw32-win-iconv
 
BuildRequires:  mingw64-win-iconv
 
BuildRequires:  mingw32-zlib
 
BuildRequires:  mingw64-zlib
 
 
 
%{?mingw_debug_package}
 
 
 
%description
 
MinGW compiled example library.
 
 
 
# Mingw32
 
%package -n mingw32-%{mingw_pkg_name}
 
Summary:      %{summary}
 
 
 
%description -n mingw32-%{mingw_pkg_name}
 
MinGW compiled example library.
 
 
 
# Mingw64
 
%package -n mingw64-%{mingw_pkg_name}
 
Summary:      %{summary}
 
 
 
%description -n mingw64-%{mingw_pkg_name}
 
MinGW compiled example library.
 
 
 
# If a package maintainer wishes to bundle static libraries then they
 
# can be placed in -static subpackages. Otherwise, these subpackages
 
# can be dropped
 
%package -n mingw32-%{mingw_pkg_name}-static
 
Summary:      Static version of the MinGW compiled example library
 
Requires:      mingw32-%{mingw_pkg_name} = %{version}-%{release}
 
 
 
%description -n mingw32-%{mingw_pkg_name}-static
 
Static version of the MinGW compiled example library.
 
 
 
%package -n mingw64-%{mingw_pkg_name}-static
 
Summary:      Static version of the MinGW compiled example library
 
Requires:      mingw64-%{mingw_pkg_name} = %{version}-%{release}
 
 
 
%description -n mingw64-%{mingw_pkg_name}-static
 
Static version of the MinGW compiled example library.
 
 
 
 
 
%prep
 
%setup -q -n %{mingw_pkg_name}-%{version}
 
 
 
 
 
%build
 
%mingw_configure "--enable-static" "--enable-shared" "--enable-foo"
 
%mingw_make %{?_smp_mflags}
 
 
 
 
 
%install
 
%mingw_make_install "DESTDIR=$RPM_BUILD_ROOT"
 
 
 
%mingw_find_lang %{mingw_pkg_name}
 
 
 
 
 
# Note: there should be no %%files section for the main package!
 
 
 
# Win32
 
%files -n mingw32-%{mingw_pkg_name} -f mingw32-%{mingw_pkg_name}.lang
 
%{mingw32_bindir}/libexample-0.dll
 
%{mingw32_includedir}/example/
 
%{mingw32_libdir}/libexample.dll.a
 
%{mingw32_libdir}/libexample.la
 
%{mingw32_libdir}/pkgconfig/example.pc
 
 
 
# Win64
 
%files -n mingw64-%{mingw_pkg_name} -f mingw64-%{mingw_pkg_name}.lang
 
%{mingw64_bindir}/libexample-0.dll
 
%{mingw64_includedir}/example/
 
%{mingw64_libdir}/libexample.dll.a
 
%{mingw64_libdir}/libexample.la
 
%{mingw64_libdir}/pkgconfig/example.pc
 
 
 
# Static subpackages are optional (as mentioned earlier)
 
# Win32
 
%files -n mingw32-%{mingw_pkg_name}-static
 
%{mingw32_libdir}/libexample.a
 
 
 
# Win64
 
%files -n mingw64-%{mingw_pkg_name}-static
 
%{mingw64_libdir}/libexample-0.a
 
 
 
 
 
%changelog
 
* Wed Apr  6 2011 Erik van Pienbroek <epienbro@fedoraproject.org> - 1.0.0-1
 
- Initial release
 
</pre>
 
 
 
[[Category:Packaging guidelines]]
 

Latest revision as of 17:41, 6 June 2012

Redirect to: