fdo-mirrors/cairo
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/cairo/cairo.git synced 2025-12-24 20:40:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove autotools build

Browse source
This commit is contained in:
Adrian Johnson 2023-01-08 22:27:47 +10:30
parent 387d2f0739
commit efe303d9db
73 changed files with 0 additions and 8059 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
.gitlab-ci.yml
View file

@ -98,20 +98,6 @@ fedora image:
google-noto-emoji-color-fonts google-noto-emoji-color-fonts
fonttools fonttools
fedora autotools build:
extends:
- '.fdo.distribution-image@fedora'
- '.ccache_setup'
stage: 'build'
script:
- ./autogen.sh
- make V=1 VERBOSE=1 -j $(nproc)
artifacts:
when: 'always'
expire_in: '2 days'
paths:
- "*"
.test fedora meson: .test fedora meson:
dependencies: dependencies:
- 'fedora meson build' - 'fedora meson build'

184
INSTALL
View file

@ -1,184 +0,0 @@
Quick-start build instructions
------------------------------
1) Configure the package:
./configure
2) Compile it:
make
3) Install it:
make install
This final step may require temporary root access (eg. with sudo) if
you don't have write permission to the directory in which cairo will
be installed.
NOTE: If you are working with source from git/cvs rather than from a tar
file, then you should use ./autogen.sh in place of ./configure
anywhere it is mentioned in these instructions.
More detailed build instructions
--------------------------------
1) Configure the package
The first step in building cairo is to configure the package by
running the configure script. [Note: if you don't have a configure
script, skip down below to the Extremely detailed build
instructions.]
The configure script attempts to automatically detect as much as
possible about your system. So, you should primarily just accept
its defaults by running:
./configure
The configure script does accept a large number of options for
fine-tuning its behavior. See "./configure --help" for a complete
list. The most commonly used options are discussed here.
--prefix=PREFIX
This option specifies the directory under which the software
should be installed. By default configure will choose a
directory such as /usr/local. If you would like to install
cairo to some other location, pass the director to configure
with the --prefix option. For example:
./configure --prefix=/opt/cairo
would install cairo into the /opt/cairo directory. You could
also choose a prefix directory within your home directory if
you don't have write access to any system-wide directory.
After installing into a custom prefix, you will need to set
some environment variables to allow the software to be
found. Assuming the /opt/cairo prefix and assuming you are
using the bash shell, the following environment variables
should be set:
PKG_CONFIG_PATH=/opt/cairo/lib/pkgconfig
LD_LIBRARY_PATH=/opt/cairo/lib
export PKG_CONFIG_PATH LD_LIBRARY_PATH
(NOTE: On Mac OS X, at least, use DYLD_LIBRARY_PATH in place
of LD_LIBRARY_PATH above.)
--enable-XYZ
--enable-XYZ=yes
--enable-XYZ=auto
--enable-XYZ=no
--disable-XYZ
Cairo's various font and surface backends and other features can be
enabled or disabled at configure time. Features can be divided into
three categories based on their default state:
* default=yes: These are the recommended features like PNG functions
and PS/PDF/SVG backends. It is highly recommended to not disable
these features but if that's really what one wants, they can be
disabled using --disable-XYZ.
* default=auto: These are the "native" features, that is, they are
platform specific, like the Xlib surface backend. You probably
want one or two of these. They will be automatically enabled if
all their required facilities are available. Or you can use
--enable-XYZ or --disable-XYZ to make your desire clear, and then
cairo errs during configure if your intention cannot be followed.
* default=no: These are the "experimental" features, and hence by
default off. Use --enable-XYZ to enable them.
The list of all features and their default state can be seen in the
output of ./configure --help.
2) Compile the package:
This step is very simple. Just:
make
The Makefiles included with cairo are designed to work on as many
different systems as possible.
When cairo is compiled, you can also run some automated tests of
cairo with:
make check
NOTE: Some versions of X servers will cause the -xlib tests to
report failures in make check even when cairo is working just
fine. If you see failures in nothing but -xlib tests, please
examine the corresponding -xlib-out.png images and compare them to
the -ref.png reference images (the -xlib-diff.png images might also
be useful). If the results seem "close enough" please do not report
a bug against cairo as the "failures" you are seeing are just due
to subtle variations in X server implementations.
3) Install the package:
The final step is to install the package with:
make install
If you are installing to a system-wide location you may need to
temporarily acquire root access in order to perform this
operation. A good way to do this is to use the sudo program:
sudo make install
Extremely detailed build instructions
-------------------------------------
So you want to build cairo but it didn't come with a configure
script. This is probably because you have checked out the latest
in-development code via git. If you need to be on the bleeding edge,
(for example, because you're wanting to develop some aspect of cairo
itself), then you're in the right place and should read on.
However, if you don't need such a bleeding-edge version of cairo, then
you might prefer to start by building the latest stable cairo release:
https://cairographics.org/releases
or perhaps the latest (unstable) development snapshot:
https://cairographics.org/snapshots
There you'll find nicely packaged tar files that include a configure
script so you can go back the the simpler instructions above.
But you're still reading, so you're someone that loves to
learn. Excellent! We hope you'll learn enough to make some excellent
contributions to cairo. Since you're not using a packaged tar file,
you're going to need some additional tools beyond just a C compiler in
order to compile cairo. Specifically, you need the following utilities:
automake
autoconf
autoheader
aclocal
libtoolize
pkg-config [at least version 0.16]
gtk-doc (recommended)
Hopefully your platform of choice has packages readily available so
that you can easily install things with your system's package
management tool, (such as "apt-get install automake" on Debian or "yum
install automake" on Fedora, etc.). Note that Mac OS X ships with
glibtoolize instead of libtoolize.
Once you have all of those packages installed, the next step is to run
the autogen.sh script. That can be as simple as:
./autogen.sh
But before you run that command, note that the autogen.sh script
accepts all the same arguments as the configure script, (and in fact,
will generate the configure script and run it with the arguments you
provide). So go back up to step (1) above and see what additional
arguments you might want to pass, (such as prefix). Then continue with
the instructions, simply using ./autogen.sh in place of ./configure.
Happy hacking!

118
Makefile.am
View file

@ -1,118 +0,0 @@
include $(top_srcdir)/build/Makefile.am.common
EXTRA_DIST += \
KNOWN_ISSUES \
README.win32 \
Makefile.win32 \
build/Makefile.win32.common \
build/Makefile.win32.inform \
build/Makefile.win32.features \
build/Makefile.win32.features-h \
$(NULL)
#MAINTAINERCLEANFILES += \
# $(srcdir)/build/Makefile.win32.features \
# $(srcdir)/build/Makefile.win32.features-h \
# $(NULL)
ACLOCAL_AMFLAGS = -I build ${ACLOCAL_FLAGS}
DIST_SUBDIRS = src doc util boilerplate test perf
SUBDIRS = src doc util
# libpng is required for our test programs
if CAIRO_HAS_PNG_FUNCTIONS
SUBDIRS += boilerplate test perf
endif
doc:
cd doc && $(MAKE) $(AM_MAKEFLAGS) $@
test retest recheck: all
cd test && $(MAKE) $(AM_MAKEFLAGS) $@
perf: all
cd perf && $(MAKE) $(AM_MAKEFLAGS) $@
check-valgrind: all
cd test && $(MAKE) $(AM_MAKEFLAGS) check-valgrind
cd perf && $(MAKE) $(AM_MAKEFLAGS) check-valgrind
.PHONY: doc test retest recheck perf check-valgrind
EXTRA_DIST += \
AUTHORS \
BIBLIOGRAPHY \
BUGS \
CODING_STYLE \
COPYING \
COPYING-LGPL-2.1 \
COPYING-MPL-1.1 \
HACKING \
INSTALL \
NEWS \
PORTING_GUIDE \
README \
RELEASING \
autogen.sh \
$(NULL)
# Meson build system files
EXTRA_DIST += \
meson.build \
meson_options.txt \
version.py \
boilerplate/make-cairo-boilerplate-constructors.py \
boilerplate/meson.build \
doc/public/meson.build \
doc/public/version.xml.in \
src/meson.build \
test/make-cairo-test-constructors.py \
test/meson.build \
test/pdiff/meson.build \
util/cairo-fdr/meson.build \
util/cairo-gobject/meson.build \
util/cairo-missing/meson.build \
util/cairo-script/meson.build \
util/cairo-sphinx/meson.build \
util/cairo-trace/meson.build \
util/meson.build \
meson-cc-tests/atomic-ops-cxx11.c \
meson-cc-tests/atomic-ops-gcc-legacy.c \
meson-cc-tests/bfd-section-flags.c \
meson-cc-tests/check-unused-result.c \
meson-cc-tests/ft_has_color.c \
meson-cc-tests/ipc_rmid_deferred_release.c \
meson-cc-tests/mkdir-variant-1.c \
meson-cc-tests/mkdir-variant-2.c \
meson-cc-tests/pthread.c \
subprojects/expat.wrap \
subprojects/fontconfig.wrap \
subprojects/freetype2.wrap \
subprojects/glib.wrap \
subprojects/libpng.wrap \
subprojects/pixman.wrap \
subprojects/zlib.wrap \
$(NULL)
DISTCLEANFILES += config.cache
MAINTAINERCLEANFILES += \
$(srcdir)/aclocal.m4 \
$(srcdir)/autoscan.log \
$(srcdir)/build/compile \
$(srcdir)/build/config.guess \
$(srcdir)/build/config.sub \
$(srcdir)/build/depcomp \
$(srcdir)/build/install-sh \
$(srcdir)/build/ltmain.sh \
$(srcdir)/build/missing \
$(srcdir)/build/mkinstalldirs \
$(srcdir)/config.h.in \
$(srcdir)/configure.scan \
$(NULL)
DISTCHECK_CONFIGURE_FLAGS = \
--enable-gtk-doc \
--enable-test-surfaces \
--enable-full-testing \
$(NULL)
include $(srcdir)/build/Makefile.am.changelog
include $(srcdir)/build/Makefile.am.releasing
include $(srcdir)/build/Makefile.am.analysis

24
Makefile.win32
View file

@ -1,24 +0,0 @@
default: all
# Do not edit this file.
# Edit build/Makefile.win32.common for customization
top_srcdir = .
include $(top_srcdir)/build/Makefile.win32.inform
all: cairo
cairo: inform
@$(MAKE) -C src -f Makefile.win32
perf: inform
@$(MAKE) -C perf -f Makefile.win32 perf
test: inform
@$(MAKE) -C test -f Makefile.win32 test
clean:
@$(MAKE) -C boilerplate -f Makefile.win32 clean
@$(MAKE) -C perf -f Makefile.win32 clean
@$(MAKE) -C src -f Makefile.win32 clean
@$(MAKE) -C test -f Makefile.win32 clean

55
acinclude.m4
View file

@ -1,55 +0,0 @@
dnl -*- mode: autoconf -*-
dnl [m4_newline] didn't appear until autoconf 2.62
m4_ifdef([m4_newline],,[m4_define([m4_newline],[
])])
dnl These are not available in autoconf 2.59
m4_ifdef([m4_foreach_w],,[m4_define([m4_foreach_w],
[m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3])])])
m4_ifdef([AS_CASE],,[
m4_define([_AS_CASE],
[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])],
[$#], 1, [ *) $1 ;;],
[$#], 2, [ $1) m4_default([$2], [:]) ;;],
[ $1) m4_default([$2], [:]) ;;
$0(m4_shift2($@))])dnl
])
m4_defun([AS_CASE],
[m4_ifval([$2$3],
[case $1 in
_AS_CASE(m4_shift($@))
esac
])dnl
])# AS_CASE
])
m4_ifdef([m4_shift2],, [m4_define([m4_shift2], [m4_shift(m4_shift($@))])])
dnl ==========================================================================
dnl This has to be in acinclude.m4 as it includes other files
dnl Parse Version.mk and declare m4 variables out of it
m4_define([CAIRO_PARSE_VERSION],dnl
m4_translit(dnl
m4_bpatsubst(m4_include(src/cairo-version.h),
[^.define \([a-zA-Z0-9_]*\) *\([0-9][0-9]*\)],
[[m4_define(\1, \2)]]),
[A-Z], [a-z])dnl
)dnl
dnl ==========================================================================
m4_pattern_forbid([^cr_])
dnl AC_AUTOCONF_VERSION was introduced in 2.62, so its definition works as
dnl a conditional on version >= 2.62. Older versions did not call
dnl m4_pattern_allow from AC_DEFINE and friends. To avoid lots of warnings we
dnl only forbid CAIRO_ if autoconf is recent enough.
m4_ifdef([AC_AUTOCONF_VERSION],
[m4_pattern_forbid([CAIRO])],
[m4_pattern_forbid([_CAIRO])])

31
autogen.sh
View file

@ -1,31 +0,0 @@
#!/bin/sh
# Run this to generate all the initial makefiles, etc.
test -n "$srcdir" || srcdir=`dirname "$0"`
test -n "$srcdir" || srcdir=.
ORIGDIR=`pwd`
cd $srcdir
AUTORECONF=`which autoreconf`
if test -z $AUTORECONF; then
echo "*** No autoreconf found, please install it ***"
exit 1
fi
GTKDOCIZE=`which gtkdocize`
if test -z $GTKDOCIZE; then
echo "*** No GTK-Doc found, documentation won't be generated ***"
else
gtkdocize || exit $?
fi
# create dummy */Makefile.am.features and ChangeLog to make automake happy
> boilerplate/Makefile.am.features
> src/Makefile.am.features
touch ChangeLog
autoreconf --install --verbose || exit $?
cd $ORIGDIR
test -n "$NOCONFIGURE" || "$srcdir/configure" "$@"

56
boilerplate/Makefile.am
View file

@ -1,56 +0,0 @@
# Note: All source files are listed in Makefile.sources.
include $(top_srcdir)/build/Makefile.am.common
include $(srcdir)/Makefile.am.features
EXTRA_DIST += Makefile.win32 Makefile.win32.features
#MAINTAINERCLEANFILES += $(srcdir)/Makefile.win32.features
AM_CPPFLAGS = \
-I$(srcdir) \
-I$(top_builddir)/src \
-I$(top_srcdir)/src \
$(CAIRO_CFLAGS) \
$(NULL)
AM_LDFLAGS = $(CAIRO_LDFLAGS)
EXTRA_LTLIBRARIES += libcairoboilerplate.la
libcairoboilerplate_la_SOURCES = \
$(enabled_cairo_boilerplate_headers) \
$(enabled_cairo_boilerplate_private) \
$(enabled_cairo_boilerplate_sources) \
cairo-boilerplate-constructors.c \
$(NULL)
libcairoboilerplate_la_LIBADD = $(top_builddir)/src/libcairo.la \
$(CAIRO_LIBS) \
$(CAIROBOILERPLATE_LIBS) \
$(NULL)
libcairoboilerplate_la_DEPENDENCIES = \
$(NULL)
if CAIRO_HAS_DL
libcairoboilerplate_la_LIBADD += -ldl
endif
if CAIRO_HAS_WIN32_SURFACE
libcairoboilerplate_la_LIBADD += -lwinspool
endif
cairo-boilerplate-constructors.c: Makefile $(enabled_cairo_boilerplate_sources) make-cairo-boilerplate-constructors.sh
(cd $(srcdir) && sh ./make-cairo-boilerplate-constructors.sh $(enabled_cairo_boilerplate_sources)) > $@
BUILT_SOURCES += cairo-boilerplate-constructors.c
EXTRA_DIST += $(BUILT_SOURCES) make-cairo-boilerplate-constructors.sh
CLEANFILES += $(BUILT_SOURCES)
test: check
if CROSS_COMPILING
else
TESTS += check-link$(EXEEXT)
endif
check_PROGRAMS += check-link
check_link_LDADD = libcairoboilerplate.la

34
boilerplate/Makefile.sources
View file

@ -1,34 +0,0 @@
# Makefile.sources
#
# This file is pretty similar to $(top_srcdir)/src/Makefile.sources,
# but for boilerplate. Unlike that file, there are no special headers.
#
cairo_boilerplate_headers = \
cairo-boilerplate-getopt.h \
cairo-boilerplate-scaled-font.h \
cairo-boilerplate-system.h \
cairo-boilerplate.h \
$(NULL)
cairo_boilerplate_sources = \
cairo-boilerplate-getopt.c \
cairo-boilerplate-system.c \
cairo-boilerplate.c \
$(NULL)
cairo_boilerplate_private = \
cairo-boilerplate-private.h \
$(NULL)
cairo_boilerplate_glx_sources = cairo-boilerplate-glx.c
cairo_boilerplate_wgl_sources = cairo-boilerplate-wgl.c
cairo_boilerplate_egl_sources = cairo-boilerplate-egl.c
cairo_boilerplate_pdf_sources = cairo-boilerplate-pdf.c
cairo_boilerplate_ps_sources = cairo-boilerplate-ps.c
cairo_boilerplate_quartz_sources = cairo-boilerplate-quartz.c
cairo_boilerplate_script_sources = cairo-boilerplate-script.c
cairo_boilerplate_svg_sources = cairo-boilerplate-svg.c
cairo_boilerplate_test_surfaces_sources = cairo-boilerplate-test-surfaces.c
cairo_boilerplate_win32_sources = cairo-boilerplate-win32.c cairo-boilerplate-win32-printing.c
cairo_boilerplate_xcb_sources = cairo-boilerplate-xcb.c
cairo_boilerplate_xlib_headers = cairo-boilerplate-xlib.h
cairo_boilerplate_xlib_sources = cairo-boilerplate-xlib.c

24
boilerplate/Makefile.win32
View file

@ -1,24 +0,0 @@
top_srcdir = ..
include $(top_srcdir)/build/Makefile.win32.common
include Makefile.win32.features
HEADERS = \
$(enabled_cairo_boilerplate_headers) \
$(enabled_cairo_boilerplate_private) \
$(NULL)
SOURCES = \
$(enabled_cairo_boilerplate_sources) \
cairo-boilerplate-constructors.c \
$(NULL)
OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(SOURCES))
cairo-boilerplate-constructors.c: Makefile.sources Makefile.win32 $(enabled_cairo_boilerplate_sources) make-cairo-boilerplate-constructors.sh
sh ./make-cairo-boilerplate-constructors.sh $(enabled_cairo_boilerplate_sources) > $@
all: $(CFG)/boiler.lib
$(CFG)/boiler.lib: $(OBJECTS)
@$(AR) $(CAIRO_ARFLAGS) -OUT:$@ $(OBJECTS)

353
boilerplate/Makefile.win32.features
View file

@ -1,353 +0,0 @@
# Generated by configure. Do not edit.
ifeq ($(top_srcdir),)
include Makefile.sources
else
include $(top_srcdir)/boilerplate/Makefile.sources
endif
supported_cairo_boilerplate_headers = $(cairo_boilerplate_headers)
unsupported_cairo_boilerplate_headers =
all_cairo_boilerplate_headers = $(cairo_boilerplate_headers)
all_cairo_boilerplate_private = $(cairo_boilerplate_private)
all_cairo_boilerplate_sources = $(cairo_boilerplate_sources)
enabled_cairo_boilerplate_headers = $(cairo_boilerplate_headers)
enabled_cairo_boilerplate_private = $(cairo_boilerplate_private)
enabled_cairo_boilerplate_sources = $(cairo_boilerplate_sources)
supported_cairo_boilerplate_headers += $(cairo_boilerplate_xlib_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_xlib_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_xlib_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_xlib_sources)
ifeq ($(CAIRO_HAS_XLIB_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_xlib_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_xlib_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_xlib_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_xlib_xrender_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_xlib_xrender_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_xlib_xrender_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_xlib_xrender_sources)
ifeq ($(CAIRO_HAS_XLIB_XRENDER_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_xlib_xrender_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_xlib_xrender_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_xlib_xrender_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_xcb_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_xcb_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_xcb_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_xcb_sources)
ifeq ($(CAIRO_HAS_XCB_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_xcb_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_xcb_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_xcb_sources)
endif
unsupported_cairo_boilerplate_headers += $(cairo_boilerplate_xlib_xcb_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_xlib_xcb_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_xlib_xcb_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_xlib_xcb_sources)
ifeq ($(CAIRO_HAS_XLIB_XCB_FUNCTIONS),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_xlib_xcb_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_xlib_xcb_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_xlib_xcb_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_xcb_shm_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_xcb_shm_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_xcb_shm_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_xcb_shm_sources)
ifeq ($(CAIRO_HAS_XCB_SHM_FUNCTIONS),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_xcb_shm_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_xcb_shm_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_xcb_shm_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_quartz_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_quartz_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_quartz_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_quartz_sources)
ifeq ($(CAIRO_HAS_QUARTZ_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_quartz_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_quartz_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_quartz_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_quartz_font_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_quartz_font_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_quartz_font_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_quartz_font_sources)
ifeq ($(CAIRO_HAS_QUARTZ_FONT),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_quartz_font_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_quartz_font_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_quartz_font_sources)
endif
unsupported_cairo_boilerplate_headers += $(cairo_boilerplate_quartz_image_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_quartz_image_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_quartz_image_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_quartz_image_sources)
ifeq ($(CAIRO_HAS_QUARTZ_IMAGE_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_quartz_image_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_quartz_image_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_quartz_image_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_win32_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_win32_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_win32_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_win32_sources)
ifeq ($(CAIRO_HAS_WIN32_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_win32_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_win32_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_win32_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_win32_font_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_win32_font_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_win32_font_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_win32_font_sources)
ifeq ($(CAIRO_HAS_WIN32_FONT),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_win32_font_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_win32_font_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_win32_font_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_png_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_png_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_png_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_png_sources)
ifeq ($(CAIRO_HAS_PNG_FUNCTIONS),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_png_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_png_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_png_sources)
endif
unsupported_cairo_boilerplate_headers += $(cairo_boilerplate_gl_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_gl_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_gl_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_gl_sources)
ifeq ($(CAIRO_HAS_GL_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_gl_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_gl_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_gl_sources)
endif
unsupported_cairo_boilerplate_headers += $(cairo_boilerplate_glesv2_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_glesv2_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_glesv2_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_glesv2_sources)
ifeq ($(CAIRO_HAS_GLESV2_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_glesv2_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_glesv2_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_glesv2_sources)
endif
unsupported_cairo_boilerplate_headers += $(cairo_boilerplate_glesv3_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_glesv3_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_glesv3_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_glesv3_sources)
ifeq ($(CAIRO_HAS_GLESV3_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_glesv3_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_glesv3_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_glesv3_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_egl_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_egl_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_egl_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_egl_sources)
ifeq ($(CAIRO_HAS_EGL_FUNCTIONS),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_egl_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_egl_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_egl_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_glx_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_glx_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_glx_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_glx_sources)
ifeq ($(CAIRO_HAS_GLX_FUNCTIONS),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_glx_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_glx_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_glx_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_wgl_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_wgl_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_wgl_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_wgl_sources)
ifeq ($(CAIRO_HAS_WGL_FUNCTIONS),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_wgl_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_wgl_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_wgl_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_script_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_script_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_script_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_script_sources)
ifeq ($(CAIRO_HAS_SCRIPT_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_script_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_script_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_script_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_ft_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_ft_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_ft_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_ft_sources)
ifeq ($(CAIRO_HAS_FT_FONT),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_ft_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_ft_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_ft_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_fc_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_fc_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_fc_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_fc_sources)
ifeq ($(CAIRO_HAS_FC_FONT),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_fc_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_fc_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_fc_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_ps_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_ps_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_ps_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_ps_sources)
ifeq ($(CAIRO_HAS_PS_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_ps_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_ps_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_ps_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_pdf_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_pdf_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_pdf_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_pdf_sources)
ifeq ($(CAIRO_HAS_PDF_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_pdf_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_pdf_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_pdf_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_svg_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_svg_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_svg_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_svg_sources)
ifeq ($(CAIRO_HAS_SVG_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_svg_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_svg_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_svg_sources)
endif
all_cairo_boilerplate_private += $(cairo_boilerplate_test_surfaces_private) $(cairo_boilerplate_test_surfaces_headers)
all_cairo_boilerplate_sources += $(cairo_boilerplate_test_surfaces_sources)
ifeq ($(CAIRO_HAS_TEST_SURFACES),1)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_test_surfaces_private) $(cairo_boilerplate_test_surfaces_headers)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_test_surfaces_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_image_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_image_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_image_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_image_sources)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_image_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_image_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_image_sources)
supported_cairo_boilerplate_headers += $(cairo_boilerplate_mime_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_mime_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_mime_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_mime_sources)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_mime_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_mime_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_mime_sources)
supported_cairo_boilerplate_headers += $(cairo_boilerplate_recording_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_recording_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_recording_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_recording_sources)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_recording_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_recording_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_recording_sources)
supported_cairo_boilerplate_headers += $(cairo_boilerplate_observer_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_observer_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_observer_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_observer_sources)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_observer_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_observer_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_observer_sources)
unsupported_cairo_boilerplate_headers += $(cairo_boilerplate_tee_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_tee_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_tee_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_tee_sources)
ifeq ($(CAIRO_HAS_TEE_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_tee_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_tee_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_tee_sources)
endif
unsupported_cairo_boilerplate_headers += $(cairo_boilerplate_xml_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_xml_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_xml_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_xml_sources)
ifeq ($(CAIRO_HAS_XML_SURFACE),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_xml_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_xml_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_xml_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_user_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_user_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_user_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_user_sources)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_user_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_user_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_user_sources)
all_cairo_boilerplate_private += $(cairo_boilerplate_pthread_private) $(cairo_boilerplate_pthread_headers)
all_cairo_boilerplate_sources += $(cairo_boilerplate_pthread_sources)
ifeq ($(CAIRO_HAS_PTHREAD),1)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_pthread_private) $(cairo_boilerplate_pthread_headers)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_pthread_sources)
endif
supported_cairo_boilerplate_headers += $(cairo_boilerplate_gobject_headers)
all_cairo_boilerplate_headers += $(cairo_boilerplate_gobject_headers)
all_cairo_boilerplate_private += $(cairo_boilerplate_gobject_private)
all_cairo_boilerplate_sources += $(cairo_boilerplate_gobject_sources)
ifeq ($(CAIRO_HAS_GOBJECT_FUNCTIONS),1)
enabled_cairo_boilerplate_headers += $(cairo_boilerplate_gobject_headers)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_gobject_private)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_gobject_sources)
endif
all_cairo_boilerplate_private += $(cairo_boilerplate_trace_private) $(cairo_boilerplate_trace_headers)
all_cairo_boilerplate_sources += $(cairo_boilerplate_trace_sources)
ifeq ($(CAIRO_HAS_TRACE),1)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_trace_private) $(cairo_boilerplate_trace_headers)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_trace_sources)
endif
all_cairo_boilerplate_private += $(cairo_boilerplate_interpreter_private) $(cairo_boilerplate_interpreter_headers)
all_cairo_boilerplate_sources += $(cairo_boilerplate_interpreter_sources)
ifeq ($(CAIRO_HAS_INTERPRETER),1)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_interpreter_private) $(cairo_boilerplate_interpreter_headers)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_interpreter_sources)
endif
all_cairo_boilerplate_private += $(cairo_boilerplate_symbol_lookup_private) $(cairo_boilerplate_symbol_lookup_headers)
all_cairo_boilerplate_sources += $(cairo_boilerplate_symbol_lookup_sources)
ifeq ($(CAIRO_HAS_SYMBOL_LOOKUP),1)
enabled_cairo_boilerplate_private += $(cairo_boilerplate_symbol_lookup_private) $(cairo_boilerplate_symbol_lookup_headers)
enabled_cairo_boilerplate_sources += $(cairo_boilerplate_symbol_lookup_sources)
endif

16
build/.gitignore vendored
View file

@ -1,16 +0,0 @@
ar-lib
compile
config.guess
config.sub
depcomp
install-sh
ltmain.sh
missing
mkinstalldirs
#Makefile.win32.features
#Makefile.win32.features-h
libtool.m4
lt*.m4
gtk-doc.m4
test-driver

37
build/Makefile.am.analysis
View file

@ -1,37 +0,0 @@
if CAIRO_HAS_LCOV
# use recursive makes in order to ignore errors during check/perf
lcov:
-$(MAKE) $(AM_MAKEFLAGS) check
$(MAKE) $(AM_MAKEFLAGS) genlcov
lcov-perf:
-$(MAKE) $(AM_MAKEFLAGS) perf
$(MAKE) $(AM_MAKEFLAGS) genlcov
# we have to massage the lcov.info file slightly to hide the effect of libtool
# placing the objects files in the .libs/ directory separate from the *.c
genlcov:
$(LTP) --directory $(top_builddir) --path $(top_builddir) --capture --output-file cairo-lcov.info --test-name CAIRO_TEST --no-checksum
$(SED) -e 's#.libs/##' \
-e 's#boilerplate/src#src#' \
-e 's#$(shell pwd)#$(shell cd $(top_srcdir) && pwd)#' \
< cairo-lcov.info > cairo-lcov.info.tmp
LANG=C $(LTP_GENHTML) --prefix $(top_builddir) --output-directory cairo-lcov --title "Cairo Code Coverage" --show-details cairo-lcov.info.tmp
$(RM) cairo-lcov.info.tmp
html-local: lcov
else
lcov lcov-perf genlcov:
@echo You need to configure Cairo with support for gcov enabled.
@echo e.g, ./configure --enable-gcov
endif
lcov-clean:
if CAIRO_HAS_LCOV
-$(LTP) --directory $(top_builddir) -z
endif
-$(RM) -r cairo-lcov.info cairo-lcov
-$(FIND) -name '*.gcda' -print | $(XARGS) $(RM)
distclean-local: lcov-clean
.PHONY: lcov lcov-perf genlcov lcov-clean

82
build/Makefile.am.changelog
View file

@ -1,82 +0,0 @@
# Creating ChangeLog files from git log:
# We always create a ChangeLog that contains the most recent changes, and
# multiple others for changes between major releases (other than the last such
# segment that we put in 'ChangeLog'. The old ones are named
# ChangeLog.pre-X.Y where X.Y is the version number of the major release.
CURR_CHANGELOG_VERSION=$(CAIRO_VERSION_MAJOR).$$(echo "($(CAIRO_VERSION_MINOR)+1)/2*2" | bc)
# examines $version
PREV_CHANGELOG_VERSION=$$(if test "x$$(echo "($$version-0.1)*2/2"|bc)" = "x$$(echo "$$version*2/2"|bc)"; \
then echo "$$version-$$(echo "$$version" | sed 's/[0-9]/0/g;s/[0-9]$$/2/')"; \
else echo "$$version-1.0"; \
fi | bc | sed 's/[.]0*/./;s/^0[.]\?$$/initial/;s/[.]$$/.0/')
CHANGELOGS = ChangeLog \
`version=$(CURR_CHANGELOG_VERSION); \
version=$(PREV_CHANGELOG_VERSION); \
while test "x$$version" != xinitial; do \
echo ChangeLog.pre-$$version; \
version=$(PREV_CHANGELOG_VERSION); \
done`
MAINTAINERCLEANFILES += $(srcdir)/ChangeLog $(srcdir)/ChangeLog.pre-*
DISTCLEANFILES += $(srcdir)/ChangeLog.cache-*
changelogs:
@$(MAKE) $(AM_MAKEFLAGS) $(CHANGELOGS)
dist-hook: changelogs
changelogs="$(CHANGELOGS)"; \
for changelog in $$changelogs; do \
cp $(srcdir)/$$changelog $(distdir)/ 2>/dev/null || \
cp $$changelog $(distdir)/; \
done
$(srcdir)/ChangeLog:
@if test -d "$(srcdir)/.git"; then \
version=$(CURR_CHANGELOG_VERSION); \
prev=$(PREV_CHANGELOG_VERSION).0; \
nearest_tag=`git describe | sed 's/-.*//'`; \
before=$(srcdir)/ChangeLog.cache-$$prev..$$nearest_tag; \
after=$(srcdir)/ChangeLog.cache-$$nearest_tag..; \
$(MAKE) $(AM_MAKEFLAGS) $$before $$after && \
echo Creating $@ && \
{ echo '# Generated by configure. Do not edit.'; echo; \
cat $$after; echo; cat $$before; } > $@; \
else \
test -f $@ || \
(echo A git checkout is required to generate $@ >&2 && \
echo A git checkout is required to generate this file >> $@); \
fi
DISTCLEANFILES += ChangeLog.cache-*
ChangeLog.cache-*..: .git
ChangeLog%: $(srcdir)/ChangeLog%
$(srcdir)/ChangeLog.cache-% $(srcdir)/ChangeLog.pre-%:
@echo Creating $@
@if test -d "$(srcdir)/.git"; then \
(cd "$(srcdir)" && \
version=$$(echo "$@" | sed 's/.*ChangeLog\([.].*-\)\?//'); \
if echo "$@" | grep -q '^ChangeLog[.]cache'; then \
spec=$$version; \
else \
to=$$version; \
test "x$$version" = x && version=$(CURR_CHANGELOG_VERSION); \
from=$(PREV_CHANGELOG_VERSION); \
test "x$$to" = x || to=$$to.0; \
test "x$$from" = xinitial || from=$$from.0; \
spec=$$from..$$to; \
fi; \
$(top_srcdir)/build/missing --run git log --stat "$$spec") > $@.tmp \
&& mv -f $@.tmp $@ \
|| ($(RM) $@.tmp; \
echo Failed to generate $@, your $@ may be outdated >&2); \
else \
echo A git checkout is required to generate $@ >&2; \
fi
.PHONY: changelogs ChangeLog $(srcdir)/ChangeLog

14
build/Makefile.am.common
View file

@ -1,14 +0,0 @@
BUILT_SOURCES =
CLEANFILES =
DISTCLEANFILES =
EXTRA_DIST =
EXTRA_LTLIBRARIES =
EXTRA_PROGRAMS =
MAINTAINERCLEANFILES =
TESTS =
check_PROGRAMS =
CLEANFILES += *.i *.s *.gch
CLEANFILES += $(EXTRA_LTLIBRARIES) $(EXTRA_PROGRAMS) $(check_PROGRAMS)
DISTCLEANFILES += $(BUILT_SOURCES)
MAINTAINERCLEANFILES += Makefile.in

173
build/Makefile.am.gtk-doc
View file

@ -1,173 +0,0 @@
# BEFORE MODIFYING THIS FILE:
#
# This file is a descendant of an old copy of gtk-doc.make, modified for cairo minimally:
#
# - Moved to build/
# - Made it append to EXTRA_DIST and CLEANFILES
# - Instead of all-local, make "doc" build docs, and err if gtk-doc not enabled
# - Some other changed introduced in 7f114b781f5c530d57530e5f76402e41cdabac6b
#
# Before changing it, check to see if a newer gtk-doc.make has fixed the issue you are facing.
# From time to time, it would be nice to update this to the latest copy of gtk-doc.make, but
# please do review all the differences and port our modifications forward.
#
# -*- mode: makefile -*-
####################################
# Everything below here is generic #
####################################
if GTK_DOC_USE_LIBTOOL
GTKDOC_CC = $(LIBTOOL) --tag=CC --mode=compile $(CC) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
GTKDOC_LD = $(LIBTOOL) --tag=CC --mode=link $(CC) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS)
else
GTKDOC_CC = $(CC) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
GTKDOC_LD = $(CC) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS)
endif
# We set GPATH here; this gives us semantics for GNU make
# which are more like other make's VPATH, when it comes to
# whether a source that is a target of one rule is then
# searched for in VPATH/GPATH.
#
GPATH = $(srcdir)
TARGET_DIR=$(HTML_DIR)/$(DOC_MODULE)
EXTRA_DIST += \
$(content_files) \
$(HTML_IMAGES) \
$(DOC_MAIN_SGML_FILE) \
$(DOC_MODULE)-sections.txt \
$(DOC_MODULE)-overrides.txt
DOC_STAMPS=scan-build.stamp sgml-build.stamp html-build.stamp \
$(srcdir)/sgml.stamp $(srcdir)/html.stamp
SCANOBJ_FILES = \
$(DOC_MODULE).args \
$(DOC_MODULE).hierarchy \
$(DOC_MODULE).interfaces \
$(DOC_MODULE).prerequisites \
$(DOC_MODULE).signals
REPORT_FILES = \
$(DOC_MODULE)-undocumented.txt \
$(DOC_MODULE)-undeclared.txt \
$(DOC_MODULE)-unused.txt
CLEANFILES += $(SCANOBJ_FILES) $(REPORT_FILES) $(DOC_STAMPS)
if ENABLE_GTK_DOC
doc: html-build.stamp
else
doc:
@echo "*** gtk-doc must be installed (and --enable-gtk-doc) in order to make doc"
@false
endif
docs: html-build.stamp
#### scan ####
scan-build.stamp: $(HFILE_GLOB) $(CFILE_GLOB) $(EXTRA_HFILES)
@echo 'gtk-doc: Scanning header files'
@-chmod -R u+w $(srcdir)
gtkdoc-scan --module=$(DOC_MODULE) --source-dir=$(DOC_SOURCE_DIR) --ignore-headers="$(IGNORE_HFILES)" $(SCAN_OPTIONS) $(EXTRA_HFILES) --output-dir=$(srcdir)
if grep -l '^..*$$' $(srcdir)/$(DOC_MODULE).types > /dev/null 2>&1 ; then \
CC="$(GTKDOC_CC)" LD="$(GTKDOC_LD)" CFLAGS="$(GTKDOC_CFLAGS)" LDFLAGS="$(GTKDOC_LIBS)" gtkdoc-scangobj $(SCANGOBJ_OPTIONS) --module=$(DOC_MODULE) --output-dir=$(srcdir) ; \
else \
cd $(srcdir) ; \
for i in $(SCANOBJ_FILES) ; do \
test -f $$i || touch $$i ; \
done \
fi
touch scan-build.stamp
$(DOC_MODULE)-decl.txt $(SCANOBJ_FILES) $(DOC_MODULE)-sections.txt $(DOC_MODULE)-overrides.txt: scan-build.stamp
@true
#### xml ####
# gtkdoc-mkdb is broken and requires a --root-dir=$(srcdir) option
# The _srcdir diversion is fragile but works for make check; make distcheck
sgml-build.stamp: $(HFILE_GLOB) $(CFILE_GLOB) $(DOC_MODULE)-sections.txt $(expand_content_files)
@echo 'gtk-doc: Building XML'
@-chmod -R u+w $(srcdir)
_srcdir="`pwd`/$(DOC_SOURCE_DIR)"; \
cd $(srcdir) && gtkdoc-mkdb --module=$(DOC_MODULE) --source-dir=$$_srcdir --output-format=xml --expand-content-files="$(expand_content_files)" --main-sgml-file=$(DOC_MAIN_SGML_FILE) $(MKDB_OPTIONS)
touch sgml-build.stamp
sgml.stamp: sgml-build.stamp
@true
#### html ####
html-build.stamp: sgml.stamp $(DOC_MAIN_SGML_FILE) $(content_files)
@echo 'gtk-doc: Building HTML'
@-chmod -R u+w $(srcdir)
rm -rf $(srcdir)/html
mkdir $(srcdir)/html
cd $(srcdir)/html && gtkdoc-mkhtml $(DOC_MODULE) ../$(DOC_MAIN_SGML_FILE)
test "x$(HTML_IMAGES)" = "x" || ( cd $(srcdir) && cp $(HTML_IMAGES) html )
@echo 'gtk-doc: Fixing cross-references'
cd $(srcdir) && gtkdoc-fixxref --module=$(DOC_MODULE) --module-dir=html --html-dir=$(HTML_DIR) $(FIXXREF_OPTIONS)
touch html-build.stamp
##############
clean-local:
rm -f *~ *.bak
rm -rf .libs
distclean-local:
cd $(srcdir) && \
rm -rf xml $(REPORT_FILES) \
$(DOC_MODULE)-decl-list.txt $(DOC_MODULE)-decl.txt
maintainer-clean-local: clean
cd $(srcdir) && rm -rf xml html
install-data-local:
-installfiles=`echo $(srcdir)/html/*`; \
if test "$$installfiles" = '$(srcdir)/html/*'; \
then echo '-- Nothing to install' ; \
else \
$(mkinstalldirs) $(DESTDIR)$(TARGET_DIR); \
for i in $$installfiles; do \
echo '-- Installing '$$i ; \
$(INSTALL_DATA) $$i $(DESTDIR)$(TARGET_DIR); \
done; \
echo '-- Installing $(srcdir)/html/index.sgml' ; \
$(INSTALL_DATA) $(srcdir)/html/index.sgml $(DESTDIR)$(TARGET_DIR) || :; \
which gtkdoc-rebase >/dev/null && \
gtkdoc-rebase --relative --dest-dir=$(DESTDIR) --html-dir=$(DESTDIR)$(TARGET_DIR) ; \
fi
uninstall-local:
rm -f $(DESTDIR)$(TARGET_DIR)/*
#
# Require gtk-doc when making dist
#
if ENABLE_GTK_DOC
dist-check-gtkdoc:
else
dist-check-gtkdoc:
@echo "*** gtk-doc must be installed (and --enable-gtk-doc) in order to make dist"
@false
endif
dist-hook: dist-check-gtkdoc dist-hook-local
mkdir $(distdir)/xml
mkdir $(distdir)/html
-cp $(srcdir)/xml/*.xml $(distdir)/xml
cp $(srcdir)/html/* $(distdir)/html
-cp $(srcdir)/$(DOC_MODULE).types $(distdir)/
-cp $(srcdir)/$(DOC_MODULE)-sections.txt $(distdir)/
cd $(distdir) && rm -f $(DISTCLEANFILES)
-gtkdoc-rebase --online --relative --html-dir=$(distdir)/html
.PHONY : dist-hook-local docs

194
build/Makefile.am.releasing
View file

@ -1,194 +0,0 @@
# Some custom targets to make it easier to release things.
#
# To make real stable releases or devel snapshots, use either:
# make release-check
# or make release-publish
#
# To make a quick properly named (date and git hash stamped) tarball:
# make snapshot
TAR_OPTIONS = --owner=0 --group=0
dist-hook: dist-clear-sticky-bits
# Clean up any sticky bits we may inherit from parent dir
dist-clear-sticky-bits:
chmod -R a-s $(distdir)
snapshot:
distdir="$(distdir)-`date '+%Y%m%d'`"; \
test -d "$(srcdir)/.git" && distdir=$$distdir-`cd "$(srcdir)" && git rev-parse HEAD | cut -c 1-6`; \
TAR_OPTIONS="$(TAR_OPTIONS)" $(MAKE) $(AM_MAKEFLAGS) distdir="$$distdir" snapshot-dist
snapshot-dist: dist
@(echo "$(distdir) archives ready for distribution: "; \
list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
RELEASE_OR_SNAPSHOT = $$(if test "x$(CAIRO_VERSION_MINOR)" = "x$$(echo "$(CAIRO_VERSION_MINOR)/2*2" | bc)" ; then echo release; else echo snapshot; fi)
RELEASE_UPLOAD_HOST = cairo.freedesktop.org
RELEASE_UPLOAD_BASE = /srv/cairo.freedesktop.org/www
RELEASE_UPLOAD_DIR = $(RELEASE_UPLOAD_BASE)/$(RELEASE_OR_SNAPSHOT)s
RELEASE_URL_BASE = https://cairographics.org/$(RELEASE_OR_SNAPSHOT)s
RELEASE_ANNOUNCE_LIST = cairo-announce@cairographics.org (and CC gnome-announce-list@gnome.org)
MANUAL_VERSIONED = manual-$(VERSION)
MANUAL_TAR_FILE = $(MANUAL_VERSIONED).tar.gz
MANUAL_UPLOAD_DIR = $(RELEASE_UPLOAD_BASE)
tar_file = $(PACKAGE)-$(VERSION).tar.xz
sha1_file = $(tar_file).sha1
gpg_file = $(sha1_file).asc
$(sha1_file): $(tar_file)
sha1sum $^ > $@
$(gpg_file): $(sha1_file)
@echo "Please enter your GPG password to sign the checksum."
gpg --armor --sign $^
release-verify-sane-changelogs: changelogs
@echo -n "Checking that the ChangeLog files are sane..."
@if grep -q "is required to generate" $(CHANGELOGS); then \
(echo "Ouch." && echo "Some of the ChangeLogs are not generated correctly." \
&& echo "Remove ChangeLog* and make changelogs" \
&& false); else :; fi
@echo "Good."
release-verify-sane-tests:
@echo "Checking that the test suite is sane..."
@cd test && $(MAKE) $(AM_MAKEFLAGS) release-verify-sane-tests
release-verify-even-micro:
@echo -n "Checking that $(VERSION) has an even micro component..."
@test "$(CAIRO_VERSION_MICRO)" = "`echo $(CAIRO_VERSION_MICRO)/2*2 | bc`" \
|| (echo "Ouch." && echo "The version micro component '$(CAIRO_VERSION_MICRO)' is not an even number." \
&& echo "The version in configure.in must be incremented before a new release." \
&& false)
@echo "Good."
release-verify-newer:
@echo -n "Checking that no $(VERSION) release already exists..."
@if curl --head --fail --silent "$(RELEASE_URL_BASE)/LATEST-$(PACKAGE)-$(VERSION)" >/dev/null; then \
(echo "Ouch." && echo "Found: $(RELEASE_URL_BASE)/LATEST-$(PACKAGE)-$(VERSION)" \
&& echo "Are you sure you have an updated checkout?" \
&& echo "This should never happen." \
&& false); else :; fi
@echo "Good."
release-remove-old:
$(RM) $(tar_file) $(sha1_file) $(gpg_file)
# Strict ordering enforced for parallel make to work
release-check: \
release-verify-even-micro \
release-verify-sane-changelogs \
release-verify-sane-tests \
release-verify-newer \
$(NULL)
$(MAKE) $(AM_MAKEFLAGS) release-remove-old
TAR_OPTIONS="$(TAR_OPTIONS)" $(MAKE) $(AM_MAKEFLAGS) distcheck
release-upload: $(tar_file) $(sha1_file) $(gpg_file)
mkdir -p releases
scp $(tar_file) $(sha1_file) $(gpg_file) $(RELEASE_UPLOAD_HOST):$(RELEASE_UPLOAD_DIR)
mv $(tar_file) $(sha1_file) $(gpg_file) releases
ssh $(RELEASE_UPLOAD_HOST) "rm -f $(RELEASE_UPLOAD_DIR)/LATEST-$(PACKAGE)-[0-9]* && ln -s $(tar_file) $(RELEASE_UPLOAD_DIR)/LATEST-$(PACKAGE)-$(VERSION)"
git tag -s -m "cairo $(CAIRO_VERSION_MAJOR).$(CAIRO_VERSION_MINOR).$(CAIRO_VERSION_MICRO) release" $(CAIRO_VERSION_MAJOR).$(CAIRO_VERSION_MINOR).$(CAIRO_VERSION_MICRO)
release-publish-message: releases/$(sha1_file)
@echo "Please follow the instructions in RELEASING to push stuff out and"
@echo "send out the announcement mails. Here is the excerpt you need:"
@echo ""
@echo "Subject: $(PACKAGE) $(RELEASE_OR_SNAPSHOT) $(VERSION) now available"
@echo ""
@echo "============================== CUT HERE =============================="
@echo "A new $(PACKAGE) $(RELEASE_OR_SNAPSHOT) $(VERSION) is now available from:"
@echo ""
@echo " $(RELEASE_URL_BASE)/$(tar_file)"
@echo ""
@echo " which can be verified with:"
@echo ""
@echo " $(RELEASE_URL_BASE)/$(sha1_file)"
@echo -n " "
@cat releases/$(sha1_file)
@echo ""
@echo " $(RELEASE_URL_BASE)/$(gpg_file)"
@echo " (signed by `getent passwd "$$USER" | cut -d: -f 5 | cut -d, -f 1`)"
@echo ""
@echo " Additionally, a git clone of the source tree:"
@echo ""
@echo " git clone git://git.cairographics.org/git/cairo"
@echo ""
@echo " will include a signed $(VERSION) tag which points to a commit named:"
@echo " `git cat-file tag $(VERSION) | grep ^object | sed -e 's,object ,,'`"
@echo ""
@echo " which can be verified with:"
@echo " git verify-tag $(VERSION)"
@echo ""
@echo " and can be checked out with a command such as:"
@echo " git checkout -b build $(VERSION)"
@echo ""
@echo "============================== CUT HERE =============================="
doc-publish-versioned: doc
rm -rf ./$(MANUAL_VERSIONED)
cp -a doc/public/html $(MANUAL_VERSIONED)
tar czf $(MANUAL_TAR_FILE) $(MANUAL_VERSIONED)
scp $(MANUAL_TAR_FILE) $(RELEASE_UPLOAD_HOST):$(MANUAL_UPLOAD_DIR)
ssh $(RELEASE_UPLOAD_HOST) "cd $(MANUAL_UPLOAD_DIR) && tar xzf $(MANUAL_TAR_FILE) && ln -sf $(MANUAL_TAR_FILE) cairo-$(MANUAL_TAR_FILE)"
doc-publish-symlinks:
ssh $(RELEASE_UPLOAD_HOST) "cd $(MANUAL_UPLOAD_DIR) && rm -f manual && ln -s $(MANUAL_VERSIONED) manual && ln -sf $(MANUAL_TAR_FILE) cairo-manual.tar.gz"
doc-publish:
$(MAKE) $(AM_MAKEFLAGS) doc-publish-versioned
@if test "$(RELEASE_OR_SNAPSHOT)" = release; then $(MAKE) $(AM_MAKEFLAGS) doc-publish-symlinks; fi
# Strict ordering enforced for parallel make to work
release-publish: release-check
$(MAKE) $(AM_MAKEFLAGS) release-upload
$(MAKE) $(AM_MAKEFLAGS) doc-publish
$(MAKE) $(AM_MAKEFLAGS) release-publish-message
if OS_WIN32
# Win32 package zipfiles
runtime_zip_file = $(PACKAGE)-$(VERSION).zip
developer_zip_file = $(PACKAGE)-dev-$(VERSION).zip
$(runtime_zip_file): install
-$(RM) $@
pwd=`pwd`; cd $(prefix); \
zip "$$pwd"/$@ bin/libcairo-$(CAIRO_VERSION_SONUM).dll
$(developer_zip_file): install
-$(RM) $@
pwd=`pwd`; cd $(prefix); \
zip -r "$$pwd"/$@ include/cairo lib/libcairo.dll.a lib/cairo.lib lib/pkgconfig/cairo.pc lib/pkgconfig/cairo-*.pc share/gtk-doc/html/cairo
zips: $(runtime_zip_file) $(developer_zip_file)
endif
.PHONY: \
dist-clear-sticky-bits \
doc-publish \
doc-publish-symlinks \
doc-publish-versioned \
release-check \
release-publish \
release-publish-message \
release-remove-old \
release-upload \
release-verify-even-micro \
release-verify-newer \
release-verify-sane-changelogs \
release-verify-sane-tests \
snapshot \
snapshot-dist \
$(NULL)

74
build/Makefile.win32.common
View file

@ -1,74 +0,0 @@
default: all
#
# Edit build/Makefile.win32.features to enable features to build
#
include $(top_srcdir)/build/Makefile.win32.inform
include $(top_srcdir)/build/Makefile.win32.features
include $(top_srcdir)/build/Makefile.win32.features-h
ifeq ($(top_builddir),)
top_builddir = $(top_srcdir)
endif
CC := cl
LD := link
AR := lib
ifeq ($(CFG),debug)
CFG_CFLAGS := -MDd -Od -Zi
CFG_LDFLAGS := -DEBUG
else
CFG_CFLAGS := -MD -O2
CFG_LDFLAGS :=
endif
ifeq ($(PIXMAN_PATH),)
PIXMAN_PATH := $(top_builddir)/../pixman
endif
PIXMAN_CFLAGS := -I$(PIXMAN_PATH)/pixman/
PIXMAN_LIBS := $(PIXMAN_PATH)/pixman/$(CFG)/pixman-1.lib
CAIRO_LIBS = gdi32.lib msimg32.lib user32.lib
ifeq ($(CAIRO_HAS_PNG_FUNCTIONS),1)
ifeq ($(LIBPNG_PATH),)
LIBPNG_PATH := $(top_builddir)/../libpng
endif
LIBPNG_CFLAGS += -I$(LIBPNG_PATH)/
CAIRO_LIBS += $(LIBPNG_PATH)/libpng.lib
endif
ifeq ($(CAIRO_HAS_PS_SURFACE)$(CAIRO_HAS_PDF_SURFACE),00)
else
ifeq ($(ZLIB_PATH),)
ZLIB_PATH := $(top_builddir)/../zlib
endif
ZLIB_CFLAGS += -I$(ZLIB_PATH)/
CAIRO_LIBS += $(ZLIB_PATH)/zdll.lib
endif
DEFAULT_CFLAGS = -nologo $(CFG_CFLAGS)
DEFAULT_CFLAGS += -I. -I$(top_srcdir) -I$(top_srcdir)/src
DEFAULT_CFLAGS += $(PIXMAN_CFLAGS) $(LIBPNG_CFLAGS) $(ZLIB_CFLAGS)
CAIRO_CFLAGS = $(DEFAULT_CFLAGS) $(CFLAGS)
DEFAULT_LDFLAGS = -nologo $(CFG_LDFLAGS)
DEFAULT_ARFLAGS = -nologo
CAIRO_LDFLAGS = $(DEFAULT_LDFLAGS) $(LDFLAGS)
CAIRO_ARFLAGS = $(DEFAULT_ARFLAGS) $(LDFLAGS)
# Some generic rules
$(CFG)/%.obj: %.c $(top_srcdir)/src/cairo-features.h
@mkdir -p $(CFG)/`dirname $<`
@$(CC) $(CAIRO_CFLAGS) -c -Fo"$@" $<
$(CFG)/%-static.obj: %.c $(top_srcdir)/src/cairo-features.h
@mkdir -p $(CFG)/`dirname $<`
@$(CC) $(CAIRO_CFLAGS) -c -DCAIRO_WIN32_STATIC_BUILD=1 -Fo"$@" $<
clean:
@rm -f $(CFG)/*.obj $(CFG)/*.dll $(CFG)/*.lib $(CFG)/*.pdb $(CFG)/*.ilk || exit 0

33
build/Makefile.win32.features
View file

@ -1,33 +0,0 @@
# Generated by configure. Modify to customize.
CAIRO_HAS_XLIB_SURFACE=0
CAIRO_HAS_XLIB_XRENDER_SURFACE=0
CAIRO_HAS_XCB_SURFACE=0
CAIRO_HAS_XLIB_XCB_FUNCTIONS=0
CAIRO_HAS_XCB_SHM_FUNCTIONS=0
CAIRO_HAS_QUARTZ_SURFACE=0
CAIRO_HAS_QUARTZ_FONT=0
CAIRO_HAS_QUARTZ_IMAGE_SURFACE=0
CAIRO_HAS_WIN32_SURFACE=1
CAIRO_HAS_WIN32_FONT=1
CAIRO_HAS_PNG_FUNCTIONS=1
CAIRO_HAS_GL_SURFACE=0
CAIRO_HAS_GLESV2_SURFACE=0
CAIRO_HAS_GLESV3_SURFACE=0
CAIRO_HAS_EGL_FUNCTIONS=0
CAIRO_HAS_GLX_FUNCTIONS=0
CAIRO_HAS_WGL_FUNCTIONS=0
CAIRO_HAS_SCRIPT_SURFACE=1
CAIRO_HAS_FT_FONT=0
CAIRO_HAS_FC_FONT=0
CAIRO_HAS_PS_SURFACE=1
CAIRO_HAS_PDF_SURFACE=1
CAIRO_HAS_SVG_SURFACE=1
CAIRO_HAS_TEST_SURFACES=0
CAIRO_HAS_TEE_SURFACE=0
CAIRO_HAS_XML_SURFACE=0
CAIRO_HAS_PTHREAD=0
CAIRO_HAS_GOBJECT_FUNCTIONS=0
CAIRO_HAS_TRACE=0
CAIRO_HAS_INTERPRETER=1
CAIRO_HAS_SYMBOL_LOOKUP=0

106
build/Makefile.win32.features-h
View file

@ -1,106 +0,0 @@
# Generated by configure. Do not edit.
$(top_srcdir)/src/cairo-features.h: $(top_srcdir)/build/Makefile.win32.features
@echo "Generating src/cairo-features.h"
@echo "/* Generated by Makefile.win32.features-h. Do not edit. */" > $(top_srcdir)/src/cairo-features.h
@echo "#ifndef CAIRO_FEATURES_H" >> $(top_srcdir)/src/cairo-features.h
@echo "#define CAIRO_FEATURES_H 1" >> $(top_srcdir)/src/cairo-features.h
ifeq ($(CAIRO_HAS_XLIB_SURFACE),1)
@echo "#define CAIRO_HAS_XLIB_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_XLIB_XRENDER_SURFACE),1)
@echo "#define CAIRO_HAS_XLIB_XRENDER_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_XCB_SURFACE),1)
@echo "#define CAIRO_HAS_XCB_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_XLIB_XCB_FUNCTIONS),1)
@echo "#define CAIRO_HAS_XLIB_XCB_FUNCTIONS 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_XCB_SHM_FUNCTIONS),1)
@echo "#define CAIRO_HAS_XCB_SHM_FUNCTIONS 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_QUARTZ_SURFACE),1)
@echo "#define CAIRO_HAS_QUARTZ_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_QUARTZ_FONT),1)
@echo "#define CAIRO_HAS_QUARTZ_FONT 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_QUARTZ_IMAGE_SURFACE),1)
@echo "#define CAIRO_HAS_QUARTZ_IMAGE_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_WIN32_SURFACE),1)
@echo "#define CAIRO_HAS_WIN32_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_WIN32_FONT),1)
@echo "#define CAIRO_HAS_WIN32_FONT 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_PNG_FUNCTIONS),1)
@echo "#define CAIRO_HAS_PNG_FUNCTIONS 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_GL_SURFACE),1)
@echo "#define CAIRO_HAS_GL_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_GLESV2_SURFACE),1)
@echo "#define CAIRO_HAS_GLESV2_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_GLESV3_SURFACE),1)
@echo "#define CAIRO_HAS_GLESV3_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_EGL_FUNCTIONS),1)
@echo "#define CAIRO_HAS_EGL_FUNCTIONS 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_GLX_FUNCTIONS),1)
@echo "#define CAIRO_HAS_GLX_FUNCTIONS 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_WGL_FUNCTIONS),1)
@echo "#define CAIRO_HAS_WGL_FUNCTIONS 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_SCRIPT_SURFACE),1)
@echo "#define CAIRO_HAS_SCRIPT_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_FT_FONT),1)
@echo "#define CAIRO_HAS_FT_FONT 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_FC_FONT),1)
@echo "#define CAIRO_HAS_FC_FONT 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_PS_SURFACE),1)
@echo "#define CAIRO_HAS_PS_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_PDF_SURFACE),1)
@echo "#define CAIRO_HAS_PDF_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_SVG_SURFACE),1)
@echo "#define CAIRO_HAS_SVG_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_TEST_SURFACES),1)
@echo "#define CAIRO_HAS_TEST_SURFACES 1" >> $(top_srcdir)/src/cairo-features.h
endif
@echo "#define CAIRO_HAS_IMAGE_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
@echo "#define CAIRO_HAS_MIME_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
@echo "#define CAIRO_HAS_RECORDING_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
@echo "#define CAIRO_HAS_OBSERVER_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
ifeq ($(CAIRO_HAS_TEE_SURFACE),1)
@echo "#define CAIRO_HAS_TEE_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_XML_SURFACE),1)
@echo "#define CAIRO_HAS_XML_SURFACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
@echo "#define CAIRO_HAS_USER_FONT 1" >> $(top_srcdir)/src/cairo-features.h
ifeq ($(CAIRO_HAS_PTHREAD),1)
@echo "#define CAIRO_HAS_PTHREAD 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_GOBJECT_FUNCTIONS),1)
@echo "#define CAIRO_HAS_GOBJECT_FUNCTIONS 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_TRACE),1)
@echo "#define CAIRO_HAS_TRACE 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_INTERPRETER),1)
@echo "#define CAIRO_HAS_INTERPRETER 1" >> $(top_srcdir)/src/cairo-features.h
endif
ifeq ($(CAIRO_HAS_SYMBOL_LOOKUP),1)
@echo "#define CAIRO_HAS_SYMBOL_LOOKUP 1" >> $(top_srcdir)/src/cairo-features.h
endif
@echo "#endif" >> $(top_srcdir)/src/cairo-features.h

13
build/Makefile.win32.inform
View file

@ -1,13 +0,0 @@
inform:
@echo
ifneq ($(CFG),release)
ifneq ($(CFG),debug)
@echo "Invalid configuration "$(CFG)" specified."
@echo -n "You must specify a configuration when "
@echo "running make, e.g. make CFG=debug"
@echo
@echo -n "Possible choices for configuration are "
@echo "'release' and 'debug'"
@exit 1
endif
endif

228
build/aclocal.cairo.m4
View file

@ -1,228 +0,0 @@
dnl ==========================================================================
dnl
dnl Cairo-specific macros
dnl
dnl ==========================================================================
dnl Usage:
dnl CAIRO_BIGENDIAN
dnl
AC_DEFUN([CAIRO_BIGENDIAN],
[dnl
case $host_os in
darwin*)
AH_VERBATIM([X_BYTE_ORDER],
[
/* Deal with multiple architecture compiles on Mac OS X */
#ifdef __APPLE_CC__
#ifdef __BIG_ENDIAN__
#define WORDS_BIGENDIAN 1
#define FLOAT_WORDS_BIGENDIAN 1
#else
#undef WORDS_BIGENDIAN
#undef FLOAT_WORDS_BIGENDIAN
#endif
#endif
])
;;
*)
AC_C_BIGENDIAN
AX_C_FLOAT_WORDS_BIGENDIAN
;;
esac
])
dnl CAIRO_CHECK_FUNCS_WITH_FLAGS(FUNCTION..., CFLAGS, LIBS
dnl [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
dnl Like AC_CHECK_FUNCS but with additional CFLAGS and LIBS
dnl --------------------------------------------------------------------
AC_DEFUN([CAIRO_CHECK_FUNCS_WITH_FLAGS],
[dnl
_save_cflags="$CFLAGS"
_save_libs="$LIBS"
CFLAGS="$CFLAGS $2"
LIBS="$LIBS $3"
AC_CHECK_FUNCS($1, $4, $5)
CFLAGS="$_save_cflags"
LIBS="$_save_libs"
])
dnl CAIRO_CONFIG_COMMANDS is like AC_CONFIG_COMMANDS, except that:
dnl
dnl 1) It redirects the stdout of the command to the file.
dnl 2) It does not recreate the file if contents didn't change.
dnl
AC_DEFUN([CAIRO_CONFIG_COMMANDS],
[dnl
AC_CONFIG_COMMANDS($1,
[
_config_file=$1
_tmp_file=cairoconf.tmp
AC_MSG_NOTICE([creating $_config_file])
{
$2
} >> "$_tmp_file" ||
AC_MSG_ERROR([failed to write to $_tmp_file])
if cmp -s "$_tmp_file" "$_config_file"; then
AC_MSG_NOTICE([$_config_file is unchanged])
rm -f "$_tmp_file"
else
mv "$_tmp_file" "$_config_file" ||
AC_MSG_ERROR([failed to update $_config_file])
fi
], $3)
])
dnl CAIRO_CC_TRY_LINK_WITH_ENV_SILENT(env-setup, program,
dnl true-action, false-action)
dnl
dnl Compile and link the program with the given environment setup.
dnl The global cairo_cc_flag is set to "yes" or "no" according as
dnl the link succeeded or not. The link step must complete without
dnl warnings or errors to stderr.
dnl
dnl Perform true-action on success and false-action on failure.
dnl The values of CFLAGS, LIBS, LDFLAGS are saved before env-setup
dnl is executed and restored right before the end of the macro.
AC_DEFUN([CAIRO_CC_TRY_LINK_WITH_ENV_SILENT],[dnl
# AC_LANG_PROGRAM() produces a main() w/o args,
# but -Wold-style-definition doesn't like that.
# We need _some_ program so that we don't get
# warnings about empty compilation units, so always
# append a reasonable main().
_compile_program="$2"'
int main(int c, char **v) { (void)c; (void)v; return 0; }'
_save_cflags="$CFLAGS"
_save_ldflags="$LDFLAGS"
_save_libs="$LIBS"
$1
AC_LINK_IFELSE(
[AC_LANG_SOURCE([[$_compile_program]])],
[cairo_cc_stderr=`test -f conftest.err && cat conftest.err`
cairo_cc_flag=yes],
[cairo_cc_stderr=`test -f conftest.err && cat conftest.err`
cairo_cc_flag=no])
if test "x$cairo_cc_stderr" != "x"; then
cairo_cc_flag=no
fi
if test "x$cairo_cc_flag" = "xyes"; then
ifelse([$3], , :, [$3])
else
ifelse([$4], , :, [$4])
fi
CFLAGS="$_save_cflags"
LDFLAGS="$_save_ldflags"
LIBS="$_save_libs"
])
dnl check compiler flags with a program and no muttering.
AC_DEFUN([CAIRO_CC_TRY_FLAG_SILENT],
[dnl (flags..., optional program, true-action, false-action)
CAIRO_CC_TRY_LINK_WITH_ENV_SILENT([CFLAGS="$CFLAGS $1"],
[$2], [$3], [$4])
])
dnl find a -Werror equivalent
AC_DEFUN([CAIRO_CC_CHECK_WERROR],
[dnl
_test_WERROR=${WERROR+set}
if test "z$_test_WERROR" != zset; then
WERROR=""
for _werror in -Werror -errwarn; do
AC_MSG_CHECKING([whether $CC supports $_werror])
CAIRO_CC_TRY_FLAG_SILENT(
[$_werror],,
[WERROR="$WERROR $_werror"],
[:])
AC_MSG_RESULT($cairo_cc_flag)
done
fi
])
dnl check compiler flags possibly using -Werror if available.
AC_DEFUN([CAIRO_CC_TRY_FLAG],
[dnl (flags..., optional program, true-action, false-action)
CAIRO_CC_CHECK_WERROR
AC_MSG_CHECKING([whether $CC supports $1])
CAIRO_CC_TRY_FLAG_SILENT([$WERROR $1], [$2], [$3], [$4])
AC_MSG_RESULT([$cairo_cc_flag])
])
dnl Usage:
dnl CAIRO_CHECK_NATIVE_ATOMIC_PRIMITIVES
AC_DEFUN([CAIRO_CHECK_NATIVE_ATOMIC_PRIMITIVES],
[dnl
AC_CACHE_CHECK([for native atomic primitives], cairo_cv_atomic_primitives,
[
cairo_cv_atomic_primitives="none"
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
int atomic_add(int i) { return __sync_fetch_and_add (&i, 1); }
int atomic_cmpxchg(int i, int j, int k) { return __sync_val_compare_and_swap (&i, j, k); }
]], [[]])],
[ cairo_cv_atomic_primitives="gcc-legacy" ], []
)
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
int atomic_add(int i) { return __atomic_fetch_add(&i, 1, __ATOMIC_SEQ_CST); }
int atomic_cmpxchg(int i, int j, int k) { return __atomic_compare_exchange_n(&i, &j, k, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
]], [[]])],
[ cairo_cv_atomic_primitives="cxx11" ], []
)
if test "x$cairo_cv_atomic_primitives" = "xnone"; then
AC_CHECK_HEADER([atomic_ops.h],
cairo_cv_atomic_primitives="libatomic-ops")
fi
if test "x$cairo_cv_atomic_primitives" = "xnone"; then
AC_CHECK_HEADER([libkern/OSAtomic.h],
cairo_cv_atomic_primitives="OSAtomic")
fi
])
if test "x$cairo_cv_atomic_primitives" = xcxx11; then
AC_DEFINE(HAVE_CXX11_ATOMIC_PRIMITIVES, 1,
[Enable if your compiler supports the GCC __atomic_* atomic primitives])
fi
if test "x$cairo_cv_atomic_primitives" = xgcc-legacy; then
AC_DEFINE(HAVE_GCC_LEGACY_ATOMICS, 1,
[Enable if your compiler supports the legacy GCC __sync_* atomic primitives])
fi
if test "x$cairo_cv_atomic_primitives" = "xlibatomic-ops"; then
AC_DEFINE(HAVE_LIB_ATOMIC_OPS, 1,
[Enable if you have libatomic-ops-dev installed])
fi
if test "x$cairo_cv_atomic_primitives" = xOSAtomic; then
AC_DEFINE(HAVE_OS_ATOMIC_OPS, 1,
[Enable if you have MacOS X atomic operations])
fi
])
dnl Usage:
dnl CAIRO_CHECK_ATOMIC_OP_NEEDS_MEMORY_BARRIER
AC_DEFUN([CAIRO_CHECK_ATOMIC_OP_NEEDS_MEMORY_BARRIER],
[dnl
AC_CACHE_CHECK([whether atomic ops require a memory barrier], cairo_cv_atomic_op_needs_memory_barrier,
[
case $host_cpu in
i?86) cairo_cv_atomic_op_needs_memory_barrier="no" ;;
x86_64) cairo_cv_atomic_op_needs_memory_barrier="no" ;;
arm*) cairo_cv_atomic_op_needs_memory_barrier="yes" ;;
*) cairo_cv_atomic_op_needs_memory_barrier="yes" ;;
esac
])
if test "x$cairo_cv_atomic_op_needs_memory_barrier" = "xyes"; then
AC_DEFINE_UNQUOTED(ATOMIC_OP_NEEDS_MEMORY_BARRIER, 1,
[whether memory barriers are needed around atomic operations])
fi
])
AC_DEFUN([CAIRO_TEXT_WRAP], [m4_text_wrap([$1], [$2],, 78)])

162
build/aclocal.compare.m4
View file

@ -1,162 +0,0 @@
dnl @synopsis AX_COMPARE_VERSION(VERSION_A, OP, VERSION_B, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
dnl
dnl This macro compares two version strings. It is used heavily in the
dnl macro _AX_PATH_BDB for library checking. Due to the various number
dnl of minor-version numbers that can exist, and the fact that string
dnl comparisons are not compatible with numeric comparisons, this is
dnl not necessarily trivial to do in a autoconf script. This macro
dnl makes doing these comparisons easy.
dnl
dnl The six basic comparisons are available, as well as checking
dnl equality limited to a certain number of minor-version levels.
dnl
dnl The operator OP determines what type of comparison to do, and can
dnl be one of:
dnl
dnl eq - equal (test A == B)
dnl ne - not equal (test A != B)
dnl le - less than or equal (test A <= B)
dnl ge - greater than or equal (test A >= B)
dnl lt - less than (test A < B)
dnl gt - greater than (test A > B)
dnl
dnl Additionally, the eq and ne operator can have a number after it to
dnl limit the test to that number of minor versions.
dnl
dnl eq0 - equal up to the length of the shorter version
dnl ne0 - not equal up to the length of the shorter version
dnl eqN - equal up to N sub-version levels
dnl neN - not equal up to N sub-version levels
dnl
dnl When the condition is true, shell commands ACTION-IF-TRUE are run,
dnl otherwise shell commands ACTION-IF-FALSE are run. The environment
dnl variable 'ax_compare_version' is always set to either 'true' or
dnl 'false' as well.
dnl
dnl Examples:
dnl
dnl AX_COMPARE_VERSION([3.15.7],[lt],[3.15.8])
dnl AX_COMPARE_VERSION([3.15],[lt],[3.15.8])
dnl
dnl would both be true.
dnl
dnl AX_COMPARE_VERSION([3.15.7],[eq],[3.15.8])
dnl AX_COMPARE_VERSION([3.15],[gt],[3.15.8])
dnl
dnl would both be false.
dnl
dnl AX_COMPARE_VERSION([3.15.7],[eq2],[3.15.8])
dnl
dnl would be true because it is only comparing two minor versions.
dnl
dnl AX_COMPARE_VERSION([3.15.7],[eq0],[3.15])
dnl
dnl would be true because it is only comparing the lesser number of
dnl minor versions of the two values.
dnl
dnl Note: The characters that separate the version numbers do not
dnl matter. An empty string is the same as version 0. OP is evaluated
dnl by autoconf, not configure, so must be a string, not a variable.
dnl
dnl The author would like to acknowledge Guido Draheim whose advice
dnl about the m4_case and m4_ifvaln functions make this macro only
dnl include the portions necessary to perform the specific comparison
dnl specified by the OP argument in the final configure script.
dnl
dnl @category Misc
dnl @author Tim Toolan <toolan@ele.uri.edu>
dnl @version 2004-03-01
dnl @license GPLWithACException
dnl #########################################################################
AC_DEFUN([AX_COMPARE_VERSION], [
# Used to indicate true or false condition
ax_compare_version=false
# Convert the two version strings to be compared into a format that
# allows a simple string comparison. The end result is that a version
# string of the form 1.12.5-r617 will be converted to the form
# 0001001200050617. In other words, each number is zero padded to four
# digits, and non digits are removed.
AS_VAR_PUSHDEF([A],[ax_compare_version_A])
A=`echo "$1" | sed -e 's/\([[0-9]]*\)/Z\1Z/g' \
-e 's/Z\([[0-9]]\)Z/Z0\1Z/g' \
-e 's/Z\([[0-9]][[0-9]]\)Z/Z0\1Z/g' \
-e 's/Z\([[0-9]][[0-9]][[0-9]]\)Z/Z0\1Z/g' \
-e 's/[[^0-9]]//g'`
AS_VAR_PUSHDEF([B],[ax_compare_version_B])
B=`echo "$3" | sed -e 's/\([[0-9]]*\)/Z\1Z/g' \
-e 's/Z\([[0-9]]\)Z/Z0\1Z/g' \
-e 's/Z\([[0-9]][[0-9]]\)Z/Z0\1Z/g' \
-e 's/Z\([[0-9]][[0-9]][[0-9]]\)Z/Z0\1Z/g' \
-e 's/[[^0-9]]//g'`
dnl # In the case of le, ge, lt, and gt, the strings are sorted as necessary
dnl # then the first line is used to determine if the condition is true.
dnl # The sed right after the echo is to remove any indented white space.
m4_case(m4_tolower($2),
[lt],[
ax_compare_version=`echo "x$A
x$B" | sed 's/^ *//' | sort -r | sed "s/x${A}/false/;s/x${B}/true/;1q"`
],
[gt],[
ax_compare_version=`echo "x$A
x$B" | sed 's/^ *//' | sort | sed "s/x${A}/false/;s/x${B}/true/;1q"`
],
[le],[
ax_compare_version=`echo "x$A
x$B" | sed 's/^ *//' | sort | sed "s/x${A}/true/;s/x${B}/false/;1q"`
],
[ge],[
ax_compare_version=`echo "x$A
x$B" | sed 's/^ *//' | sort -r | sed "s/x${A}/true/;s/x${B}/false/;1q"`
],[
dnl Split the operator from the subversion count if present.
m4_bmatch(m4_substr($2,2),
[0],[
# A count of zero means use the length of the shorter version.
# Determine the number of characters in A and B.
ax_compare_version_len_A=`echo "$A" | awk '{print(length)}'`
ax_compare_version_len_B=`echo "$B" | awk '{print(length)}'`
# Set A to no more than B's length and B to no more than A's length.
A=`echo "$A" | sed "s/\(.\{$ax_compare_version_len_B\}\).*/\1/"`
B=`echo "$B" | sed "s/\(.\{$ax_compare_version_len_A\}\).*/\1/"`
],
[[0-9]+],[
# A count greater than zero means use only that many subversions
A=`echo "$A" | sed "s/\(\([[0-9]]\{4\}\)\{m4_substr($2,2)\}\).*/\1/"`
B=`echo "$B" | sed "s/\(\([[0-9]]\{4\}\)\{m4_substr($2,2)\}\).*/\1/"`
],
[.+],[
AC_WARNING(
[illegal OP numeric parameter: $2])
],[])
# Pad zeros at end of numbers to make same length.
ax_compare_version_tmp_A="$A`echo $B | sed 's/./0/g'`"
B="$B`echo $A | sed 's/./0/g'`"
A="$ax_compare_version_tmp_A"
# Check for equality or inequality as necessary.
m4_case(m4_tolower(m4_substr($2,0,2)),
[eq],[
test "x$A" = "x$B" && ax_compare_version=true
],
[ne],[
test "x$A" != "x$B" && ax_compare_version=true
],[
AC_WARNING([illegal OP parameter: $2])
])
])
AS_VAR_POPDEF([A])dnl
AS_VAR_POPDEF([B])dnl
dnl # Execute ACTION-IF-TRUE / ACTION-IF-FALSE.
if test "$ax_compare_version" = "true" ; then
m4_ifvaln([$4],[$4],[:])dnl
m4_ifvaln([$5],[else $5])dnl
fi
]) dnl AX_COMPARE_VERSION

409
build/aclocal.enable.m4
View file

@ -1,409 +0,0 @@
dnl
dnl These are the facilities for enable/disabling various features,
dnl and for collecting CFLAGS/LIBS and generating per feature .pc
dnl files, assembling list of source files to compile, creating
dnl cairo-features.h and other generated files, etc...
dnl
dnl ===========================================================================
dnl
dnl Define a macro to enable features
dnl - Macro: _CAIRO_ENABLE (ID, NAME, WHAT, DEFAULT, COMMANDS)
dnl
dnl where:
dnl
dnl ID is the sub-namespace in function names, eg. "ft" for cairo_ft_...
dnl NAME is the human-readable name of the feature, eg. "FreeType font"
dnl WHAT is the type of feature:
dnl "surface" for surface backends
dnl "font" for font backends
dnl "functions" for set of functions
dnl "" for private configurations
dnl DEFAULT is the default state of the feature:
dnl "no" for experimental features, eg. your favorite new backend
dnl "yes" for recommended features, eg. png functions
dnl "auto" for other supported features, eg. xlib surface backend
dnl "always" for mandatory features (can't be disabled), eg. image surface backend
dnl COMMANDS are run to check whether the feature can be enabled.
dnl They should set use_$(ID) to something other than yes if the
dnl feature cannot be built, eg. "no (requires SomeThing)". It then
dnl should also set $(ID)_REQUIRES/CFLAGS/LIBS/...
dnl appropriately. Look at the macro definition for more details,
dnl or ask if in doubt.
dnl
AC_DEFUN([_CAIRO_ENABLE],
[dnl
dnl Sanity check ID
m4_if(
[$1],
m4_tolower(AS_TR_SH([$1])),
,
[m4_fatal([invalid feature name `$1'])]
)dnl
m4_pushdef([cr_feature], [$1])dnl
m4_pushdef([cr_feature_name], m4_normalize([$2]))dnl
m4_pushdef([cr_feature_what], m4_normalize([$3]))dnl
m4_pushdef([cr_feature_default], m4_normalize([$4]))dnl
m4_pushdef([cr_feature_commands], [$5])dnl
dnl
m4_pushdef([cr_feature_arg], m4_translit([$1],_,-))dnl
dnl
dnl Sanity check default
m4_case(
cr_feature_default,
[no],,
[yes],,
[auto],,
[always],,
[m4_fatal([Invalid default value `]cr_feature_default[' for feature `]cr_feature['])]
)dnl
dnl
m4_if(cr_feature_default, [always],
[dnl
enable_$1=yes
],[dnl
AC_ARG_ENABLE(cr_feature_arg,
AS_HELP_STRING([--enable-]cr_feature_arg[=@<:@no/auto/yes@:>@],
[Enable cairo's ]cr_feature_name[ feature @<:@default=]cr_feature_default[@:>@]),
enable_$1=$enableval, enable_$1=cr_feature_default)
])dnl
dnl
AS_CASE([$enable_$1],
[no],[dnl
use_$1="no (disabled, use --enable-cr_feature_arg to enable)"
],dnl
[yes|auto],[dnl
AC_MSG_CHECKING([for cairo's ]cr_feature_name[ feature])
echo
use_[]$1=yes
CAIRO_FEATURE_VARS_FOREACH(cr_var, [cr_feature[_]cr_var[=]_CAIRO_SH_ESCAPE_UNQUOTED(m4_do([cr_var_default_]cr_var[_value]))]m4_newline)
cr_feature_commands
AC_MSG_CHECKING([whether cairo's ]cr_feature_name[ feature could be enabled])
AC_MSG_RESULT([$use_$1])
AS_IF([test "x$enable_$1" = "xyes" -a "x$use_$1" != xyes],
[dnl
AC_MSG_ERROR(
m4_case(cr_feature_default,
[always], [mandatory],
[yes], [recommended],
, [requested]
) cr_feature_name[ feature could not be enabled])
])dnl
],dnl
[dnl
AC_MSG_ERROR([invalid argument passed to --enable-]cr_feature_arg[: `$use_$1', should be one of @<:@no/auto/yes@:>@])
])dnl
AS_IF([test "x$use_$1" = "xyes"],
[dnl
CAIRO_ACCUMULATED_FEATURE_VARS_FOREACH([cr_var],
[dnl
CAIRO_ACCUMULATE_UNQUOTED_BEFORE(cr_var, [$]cr_feature[_]cr_var)
])dnl
],[dnl
dnl If not enabled, empty the vars so no one accidentally uses them.
CAIRO_FEATURE_VARS_FOREACH([cr_var], [unset cr_feature[_]cr_var]m4_newline)
])dnl
_CAIRO_FEATURE_HOOKS(cr_feature, cr_feature_name, cr_feature_default, cr_feature_what)dnl
m4_popdef([cr_feature])dnl
m4_popdef([cr_feature_name])dnl
m4_popdef([cr_feature_what])dnl
m4_popdef([cr_feature_default])dnl
m4_popdef([cr_feature_commands])dnl
m4_popdef([cr_feature_arg])dnl
])
dnl ===========================================================================
m4_define([_CAIRO_FEATURE_VARS])
dnl
dnl CAIRO_FEATURE_VARS_REGISTER(VARS, DEFAULT-VALUE=[])
dnl
dnl Registers variables to be collected from feature-enabling code segments.
dnl VARS should be a whitespace-separate list of variable names.
dnl
dnl DEFAULT-VALUE is m4 macros to set default value of VARS
dnl
AC_DEFUN([CAIRO_FEATURE_VARS_REGISTER],
[dnl
m4_foreach_w([cr_var], [$1],
[m4_append_uniq([_CAIRO_FEATURE_VARS], cr_var, [ ],,
[m4_fatal([Feature variable `]cr_var[' already registered])])])dnl
m4_foreach_w([cr_var], [$1],
[dnl
m4_define([cr_var_default_]cr_var[_value], m4_default([$2],[[$ac_env_[]]cr_feature[[]_]]cr_var[[_value]]))dnl
])dnl
])
dnl
dnl CAIRO_FEATURE_VARS_FOREACH(VAR, COMMANDS)
dnl
dnl Run COMMANDS for each registered feature variable.
dnl Defines VAR to the variable being processed.
dnl
AC_DEFUN([CAIRO_FEATURE_VARS_FOREACH],
[dnl
m4_foreach_w([$1], _CAIRO_FEATURE_VARS, [$2])dnl
])
dnl ===========================================================================
m4_define([_CAIRO_ACCUMULATORS])dnl
m4_define([_CAIRO_ACCUMULATORS_REGISTER],
[dnl
m4_foreach_w([cr_var], [$1],
[m4_append_uniq([_CAIRO_ACCUMULATORS], cr_var, [ ],,
[m4_fatal([Accumulator `]cr_var[' already registered])])])dnl
m4_foreach_w([cr_var], [$1], [m4_define([cr_acc_]cr_var[_sep], [$2])])dnl
m4_foreach_w([cr_var], [$1], [[CAIRO_]cr_var[=$3]]m4_newline)dnl
m4_foreach_w([cr_var], [$1], [m4_pattern_allow([CAIRO_]cr_var)])dnl
])dnl
m4_define([_CAIRO_SH_ESCAPE],['m4_bpatsubst([$1],['],[\\'])'])dnl
m4_define([_CAIRO_SH_ESCAPE_UNQUOTED],["m4_bpatsubst([$1],["],[\\"])"])dnl
dnl
dnl CAIRO_ACCUMULATORS_REGISTER(VARS, SEPARATOR=[], INITIAL-VALUE=[])
dnl
dnl Registers accumulators. An accumulator is a shell variable that can
dnl be accumulated to. The macros take care of adding a SEPARATOR between
dnl accumulated values.
dnl
dnl VARS should be a whitespace-separate list of variable names. The actual
dnl shell variable resulting for each variable is prefixed with CAIRO_.
dnl
AC_DEFUN([CAIRO_ACCUMULATORS_REGISTER],
[dnl
_CAIRO_ACCUMULATORS_REGISTER([$1],[$2],_CAIRO_SH_ESCAPE([$3]))dnl
])dnl
dnl
dnl Like CAIRO_ACCUMULATORS_REGISTER but INITIAL-VALUE is left unquoted,
dnl so it can reference other shell variables for example.
dnl
AC_DEFUN([CAIRO_ACCUMULATORS_REGISTER_UNQUOTED],
[dnl
_CAIRO_ACCUMULATORS_REGISTER([$1],[$2],_CAIRO_SH_ESCAPE_UNQUOTED([$3]))dnl
])dnl
m4_define([_CAIRO_ACCUMULATOR_CHECK],
[dnl
m4_ifdef([cr_acc_$1_sep],,[m4_fatal([Accumulator `]$1[' not defined.])])dnl
])dnl
m4_define([_CAIRO_ACCUMULATE],
[dnl
_CAIRO_ACCUMULATOR_CHECK([$1])dnl
m4_ifval([$2], [$3]m4_newline)dnl
])dnl
dnl
dnl CAIRO_ACCUMULATE(VAR, VALUE)
dnl
dnl Appends VALUE to accumulator VAR
dnl
AC_DEFUN([CAIRO_ACCUMULATE],
[dnl
_CAIRO_ACCUMULATE([$1], [$2], [CAIRO_$1="${CAIRO_$1}]m4_do([cr_acc_$1_sep])["_CAIRO_SH_ESCAPE([$2])])dnl
])dnl
dnl
dnl CAIRO_ACCUMULATE_BEFORE(VAR, VALUE)
dnl
dnl Prepends VALUE to accumulator VAR
dnl
AC_DEFUN([CAIRO_ACCUMULATE_BEFORE],
[dnl
_CAIRO_ACCUMULATE([$1], [$2], [CAIRO_$1=_CAIRO_SH_ESCAPE([$2])"]m4_do([cr_acc_$1_sep])[${CAIRO_$1}"])dnl
])dnl
m4_define([_CAIRO_ACCUMULATE_UNQUOTED],
[dnl
_CAIRO_ACCUMULATOR_CHECK([$1])dnl
m4_ifval([$2], [m4_bmatch([$2],[[$]],[test -n "$2" &&]) $3]m4_newline)dnl
])dnl
dnl
dnl CAIRO_ACCUMULATE_UNQUOTED(VAR, VALUE)
dnl
dnl Like CAIRO_ACCUMULATE but VALUE is left unquoted,
dnl so it can reference other shell variables for example.
dnl
AC_DEFUN([CAIRO_ACCUMULATE_UNQUOTED],
[dnl
_CAIRO_ACCUMULATE_UNQUOTED([$1], [$2], [CAIRO_$1="${CAIRO_$1}]m4_do([cr_acc_$1_sep])["]_CAIRO_SH_ESCAPE_UNQUOTED([$2]))dnl
])dnl
dnl
dnl CAIRO_ACCUMULATE_UNQUOTED_BEFORE(VAR, VALUE)
dnl
dnl Like CAIRO_ACCUMULATE_BEFORE but VALUE is left unquoted,
dnl so it can reference other shell variables for example.
dnl
AC_DEFUN([CAIRO_ACCUMULATE_UNQUOTED_BEFORE],
[dnl
_CAIRO_ACCUMULATE_UNQUOTED([$1], [$2], [CAIRO_$1=]_CAIRO_SH_ESCAPE_UNQUOTED([$2])["]m4_do([cr_acc_$1_sep])[${CAIRO_$1}"])dnl
])dnl
dnl
dnl CAIRO_ACCUMULATE_UNQUOTED_UNCHECKED(VAR, VALUE)
dnl
dnl Like CAIRO_ACCUMULATE_UNQUOTED but VALUE is not tested for emptiness.
dnl
AC_DEFUN([CAIRO_ACCUMULATE_UNQUOTED_UNCHECKED],
[dnl
_CAIRO_ACCUMULATE([$1], [$2], [CAIRO_$1="${CAIRO_$1}]m4_do([cr_acc_$1_sep])["]_CAIRO_SH_ESCAPE_UNQUOTED([$2]))dnl
])dnl
dnl
dnl CAIRO_ACCUMULATE_UNQUOTED_UNCHECKED_BEFORE(VAR, VALUE)
dnl
dnl Like CAIRO_ACCUMULATE_UNQUOTED_BEFORE but VALUE is not tested for emptiness.
dnl
AC_DEFUN([CAIRO_ACCUMULATE_UNQUOTED_BEFORE],
[dnl
_CAIRO_ACCUMULATE([$1], [$2], [CAIRO_$1=]_CAIRO_SH_ESCAPE_UNQUOTED([$2])["]m4_do([cr_acc_$1_sep])[${CAIRO_$1}"])dnl
])dnl
dnl
dnl CAIRO_ACCUMULATORS_FOREACH(VAR, COMMANDS)
dnl
dnl Run COMMANDS for each registered accumulator.
dnl Defines VAR to the accumulator being processed.
dnl
AC_DEFUN([CAIRO_ACCUMULATORS_FOREACH],
[dnl
m4_foreach_w([$1], _CAIRO_ACCUMULATORS, [$2])dnl
])dnl
dnl ===========================================================================
m4_define([_CAIRO_ACCUMULATED_FEATURE_VARS])dnl
dnl
dnl CAIRO_ACCUMULATED_FEATURE_VARS_REGISTER(VARS, DEFAULT-VALUE=[], SEPARATOR=[], INITIAL-VALUE=[])
dnl
dnl Defines VARS as feature variables and accumulators. Also accumulates
dnl (prepending, not appending) feature values for VARS.
dnl
AC_DEFUN([CAIRO_ACCUMULATED_FEATURE_VARS_REGISTER],
[dnl
m4_foreach_w([cr_var], [$1],
[m4_append_uniq([_CAIRO_ACCUMULATED_FEATURE_VARS], cr_var, [ ],,
[m4_fatal([Accumulated feature variable `]cr_var[' already registered])])])dnl
CAIRO_FEATURE_VARS_REGISTER([$1],[$2])dnl
CAIRO_ACCUMULATORS_REGISTER_UNQUOTED([$1],[$3],[$4])dnl
])dnl
dnl
dnl CAIRO_ACCUMULATED_FEATURE_VARS_FOREACH(VAR, COMMANDS)
dnl
dnl Run COMMANDS for each registered accumulated feature variable.
dnl Defines VAR to the variable being processed.
dnl
AC_DEFUN([CAIRO_ACCUMULATED_FEATURE_VARS_FOREACH],
[dnl
m4_foreach_w([$1], _CAIRO_ACCUMULATED_FEATURE_VARS, [$2])dnl
])dnl
dnl ===========================================================================
dnl
dnl CAIRO_FEATURE_IF_ENABLED(FEATURE=cr_feature, COMMANDS)
dnl
dnl Run COMMANDS if FEATURE is enabled.
dnl
AC_DEFUN([CAIRO_FEATURE_IF_ENABLED],
[dnl
AS_IF([test "x$use_]m4_default([$1], cr_feature)[" = xyes], [$2], [$3])dnl
])dnl
m4_define([_CAIRO_FEATURE_HOOK_MATCH_SH_BOOL],
[dnl
m4_case([$1],
[*], [$3],
[no], [AS_IF([test "x$2" != xyes], [:m4_newline()$3])],
[yes], [AS_IF([test "x$2" = xyes], [:m4_newline()$3])],
[m4_fatal([Invalid ENABLED value `]$1['])])dnl
])dnl
m4_define([_CAIRO_FEATURE_HOOK_MATCH_M4],
[dnl
m4_case([$1],
[*], [$3],
[$2], [$3],
[!$2], ,
[m4_bmatch([$1], [^!], [$3])])dnl
])dnl
m4_define([_CAIRO_FEATURE_HOOKS])dnl
dnl
dnl CAIRO_FEATURE_HOOK_REGISTER(ENABLED, DEFAULT, WHAT, COMMANDS)
dnl
dnl ENABLED is the feature enabledness to match
dnl DEFAULT is the default value of features to match
dnl WHAT is the type of features to match
dnl COMMANDS is commands to run for matched features.
dnl
dnl Runs COMMANDS for features matching ENABLED, DEFAULT, and WHAT.
dnl Hooks are run for each feature in the order they are added.
dnl
dnl DEFAULT and WHAT are matched like this:
dnl [*] matches all values
dnl [val] matches [val]
dnl [!val] matches anything other than [val]
dnl
dnl ENABLED is matched like this:
dnl [yes] matches enabled features
dnl [no] matches disabled features
dnl [*] matches all features
dnl
dnl The following macros can be used in COMMANDS:
dnl
dnl cr_feature expands to the feature id, eg "ft"
dnl cr_feature_name expands to the human-readable name of the feature, eg. "FreeType font"
dnl cr_feature_default expands to the default state of the feature:
dnl "no" for experimental features, eg. your favorite new backend
dnl "yes" for recommended features, eg. png functions
dnl "auto" for other supported features, eg. xlib surface backend
dnl "always" for mandatory features (can't be disabled), eg. image surface backend
dnl cr_what expands to the type of feature:
dnl "surface" for surface backends
dnl "font" for font backends
dnl "functions" for set of functions
dnl "" for private configurations
dnl
dnl These four values are also set as $1 to $4. To know if feature was
dnl enabled from within COMMANDS, use CAIRO_FEATURE_IF_ENABLED:
dnl
dnl CAIRO_FEATURE_IF_ENABLED($1, [IF-ENABLED], [IF-DISABLED])
dnl
dnl or compare $use_$1 to string "yes". As in:
dnl
dnl AS_IF([test "x$use_$1" = "xyes"], [IF-ENABLED], [IF-DISABLED])
dnl
AC_DEFUN([CAIRO_FEATURE_HOOK_REGISTER],
[dnl
m4_append([_CAIRO_FEATURE_HOOKS],
[dnl
_CAIRO_FEATURE_HOOK_MATCH_M4([$2], cr_feature_default,
[_CAIRO_FEATURE_HOOK_MATCH_M4([$3], cr_feature_what,
[_CAIRO_FEATURE_HOOK_MATCH_SH_BOOL([$1], [$use_]cr_feature,
[$4]
)])])dnl
], m4_newline)dnl
])dnl

68
build/aclocal.float.m4
View file

@ -1,68 +0,0 @@
# AX_C_FLOAT_WORDS_BIGENDIAN ([ACTION-IF-TRUE], [ACTION-IF-FALSE],
# [ACTION-IF-UNKNOWN])
#
# Checks the ordering of words within a multi-word float. This check
# is necessary because on some systems (e.g. certain ARM systems), the
# float word ordering can be different from the byte ordering. In a
# multi-word float context, "big-endian" implies that the word containing
# the sign bit is found in the memory location with the lowest address.
# This implementation was inspired by the AC_C_BIGENDIAN macro in autoconf.
# -------------------------------------------------------------------------
AC_DEFUN([AX_C_FLOAT_WORDS_BIGENDIAN],
[AC_CACHE_CHECK(whether float word ordering is bigendian,
ax_cv_c_float_words_bigendian, [
# The endianness is detected by first compiling C code that contains a special
# double float value, then grepping the resulting object file for certain
# strings of ascii values. The double is specially crafted to have a
# binary representation that corresponds with a simple string. In this
# implementation, the string "noonsees" was selected because the individual
# word values ("noon" and "sees") are palindromes, thus making this test
# byte-order agnostic. If grep finds the string "noonsees" in the object
# file, the target platform stores float words in big-endian order. If grep
# finds "seesnoon", float words are in little-endian order. If neither value
# is found, the user is instructed to specify the ordering.
ax_cv_c_float_words_bigendian=unknown
AC_LINK_IFELSE([AC_LANG_SOURCE([[
double d __attribute__((used)) = 90904234967036810337470478905505011476211692735615632014797120844053488865816695273723469097858056257517020191247487429516932130503560650002327564517570778480236724525140520121371739201496540132640109977779420565776568942592.0;
int main() { return 0; }
]])], [
# allow users to override default 'strings' with 'llvm-strings'
# or ${CHOST}-strings.
AC_CHECK_TOOL(STRINGS, strings)
if $STRINGS -a conftest$ac_exeext | grep noonsees >/dev/null ; then
ax_cv_c_float_words_bigendian=yes
fi
if $STRINGS -a conftest$ac_exeext | grep seesnoon >/dev/null ; then
if test "$ax_cv_c_float_words_bigendian" = unknown; then
ax_cv_c_float_words_bigendian=no
else
ax_cv_c_float_words_bigendian=unknown
fi
fi
])])
case $ax_cv_c_float_words_bigendian in
yes)
m4_default([$1],
[AC_DEFINE([FLOAT_WORDS_BIGENDIAN], 1,
[Define to 1 if your system stores words within floats
with the most significant word first])]) ;;
no)
$2 ;;
*)
m4_default([$3],
[AC_MSG_ERROR([
Unknown float word ordering. You need to manually preset
ax_cv_c_float_words_bigendian=no (or yes) according to your system.
])]) ;;
esac
])# AX_C_FLOAT_WORDS_BIGENDIAN

39
build/aclocal.gtk-doc.m4
View file

@ -1,39 +0,0 @@
dnl -*- mode: autoconf -*-
# serial 1
dnl Usage:
dnl GTK_DOC_CHECK([minimum-gtk-doc-version])
AC_DEFUN([GTK_DOC_CHECK],
[
AC_BEFORE([AC_PROG_LIBTOOL],[$0])dnl setup libtool first
AC_BEFORE([AM_PROG_LIBTOOL],[$0])dnl setup libtool first
dnl for overriding the documentation installation directory
AC_ARG_WITH([html-dir],
AS_HELP_STRING([--with-html-dir=PATH], [path to installed docs]),,
[with_html_dir='${datadir}/gtk-doc/html'])
HTML_DIR="$with_html_dir"
AC_SUBST([HTML_DIR])
dnl enable/disable documentation building
AC_ARG_ENABLE([gtk-doc],
AS_HELP_STRING([--enable-gtk-doc],
[use gtk-doc to build documentation [[default=no]]]),,
[enable_gtk_doc=no])
if test x$enable_gtk_doc = xyes; then
ifelse([$1],[],
[PKG_CHECK_EXISTS([gtk-doc],,
AC_MSG_ERROR([gtk-doc not installed and --enable-gtk-doc requested]))],
[PKG_CHECK_EXISTS([gtk-doc >= $1],,
AC_MSG_ERROR([You need to have gtk-doc >= $1 installed to build gtk-doc]))])
fi
AC_MSG_CHECKING([whether to build gtk-doc documentation])
AC_MSG_RESULT($enable_gtk_doc)
AC_PATH_PROGS(GTKDOC_CHECK,gtkdoc-check,)
AM_CONDITIONAL([ENABLE_GTK_DOC], [test x$enable_gtk_doc = xyes])
AM_CONDITIONAL([GTK_DOC_USE_LIBTOOL], [test -n "$LIBTOOL"])
])

234
build/aclocal.makefile.m4
View file

@ -1,234 +0,0 @@
dnl
dnl These are the facilities for generating Makefile.am.features and
dnl Makefile.win32.features files.
dnl
dnl ===========================================================================
dnl
dnl Define cr_feature_tag ala other cr_feature_* macros
dnl Expands to CAIRO_HAS_FEATURE_ID
dnl
m4_define([_CAIRO_BUILD_FEATURE_TAG_NORMALIZED],
[CAIRO_HAS_[$1]m4_bmatch([$1],[$2$],,[$2])])dnl
m4_define([_CAIRO_BUILD_FEATURE_TAG],
[_CAIRO_BUILD_FEATURE_TAG_NORMALIZED(AS_TR_CPP([$1]),AS_TR_CPP(m4_ifval([$2],[ $2])))])dnl
m4_define([cr_feature_tag],
[_CAIRO_BUILD_FEATURE_TAG(cr_feature,cr_feature_what)])dnl
dnl ===========================================================================
dnl
dnl CAIRO_INIT_MAKEFILES([AUX-DIR])
dnl
dnl Sets up automake and win32 conditionals for all features
dnl
AC_DEFUN([CAIRO_INIT_MAKEFILES],
[dnl
dnl Allow feature tags in the output
m4_pattern_allow(^CAIRO_HAS_)dnl
dnl Automake conditionals for non-builtin features
CAIRO_FEATURE_HOOK_REGISTER(*,!always,*,
[dnl
AM_CONDITIONAL(cr_feature_tag, [test "x$use_]cr_feature[" = xyes])dnl
])dnl
CAIRO_CONFIG_MAKEFILE_PRIVATE_WIN32([_],[$1],[],[[# Generated by configure. Modify to customize.]])dnl
CAIRO_MAKEFILE_ACCUMULATE_FEATURE([_],*,!always,*,[cr_feature_tag=m4_if(cr_feature_default,[yes],1,[m4_bmatch(cr_feature,[win32],1,0)])])dnl
])dnl
dnl ===========================================================================
m4_define([_CAIRO_MAKEFILES])dnl
dnl
dnl CAIRO_CONFIG_MAKEFILE(TAG, DIR, [SUFFIX], [HEADER])
dnl
dnl Create DIR/Makefile.{am,win32}.SUFFIX files
dnl TAG is a TAG used by other CAIRO_MAKEFILE_* macros to append to these
dnl Makefile's.
dnl
dnl HEADER is appended at the top of the Makefile's. If HEADER is not
dnl set, the generic "Generated by configure. Do not edit." comment
dnl is added.
dnl
AC_DEFUN([CAIRO_CONFIG_MAKEFILE],
[dnl
m4_append_uniq([_CAIRO_MAKEFILES], [$1], [ ])dnl
CAIRO_CONFIG_MAKEFILE_PRIVATE([$1], [$2], [$3], [$4])dnl
])dnl
dnl Like CAIRO_CONFIG_MAKEFILE but only generate win32 makefile
AC_DEFUN([CAIRO_CONFIG_MAKEFILE_WIN32],
[dnl
m4_append_uniq([_CAIRO_MAKEFILES], [$1], [ ])dnl
CAIRO_CONFIG_MAKEFILE_PRIVATE_WIN32([$1], [$2], [$3], [$4])dnl
])dnl
dnl Like CAIRO_CONFIG_MAKEFILE but only generate automake makefile
AC_DEFUN([CAIRO_CONFIG_MAKEFILE_AMAKE],
[dnl
m4_append_uniq([_CAIRO_MAKEFILES], [$1], [ ])dnl
CAIRO_CONFIG_MAKEFILE_PRIVATE_AMAKE([$1], [$2], [$3], [$4])dnl
])dnl
dnl
dnl CAIRO_CONFIG_MAKEFILE_PRIVATE(TAG, DIR, [SUFFIX], [HEADER])
dnl
dnl Like CAIRO_CONFIG_MAKEFILE but this makefile tag won't match
dnl against '*' in makefile accumulators.
dnl
AC_DEFUN([CAIRO_CONFIG_MAKEFILE_PRIVATE],
[dnl
m4_ifdef([cr_make_$1_dir],
[m4_fatal([Makefile `$1' already registered])])dnl
m4_define([cr_make_$1_dir],[$2])dnl
CAIRO_CONFIG_MAKEFILE_PRIVATE_AMAKE([$1], [$2], [$3], [$4])dnl
CAIRO_CONFIG_MAKEFILE_PRIVATE_WIN32([$1], [$2], [$3], [$4])dnl
])dnl
dnl Like CAIRO_CONFIG_MAKEFILE_PRIVATE but only generate automake makefile
AC_DEFUN([CAIRO_CONFIG_MAKEFILE_PRIVATE_AMAKE],
[dnl
m4_ifdef([cr_make_$1_dir_amake],
[m4_fatal([Automake makefile `$1' already registered])])dnl
m4_define([cr_make_$1_dir_amake],[$2])dnl
m4_define([cr_make_$1_dir_any],[$2])dnl
dnl Accumulators
CAIRO_ACCUMULATORS_REGISTER(MAKEFILE_$1_AMAKE, m4_newline, m4_default([$4],[[# Generated by configure. Do not edit.]])m4_newline)dnl
dnl Generate
CAIRO_CONFIG_COMMANDS([$srcdir/]m4_if([$2],[.],,[$2/])[Makefile.am.]m4_default([$3],[features]),
[echo "$CAIRO_MAKEFILE_$1_AMAKE"],
[CAIRO_MAKEFILE_$1_AMAKE='$CAIRO_MAKEFILE_$1_AMAKE'])dnl
])dnl
dnl Like CAIRO_CONFIG_MAKEFILE_PRIVATE but only generate win32 makefile
AC_DEFUN([CAIRO_CONFIG_MAKEFILE_PRIVATE_WIN32],
[dnl
m4_ifdef([cr_make_$1_dir_win32],
[m4_fatal([Win32 makefile `$1' already registered])])dnl
m4_define([cr_make_$1_dir_win32],[$2])dnl
m4_define([cr_make_$1_dir_any],[$2])dnl
dnl Accumulators
CAIRO_ACCUMULATORS_REGISTER(MAKEFILE_$1_WIN32, m4_newline, m4_default([$4],[[# Generated by configure. Do not edit.]])m4_newline)dnl
dnl Generate
CAIRO_CONFIG_COMMANDS([$srcdir/]m4_if([$2],[.],,[$2/])[Makefile.win32.]m4_default([$3],[features]),
[echo "$CAIRO_MAKEFILE_$1_WIN32"],
[CAIRO_MAKEFILE_$1_WIN32='$CAIRO_MAKEFILE_$1_WIN32'])dnl
])dnl
m4_define([_CAIRO_MAKEFILE_CHECK],
[dnl
m4_ifdef([cr_make_$1_dir_any],,[m4_fatal([Makefile `]$1[' not defined.])])dnl
])dnl
dnl
dnl CAIRO_MAKEFILE_INCLUDE(TAG, FILE)
dnl
dnl Include FILE from Makefile's for TAG. FILE should be placed
dnl relative to directory for TAG. If TAG is *, FILE is included from
dnl all Makefile's.
dnl
AC_DEFUN([CAIRO_MAKEFILE_INCLUDE],
[dnl
m4_if([$1],[*],,[_CAIRO_MAKEFILE_CHECK([$1])])dnl
m4_foreach_w([cr_makefile], m4_if([$1],[*],_CAIRO_MAKEFILES,[$1]),
[dnl
m4_ifdef([cr_make_]cr_makefile[_dir_amake],dnl
[CAIRO_ACCUMULATE([MAKEFILE_]cr_makefile[_AMAKE],[include $(top_srcdir)/cr_make_]cr_makefile[_dir_amake/$2]m4_newline)]
)dnl
m4_ifdef([cr_make_]cr_makefile[_dir_win32],dnl
[CAIRO_ACCUMULATE([MAKEFILE_]cr_makefile[_WIN32],[ifeq ($(top_srcdir),)]m4_newline[include $2]m4_newline[else]m4_newline[include $(top_srcdir)/cr_make_]cr_makefile[_dir_win32/$2]m4_newline[endif]m4_newline)]
)dnl
])dnl
])dnl
m4_pattern_allow([cr_make_tmp])
dnl
dnl CAIRO_MAKEFILE_ACCUMULATE(TAG, CONTENT)
dnl
dnl Accumulates CONTENT to Makefile's for TAG. If TAG is *,
dnl CONTENT is added to all Makefile's.
dnl
AC_DEFUN([CAIRO_MAKEFILE_ACCUMULATE],
[dnl
m4_if([$1],[*],,[_CAIRO_MAKEFILE_CHECK([$1])])dnl
m4_foreach_w([cr_makefile], m4_if([$1],[*],_CAIRO_MAKEFILES,[$1]),
[dnl
m4_pushdef([cr_make_acc_contents],[$2])dnl
cr_make_tmp=_CAIRO_SH_ESCAPE(cr_make_acc_contents(cr_makefile))
m4_popdef([cr_make_acc_contents])dnl
m4_ifdef([cr_make_]cr_makefile[_dir_amake],dnl
[CAIRO_ACCUMULATE_UNQUOTED_UNCHECKED([MAKEFILE_]cr_makefile[_AMAKE], [$cr_make_tmp])]
)dnl
m4_ifdef([cr_make_]cr_makefile[_dir_win32],dnl
[CAIRO_ACCUMULATE_UNQUOTED_UNCHECKED([MAKEFILE_]cr_makefile[_WIN32], [$cr_make_tmp])]
)dnl
])dnl
])dnl
m4_define([_CAIRO_MAKEFILE_ACCUMULATE_FEATURE],
[dnl
dnl Don't do a conditional for default=always features
m4_pushdef([cr_mk_acc_feat_enabled],m4_if([$2],[yes],[m4_if(cr_feature_default,[always],[*],[$2])],[$2]))dnl
m4_case(cr_mk_acc_feat_enabled,
[*],,
[yes], [CAIRO_ACCUMULATE([$1], [$3])],
[no], [CAIRO_ACCUMULATE([$1], [$3]m4_newline[$4])],
[m4_fatal([Invalid ENABLED value `]$2['])])dnl
CAIRO_ACCUMULATE_UNQUOTED_UNCHECKED([$1], [$6])dnl
m4_case(cr_mk_acc_feat_enabled,
[*],,
[yes], [CAIRO_ACCUMULATE([$1], [$5])],
[no], [CAIRO_ACCUMULATE([$1], [$5])],
[m4_fatal([Invalid ENABLED value `]$2['])])dnl
m4_popdef([cr_mk_acc_feat_enabled])dnl
])dnl
dnl
dnl CAIRO_MAKEFILE_ACCUMULATE_FEATURE(TAG, ENABLED, DEFAULT, WHAT, CONTENT)
dnl
dnl Accumulates CONTENT to Makefile's for TAG for each feature matching
dnl ENABLED, DEFAULT, and WHAT. Those parameters are similar to those
dnl passed to CAIRO_FEATURE_HOOK_REGISTER.
dnl If TAG is *, CONTENT is added to all Makefile's.
dnl
AC_DEFUN([CAIRO_MAKEFILE_ACCUMULATE_FEATURE],
[dnl
m4_if([$1],[*],,[_CAIRO_MAKEFILE_CHECK([$1])])dnl
m4_append([cr_make_acc_counter],[1],[])dnl
m4_define([cr_make_acc_contents]m4_len(cr_make_acc_counter), [$5])dnl
CAIRO_FEATURE_HOOK_REGISTER(*,[$3],[$4],
[dnl
m4_foreach_w([cr_makefile], m4_if([$1],[*],_CAIRO_MAKEFILES,[$1]),
[dnl
cr_make_tmp=_CAIRO_SH_ESCAPE(cr_make_acc_contents]]m4_len(cr_make_acc_counter)([[cr_makefile,]][$][1],[$][2],[$][3],[$][4])[[)
m4_ifdef([cr_make_]cr_makefile[_dir_amake],
[_CAIRO_MAKEFILE_ACCUMULATE_FEATURE(
[MAKEFILE_]cr_makefile[_AMAKE],
[$2],
[if ]cr_feature_tag, [else], [endif],
[$cr_make_tmp])
])dnl
m4_ifdef([cr_make_]cr_makefile[_dir_win32],
[_CAIRO_MAKEFILE_ACCUMULATE_FEATURE(
[MAKEFILE_]cr_makefile[_WIN32],
[$2],
[ifeq ($(]cr_feature_tag[),1)], [else], [endif],
[$cr_make_tmp])dnl
])dnl
])dnl
])dnl
])dnl
m4_define([cr_make_acc_counter])dnl

157
build/aclocal.pkg.m4
View file

@ -1,157 +0,0 @@
# pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
#
# Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# PKG_PROG_PKG_CONFIG([MIN-VERSION])
# ----------------------------------
AC_DEFUN([PKG_PROG_PKG_CONFIG],
[m4_pattern_forbid([^_?PKG_[A-Z_]+$])
m4_pattern_allow([^PKG_CONFIG(_PATH)?$])
AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])dnl
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
fi
if test -n "$PKG_CONFIG"; then
_pkg_min_version=m4_default([$1], [0.9.0])
AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])
if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
PKG_CONFIG=""
fi
fi[]dnl
])# PKG_PROG_PKG_CONFIG
# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
#
# Check to see whether a particular set of modules exists. Similar
# to PKG_CHECK_MODULES(), but does not set variables or print errors.
#
#
# Similar to PKG_CHECK_MODULES, make sure that the first instance of
# this or PKG_CHECK_MODULES is called, or make sure to call
# PKG_CHECK_EXISTS manually
# --------------------------------------------------------------
AC_DEFUN([PKG_CHECK_EXISTS],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
if test -n "$PKG_CONFIG" && \
AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
m4_ifval([$2], [$2], [:])
m4_ifvaln([$3], [else
$3])dnl
fi])
# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
# ---------------------------------------------
m4_define([_PKG_CONFIG],
[if test -n "$$1"; then
pkg_cv_[]$1="$$1"
elif test -n "$PKG_CONFIG"; then
PKG_CHECK_EXISTS([$3],
[pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`],
[pkg_failed=yes])
else
pkg_failed=untried
fi[]dnl
])# _PKG_CONFIG
# _PKG_SHORT_ERRORS_SUPPORTED
# -----------------------------
AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
_pkg_short_errors_supported=yes
else
_pkg_short_errors_supported=no
fi[]dnl
])# _PKG_SHORT_ERRORS_SUPPORTED
# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
# [ACTION-IF-NOT-FOUND])
#
# ACTION-IF-NOT-FOUND is not allowed to be empty, that trigger PKG_CONFIG_PATH error message.
# Use : or set a dummy variable to avoid that behavior.
#
# Note that if there is a possibility the first call to
# PKG_CHECK_MODULES might not happen, you should be sure to include an
# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
#
#
# --------------------------------------------------------------
AC_DEFUN([PKG_CHECK_MODULES],
[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
pkg_failed=no
AC_MSG_CHECKING([for $1])
_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
_PKG_CONFIG([$1][_LIBS], [libs], [$2])
m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
and $1[]_LIBS to avoid the need to call pkg-config.
See the pkg-config man page for more details.])
if test $pkg_failed = yes; then
_PKG_SHORT_ERRORS_SUPPORTED
if test $_pkg_short_errors_supported = yes; then
$1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "$2" 2>&1`
else
$1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors "$2" 2>&1`
fi
# Put the nasty error message in config.log where it belongs
echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
ifelse([$4], , [AC_MSG_ERROR(dnl
[Package requirements ($2) were not met:
$$1_PKG_ERRORS
Consider adjusting the PKG_CONFIG_PATH environment variable if you
installed software in a non-standard prefix.
_PKG_TEXT
])],
[AC_MSG_RESULT([no])
$4])
elif test $pkg_failed = untried; then
ifelse([$4], , [AC_MSG_FAILURE(dnl
[The pkg-config script could not be found or is too old. Make sure it
is in your PATH or set the PKG_CONFIG environment variable to the full
path to pkg-config.
_PKG_TEXT
To get pkg-config, see <https://pkg-config.freedesktop.org/>.])],
[$4])
else
$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
$1[]_LIBS=$pkg_cv_[]$1[]_LIBS
AC_MSG_RESULT([yes])
ifelse([$3], , :, [$3])
fi[]dnl
])# PKG_CHECK_MODULES

106
build/configure.ac.analysis
View file

@ -1,106 +0,0 @@
dnl ===========================================================================
dnl
dnl LCOV
dnl
cairo_has_lcov=no
AC_ARG_ENABLE(gcov,
AS_HELP_STRING([--enable-gcov],
[Enable gcov]),
[use_gcov=$enableval], [use_gcov=no])
if test "x$use_gcov" = "xyes"; then
dnl we need gcc:
if test "$GCC" != "yes"; then
AC_MSG_ERROR([GCC is required for --enable-gcov])
fi
dnl Check if ccache is being used
AC_CHECK_PROG(SHTOOL, shtool, shtool)
case `$SHTOOL path $CC` in
*ccache*[)] gcc_ccache=yes;;
*[)] gcc_ccache=no;;
esac
if test "$gcc_ccache" = "yes" && (test -z "$CCACHE_DISABLE" || test "$CCACHE_DISABLE" != "1"); then
AC_MSG_ERROR([ccache must be disabled when --enable-gcov option is used. You can disable ccache by setting environment variable CCACHE_DISABLE=1.])
fi
ltp_version_list="1.7 1.6 1.5 1.4"
AC_CHECK_PROG(LTP, lcov, lcov)
AC_CHECK_PROG(LTP_GENHTML, genhtml, genhtml)
if test "$LTP"; then
AC_CACHE_CHECK([for ltp version], cairo_cv_ltp_version, [
cairo_cv_ltp_version=invalid
ltp_version=`$LTP -v 2>/dev/null | $SED -e 's/^.* //'`
for ltp_check_version in $ltp_version_list; do
if test "$ltp_version" = "$ltp_check_version"; then
cairo_cv_ltp_version="$ltp_check_version (ok)"
fi
done
])
fi
case $cairo_cv_ltp_version in
""|invalid[)]
;;
*)
cairo_has_lcov=yes
;;
esac
if test "x$cairo_has_lcov" != "xyes"; then
AC_MSG_ERROR([[To enable code coverage reporting you must have one of the following LTP versions installed: $ltp_version_list.
Please install the Linux Test Project [http://ltp.sourceforge.net/], and try again.]])
fi
if test -z "$LTP_GENHTML"; then
AC_MSG_ERROR([[Could not find genhtml from the LTP package.
Please install the Linux Test Project [http://ltp.sourceforge.net/], and try again.]])
fi
AC_DEFINE(HAVE_GCOV, 1, [Whether you have gcov])
dnl PHP_ADD_MAKEFILE_FRAGMENT($abs_srcdir/Makefile.gcov, $abs_srcdir)
dnl Remove all optimization flags from CFLAGS
changequote({,})
CFLAGS=`echo "$CFLAGS" | $SED -e 's/-O[0-9]*//g'`
CAIRO_CFLAGS=`echo "$CAIRO_CFLAGS" | $SED -e 's/-O[0-9]*//g'`
changequote([,])
dnl Add the special gcc flags
dnl In order to workaround a debian bug in libtool where they strip
dnl $dependency_libs from the link line and CFLAGS, we need to pass
dnl --coverage via LDFLAGS.
CAIRO_CC_TRY_FLAG([--coverage],,
[
CAIRO_CFLAGS="$CAIRO_CFLAGS -O0 --coverage"
CAIRO_LDFLAGS="$CAIRO_LDFLAGS -O0 --coverage"
])
fi
AM_CONDITIONAL(CAIRO_HAS_LCOV, test "x$cairo_has_lcov" = "xyes")
dnl ===========================================================================
dnl Check for some custom valgrind modules
AC_ARG_ENABLE(valgrind,
AS_HELP_STRING([--disable-valgrind],
[Disable valgrind support]),
[use_valgrind=$enableval], [use_valgrind=yes])
if test "x$use_valgrind" = "xyes"; then
PKG_CHECK_MODULES(VALGRIND, valgrind, [
_save_CFLAGS="$CFLAGS"
_save_CPPFLAGS="$CPPFLAGS"
CFLAGS="$CFLAGS $VALGRIND_CFLAGS"
CPPFLAGS="$CPPFLAGS $VALGRIND_CFLAGS"
AC_CHECK_HEADER([valgrind.h], [AC_DEFINE([HAVE_VALGRIND], [1],
[Define to 1 if you have Valgrind])])
AC_CHECK_HEADER([lockdep.h], [AC_DEFINE([HAVE_LOCKDEP], [1],
[Define to 1 if you have the Valgrind lockdep tool])])
AC_CHECK_HEADER([memfault.h], [AC_DEFINE([HAVE_MEMFAULT], [1],
[Define to 1 if you have the Valgrind memfault tool])])
CAIRO_CFLAGS="$VALGRIND_CFLAGS $CAIRO_CFLAGS"
CFLAGS="$_save_CFLAGS"
CPPFLAGS="$_save_CPPFLAGS"
], AC_MSG_RESULT(no))
fi

416
build/configure.ac.features
View file

@ -1,416 +0,0 @@
dnl
dnl Define macros to enable various features.
dnl - Macro: CAIRO_ENABLE_* (ID, NAME, DEFAULT, COMMANDS)
dnl
dnl where:
dnl
dnl ID is the feature id, eg. "ft" for cairo_ft_...
dnl NAME is the human-readable name of the feature, eg. "FreeType"
dnl DEFAULT is the default state of the feature:
dnl "no" for experimental backends, eg. your favorite new backend
dnl "yes" for mandatory backends, eg. png
dnl "auto" for other supported backends, eg. xlib
dnl COMMANDS are run to check whether the feature can be enabled. Their
dnl result may be cached, so user should not count on them being run.
dnl They should set use_$(ID) to something other than yes if the
dnl feature cannot be built, eg. "no (requires SomeThing)". It then
dnl should also set $(ID)_REQUIRES/CFLAGS/LIBS/...
dnl appropriately. Look at the macro definition for more details,
dnl or ask if in doubt.
dnl
AC_DEFUN([CAIRO_ENABLE],
[_CAIRO_ENABLE([$1], [$2], , [$3],[$4])])dnl
AC_DEFUN([CAIRO_ENABLE_SURFACE_BACKEND],
[_CAIRO_ENABLE([$1], [$2 surface backend], surface, [$3],[$4])])dnl
AC_DEFUN([CAIRO_ENABLE_FONT_BACKEND],
[_CAIRO_ENABLE([$1], [$2 font backend], font, [$3],[$4])])dnl
AC_DEFUN([CAIRO_ENABLE_FUNCTIONS],
[_CAIRO_ENABLE([$1], [$2 functions], functions, [$3],[$4])])dnl
dnl
dnl Define cr_feature_pc and friends ala other cr_feature_* macros
dnl
m4_define([cr_pc_modname],
[[cairo-]m4_translit([$1],_,-)])dnl
m4_define([cr_feature_pc],
[cr_pc_modname(cr_feature)[.pc]])dnl
m4_define([cr_feature_uninstalled_pc],
[cr_pc_modname(cr_feature)[-uninstalled.pc]])dnl
dnl ===========================================================================
dnl
dnl Hooks
dnl
dnl ===========================================================================
dnl ===========================================================================
dnl
dnl Generate {src,boilerplate}/Makefile.{am,win32}.config
dnl
CAIRO_INIT_MAKEFILES([build])
CAIRO_CONFIG_MAKEFILE([cairo], [src])dnl
CAIRO_CONFIG_MAKEFILE([cairo_boilerplate], [boilerplate])dnl
CAIRO_MAKEFILE_INCLUDE(*,[Makefile.sources])dnl
dnl An empty line per feature for readability
CAIRO_MAKEFILE_ACCUMULATE_FEATURE(*,*,*,*,[])dnl
dnl Collect list of all supported public headers
CAIRO_MAKEFILE_ACCUMULATE(*,
[supported_$1_headers = $($1_headers)]dnl
)dnl
CAIRO_MAKEFILE_ACCUMULATE_FEATURE(*,*,!no,!,
[supported_$1_headers += $($1_$2_headers)]dnl
)dnl
dnl Collect list of all unsupported public headers
CAIRO_MAKEFILE_ACCUMULATE(*,
[unsupported_$1_headers =]dnl
)dnl
CAIRO_MAKEFILE_ACCUMULATE_FEATURE(*,*,no,!,
[unsupported_$1_headers += $($1_$2_headers)]dnl
)dnl
dnl Collect list of source files for all public features
CAIRO_MAKEFILE_ACCUMULATE(*,
[dnl
all_$1_headers = $($1_headers)
all_$1_private = $($1_private)
all_$1_sources = $($1_sources)
])dnl
CAIRO_MAKEFILE_ACCUMULATE_FEATURE(*,*,*,!,
[dnl
all_$1_headers += $($1_$2_headers)
all_$1_private += $($1_$2_private)
all_$1_sources += $($1_$2_sources)]dnl
)dnl
dnl Collect list of source files for enabled public features
CAIRO_MAKEFILE_ACCUMULATE(*,
[dnl
enabled_$1_headers = $($1_headers)
enabled_$1_private = $($1_private)
enabled_$1_sources = $($1_sources)
])dnl
CAIRO_MAKEFILE_ACCUMULATE_FEATURE(*,yes,*,!,
[dnl
enabled_$1_headers += $($1_$2_headers)
enabled_$1_private += $($1_$2_private)
enabled_$1_sources += $($1_$2_sources)]dnl
)dnl
dnl No public headers for private features
dnl Collect list of source files for all private features
CAIRO_MAKEFILE_ACCUMULATE_FEATURE(*,*,*,,
[dnl
all_$1_private += $($1_$2_private) $($1_$2_headers)
all_$1_sources += $($1_$2_sources)]dnl
)dnl
dnl Collect list of source files for enabled private features
CAIRO_MAKEFILE_ACCUMULATE_FEATURE(*,yes,*,,
[dnl
enabled_$1_private += $($1_$2_private) $($1_$2_headers)
enabled_$1_sources += $($1_$2_sources)]dnl
)dnl
dnl ===========================================================================
dnl
dnl Generate .pc files
dnl
dnl All .pc files are generated automatically except for these
AC_CONFIG_FILES([src/cairo.pc])dnl
AC_CONFIG_FILES([cairo-uninstalled.pc:src/cairo-uninstalled.pc.in])dnl
AC_CONFIG_FILES([util/cairo-script/cairo-script-interpreter.pc])dnl
AC_CONFIG_FILES([util/cairo-script/cairo-script-interpreter-uninstalled.pc:util/cairo-script/cairo-script-interpreter-uninstalled.pc.in])dnl
dnl pkg-config requires, non-pkgconfig cflags and libs, and total cflags and libs
CAIRO_FEATURE_VARS_REGISTER([BASE],[cairo])dnl
CAIRO_ACCUMULATED_FEATURE_VARS_REGISTER([REQUIRES],,[ ])dnl
CAIRO_ACCUMULATED_FEATURE_VARS_REGISTER([CFLAGS NONPKGCONFIG_CFLAGS],,[ ])dnl
CAIRO_ACCUMULATED_FEATURE_VARS_REGISTER([LIBS NONPKGCONFIG_LIBS],,[ ],[$LIBS])dnl
CAIRO_FEATURE_VARS_REGISTER([NONPKGCONFIG_EXTRA_LIBS])dnl
AC_SUBST(CAIRO_REQUIRES)dnl
AC_SUBST(CAIRO_CFLAGS)dnl
AC_SUBST(CAIRO_LDFLAGS)dnl
AC_SUBST(CAIRO_NONPKGCONFIG_CFLAGS)dnl
AC_SUBST(CAIRO_LIBS)dnl
AC_SUBST(CAIRO_NONPKGCONFIG_LIBS)dnl
dnl add non-pkgconfig values
AC_CONFIG_COMMANDS_PRE(
[dnl
CAIRO_CFLAGS="$CAIRO_CFLAGS $CAIRO_NONPKGCONFIG_CFLAGS"
CAIRO_LIBS="$CAIRO_LIBS $CAIRO_NONPKGCONFIG_LIBS"
])dnl
m4_define([_CAIRO_FEATURE_CONFIG_PKGCONFIG_FILE],
[dnl
AC_CONFIG_FILES([$3:$4],
[dnl
mv "$3" "$3.tmp" &&
$SED "dnl
s%@FEATURE_PC@%]cr_pc_modname([$1])[%g;dnl
s%@FEATURE_NAME@%$2%g;dnl
s%@FEATURE_BASE@%$$1_BASE%g;dnl
s%@FEATURE_REQUIRES@%$$1_REQUIRES%g;dnl
s%@FEATURE_NONPKGCONFIG_LIBS@%$$1_NONPKGCONFIG_LIBS%g;dnl
s%@FEATURE_NONPKGCONFIG_EXTRA_LIBS@%$$1_NONPKGCONFIG_EXTRA_LIBS%g;dnl
s%@FEATURE_NONPKGCONFIG_CFLAGS@%$$1_NONPKGCONFIG_CFLAGS%g;dnl
" < "$3.tmp" > "$3" && rm -f "$3.tmp" ||
AC_MSG_ERROR(failed to update $3)
],[dnl
SED='$SED'
$1_BASE='$$1_BASE'
$1_REQUIRES='$$1_REQUIRES'
$1_NONPKGCONFIG_LIBS='$$1_NONPKGCONFIG_LIBS'
$1_NONPKGCONFIG_EXTRA_LIBS='$$1_NONPKGCONFIG_EXTRA_LIBS'
$1_NONPKGCONFIG_CFLAGS='$$1_NONPKGCONFIG_CFLAGS'
])dnl
])dnl
dnl Generate .pc files for enabled non-builtin public features
CAIRO_FEATURE_HOOK_REGISTER(yes,!always,!,
[dnl
_CAIRO_FEATURE_CONFIG_PKGCONFIG_FILE(
[$1],
cr_feature_name,
[src/]cr_feature_pc,
[src/cairo-features.pc.in]
)dnl
])dnl
dnl Generate -uninstalled.pc files for enabled non-builtin public features
CAIRO_FEATURE_HOOK_REGISTER(yes,!always,!,
[dnl
_CAIRO_FEATURE_CONFIG_PKGCONFIG_FILE(
[$1],
cr_feature_name,
cr_feature_uninstalled_pc,
[src/cairo-features-uninstalled.pc.in]
)dnl
])dnl
dnl Collect list of .pc files for all non-builtin public features
CAIRO_MAKEFILE_ACCUMULATE(cairo,
[all_$1_pkgconf = cairo.pc])dnl
CAIRO_MAKEFILE_ACCUMULATE_FEATURE(cairo,*,!always,!,
[all_$1_pkgconf += cr_feature_pc])dnl
dnl Collect list of .pc files for enabled non-builtin public features
CAIRO_MAKEFILE_ACCUMULATE(cairo,
[enabled_$1_pkgconf = cairo.pc])dnl
CAIRO_MAKEFILE_ACCUMULATE_FEATURE(cairo,yes,!always,!,
[enabled_$1_pkgconf += cr_feature_pc])dnl
dnl ===========================================================================
dnl
dnl Generate src/cairo-features.h, src/cairo-supported-features.h, and
dnl src/cairo-features-win32.h
dnl
dnl Collect list of enabled public features
CAIRO_ACCUMULATORS_REGISTER(FEATURES,[ ])dnl
CAIRO_FEATURE_HOOK_REGISTER(yes,*,!,dnl
[dnl
CAIRO_ACCUMULATE(FEATURES, cr_feature_tag)dnl
])dnl
dnl Collect list of all supported public features
CAIRO_ACCUMULATORS_REGISTER(SUPPORTED_FEATURES,[ ])dnl
CAIRO_FEATURE_HOOK_REGISTER(*,!no,!,dnl
[dnl
CAIRO_ACCUMULATE(SUPPORTED_FEATURES, cr_feature_tag)
])dnl
dnl Collect list of all supported disabled public features
CAIRO_ACCUMULATORS_REGISTER(NO_FEATURES,[ ])dnl
CAIRO_FEATURE_HOOK_REGISTER(no,*,!,
[dnl
CAIRO_ACCUMULATE(NO_FEATURES, cr_feature_tag)
])dnl
dnl Generate src/cairo-features.h
CAIRO_CONFIG_COMMANDS([src/cairo-features.h],
[dnl
echo '/* Generated by configure. Do not edit. */'
echo '#ifndef CAIRO_FEATURES_H'
echo '#define CAIRO_FEATURES_H'
echo ''
for FEATURE in $CAIRO_FEATURES; do
echo "#define $FEATURE 1"
done | LANG=C sort
echo ''
for FEATURE in $CAIRO_NO_FEATURES; do
echo "/*#undef $FEATURE */"
done | LANG=C sort
echo ''
echo '#endif'
],[dnl
CAIRO_FEATURES='$CAIRO_FEATURES'
CAIRO_NO_FEATURES='$CAIRO_NO_FEATURES'
])dnl
dnl Generate src/cairo-supported-features.h
CAIRO_CONFIG_COMMANDS([src/cairo-supported-features.h],
[dnl
echo '/* Generated by configure. Do not edit. */'
echo '#ifndef CAIRO_SUPPORTED_FEATURES_H'
echo '#define CAIRO_SUPPORTED_FEATURES_H'
echo ''
echo '/* This is a dummy header, to trick gtk-doc only */'
echo ''
for FEATURE in $CAIRO_SUPPORTED_FEATURES; do
echo "#define $FEATURE 1"
done
echo ''
echo '#endif'
],[dnl
CAIRO_SUPPORTED_FEATURES='$CAIRO_SUPPORTED_FEATURES'
])dnl
dnl For enabled private features just define them in config.h. No fanfare!
CAIRO_FEATURE_HOOK_REGISTER(yes,*,,
[dnl
AC_DEFINE(cr_feature_tag, 1, [Define to 1 to enable cairo's ]cr_feature_name[ feature])
])dnl
dnl Generate build/Makefile.win32.features-h that generates src/cairo-features.h
CAIRO_CONFIG_MAKEFILE_PRIVATE_WIN32([win32_features_h],[build],[features-h])
dnl
CAIRO_MAKEFILE_ACCUMULATE([win32_features_h],
[$(top_srcdir)/src/cairo-features.h: $(top_srcdir)/build/Makefile.win32.features
@echo "Generating src/cairo-features.h"
@echo "/* Generated by Makefile.win32.features-h. Do not edit. */" > $(top_srcdir)/src/cairo-features.h
@echo "[#]ifndef CAIRO_FEATURES_H" >> $(top_srcdir)/src/cairo-features.h
@echo "[#]define CAIRO_FEATURES_H 1" >> $(top_srcdir)/src/cairo-features.h]dnl
)
AC_CONFIG_COMMANDS_PRE(
[dnl
CAIRO_MAKEFILE_ACCUMULATE([win32_features_h], [ @echo "[#]endif" >> $(top_srcdir)/src/cairo-features.h])
])dnl
CAIRO_MAKEFILE_ACCUMULATE_FEATURE([win32_features_h],yes,*,*,dnl
[ @echo "[#]define cr_feature_tag 1" >> $(top_srcdir)/src/cairo-features.h]dnl
)dnl
dnl ===========================================================================
dnl
dnl Report
dnl
CAIRO_ACCUMULATORS_REGISTER([WARNING_MESSAGE],m4_newline()m4_newline)dnl
dnl Collect warning message for enabled unsupported public features
CAIRO_FEATURE_HOOK_REGISTER(yes,no,!,
[dnl
CAIRO_ACCUMULATE([WARNING_MESSAGE], CAIRO_TEXT_WRAP([The ]cr_feature_name[ feature is still under active development and is included in this release only as a preview. It does NOT fully work yet and incompatible changes may yet be made to ]cr_feature_name[ specific API.], [--- ]))
])dnl
dnl Collect warning message for disabled recommended features
CAIRO_FEATURE_HOOK_REGISTER(no,yes,*,
[dnl
CAIRO_ACCUMULATE([WARNING_MESSAGE], CAIRO_TEXT_WRAP([It is strongly recommended that you do NOT disable the ]cr_feature_name[ feature.], [+++ ]))
])dnl
dnl Collect enabled native surface/font backend features
CAIRO_ACCUMULATORS_REGISTER([NATIVE_SURFACE_BACKENDS])dnl
CAIRO_ACCUMULATORS_REGISTER([NATIVE_FONT_BACKENDS])dnl
CAIRO_FEATURE_HOOK_REGISTER(yes,auto,surface,
[dnl
CAIRO_ACCUMULATE([NATIVE_SURFACE_BACKENDS], [$1])
])dnl
CAIRO_FEATURE_HOOK_REGISTER(yes,auto,font,
[dnl
CAIRO_ACCUMULATE([NATIVE_FONT_BACKENDS], [$1])
])dnl
dnl Collect warning message if no native surface/font backend feature enabled
AC_CONFIG_COMMANDS_PRE(dnl
[dnl
AS_IF([test -z "$CAIRO_NATIVE_SURFACE_BACKENDS"],dnl
[dnl
CAIRO_ACCUMULATE([WARNING_MESSAGE], CAIRO_TEXT_WRAP([No native surface backends enabled for your platform. It is strongly recommended that you enable the native surface backend feature for your platform.], [*** ]))
])
AS_IF([test -z "$CAIRO_NATIVE_FONT_BACKENDS"],dnl
[dnl
CAIRO_ACCUMULATE([WARNING_MESSAGE], CAIRO_TEXT_WRAP([No native font backends enabled for your platform. It is strongly recommended that you enable the native font backend feature for your platform.], [*** ]))
])
])dnl
AC_DEFUN([CAIRO_REPORT],
[dnl
V="$CAIRO_VERSION_MAJOR.$CAIRO_VERSION_MINOR.$CAIRO_VERSION_MICRO"
echo ""
echo "cairo (version $V [[$CAIRO_RELEASE_STATUS]]) will be compiled with:"
echo ""
echo "The following surface backends:"
echo " Image: yes (always builtin)"
echo " Recording: yes (always builtin)"
echo " Observer: yes (always builtin)"
echo " Mime: yes (always builtin)"
echo " Tee: $use_tee"
echo " XML: $use_xml"
echo " Xlib: $use_xlib"
echo " Xlib Xrender: $use_xlib_xrender"
echo " Quartz: $use_quartz"
echo " Quartz-image: $use_quartz_image"
echo " XCB: $use_xcb"
echo " Win32: $use_win32"
echo " CairoScript: $use_script"
echo " PostScript: $use_ps"
echo " PDF: $use_pdf"
echo " SVG: $use_svg"
echo " OpenGL: $use_gl"
echo " OpenGL ES 2.0: $use_glesv2"
echo " OpenGL ES 3.0: $use_glesv3"
echo ""
echo "The following font backends:"
echo " User: yes (always builtin)"
echo " FreeType: $use_ft"
echo " Fontconfig: $use_fc"
echo " Win32: $use_win32_font"
echo " Quartz: $use_quartz_font"
echo ""
echo "The following functions:"
echo " PNG functions: $use_png"
echo " GLX functions: $use_glx"
echo " WGL functions: $use_wgl"
echo " EGL functions: $use_egl"
echo " X11-xcb functions: $use_xlib_xcb"
echo " XCB-shm functions: $use_xcb_shm"
echo ""
echo "The following features and utilities:"
echo " cairo-trace: $use_trace"
echo " cairo-script-interpreter: $use_interpreter"
echo ""
echo "And the following internal features:"
echo " pthread: $use_pthread"
echo " gtk-doc: $enable_gtk_doc"
echo " gcov support: $use_gcov"
echo " symbol-lookup: $use_symbol_lookup"
echo " test surfaces: $use_test_surfaces"
echo " ps testing: $test_ps"
echo " pdf testing: $test_pdf"
echo " svg testing: $test_svg"
if test x"$use_win32" = "xyes"; then
echo " win32 printing testing: $test_win32_printing"
fi
echo "$CAIRO_WARNING_MESSAGE"
echo ""
])dnl

23
build/configure.ac.noversion
View file

@ -1,23 +0,0 @@
dnl
dnl Version stuff
dnl
dnl Disable autoconf's version macros. We try hard to not rebuild the entire
dnl library just because version changed. The PACKAGE_VERSION* stuff in
dnl config.h is negating all the effort.
dnl
dnl We're not actually supposed to be doing this, and indeed adding the
dnl AC_DEFINEs below causes confdefs.h to contain duplicate incompatible
dnl #defines for the same PACKAGE_* symbols. Those are provoking warnings
dnl from the compiler, and that throws our CAIRO_TRY_LINK_*_ checks off,
dnl because they think that there's something wrong with some flag they're
dnl testing rather than confdefs.h! So let's do the gross thing and puke
dnl into confdefs.h some #undefs.
echo '#undef PACKAGE_VERSION' >>confdefs.h
echo '#undef PACKAGE_STRING' >>confdefs.h
echo '#undef PACKAGE_NAME' >>confdefs.h
echo '#undef PACKAGE_TARNAME' >>confdefs.h
AC_DEFINE(PACKAGE_VERSION, [USE_cairo_version_OR_cairo_version_string_INSTEAD])
AC_DEFINE(PACKAGE_STRING, [USE_cairo_version_OR_cairo_version_string_INSTEAD])
AC_DEFINE(PACKAGE_NAME, [USE_cairo_INSTEAD])
AC_DEFINE(PACKAGE_TARNAME, [USE_cairo_INSTEAD])

253
build/configure.ac.pthread
View file

@ -1,253 +0,0 @@
dnl Defines the macro CAIRO_CONFIGURE_PTHREAD to find a suitable
dnl pthread implementation. There are two levels of pthread conformance
dnl we are looking for:
dnl
dnl a) A minimal level denoted by -DCAIRO_HAS_PTHREAD=1: This level
dnl requires mutex and recursive mutexattr support. If possible we try
dnl to use weakly linked stubs from libc over the real pthread library.
dnl This level is required by the cairo library proper. If the user
dnl invokes configure with --enable-pthread=yes or
dnl --enable-pthread=always then we avoid trying to use weak stubs.
dnl
dnl b) A full level denoted by -DCAIRO_HAS_REAL_PTHREAD=1: This level
dnl requires full support from a real pthread library, including thread
dnl creation, joins, thread attribtues, etc. This level is required by
dnl multithreaded applications using cairo, such as the test suite
dnl binaries and cairo utilities.
dnl
dnl Usage:
dnl CAIRO_ENABLE(pthread, pthread, <default yes|no|auto|always>,
dnl [CAIRO_CONFIGURE_PTHREAD])
dnl
dnl This should be invoked near the end of configure.ac so that
dnl the pthread specific CFLAGS and LIBS end up at the front
dnl of CAIRO_CFLAGS and CAIRO_LIBS -- this helps ensure that we
dnl really do get non-weak symbols from the actual pthread library
dnl rather than possible stubs in other libraries.
dnl
dnl The user can override the choices made by
dnl CAIRO_CONFIGURE_PTHREAD by using --enable-pthread=yes and
dnl giving PTHREAD_CFLAGS and PTHREAD_LIBS to configure.
dnl
dnl Sets environment variables:
dnl use_pthread="yes" | "no (<errmsg>)"
dnl have_pthread="yes" | "no (<errmsg)"
dnl have_real_pthread="yes" | "no (<errmsg)"
dnl pthread_{CFLAGS,LIBS,REQUIRES}
dnl real_pthread_{CFLAGS,LIBS}
dnl
dnl Autoconfigured defines in config.h (conditional):
dnl CAIRO_HAS_PTHREAD
dnl CAIRO_HAS_REAL_PTHREAD
dnl
dnl -----------------------------------------------------------------------
dnl A program to test all the pthread features we need to be able to
dnl compile libcairo itself. We could test the features independently,
dnl but we need all of them anyway.
m4_define([libcairo_pthread_program],[dnl
#ifndef _GNU_SOURCE
#define _GNU_SOURCE /* for PTHREAD_MUTEX_INITIALIZER under linux */
#endif
#include <pthread.h>
pthread_mutex_t test_mutex_initializer = PTHREAD_MUTEX_INITIALIZER;
int test_mutex (void)
{
int x = 0;
pthread_mutex_t mutex;
x |= pthread_mutex_init (&mutex, NULL);
x |= pthread_mutex_lock (&mutex);
x |= pthread_mutex_unlock (&mutex);
x |= pthread_mutex_destroy (&mutex);
return 0;
}
int test_mutex_attr (void)
{
int x = 0;
pthread_mutexattr_t attr;
pthread_mutex_t mutex;
x |= pthread_mutexattr_init (&attr);
x |= pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
x |= pthread_mutex_init (&mutex, &attr);
x |= pthread_mutex_lock (&mutex);
x |= pthread_mutex_unlock (&mutex);
x |= pthread_mutex_destroy (&mutex);
x |= pthread_mutexattr_destroy (&attr);
return x;
}])
dnl -----------------------------------------------------------------------
dnl A program to test all the features we want to be able to run the test
dnl suite or other thready cairo applications that want real threads.
m4_define([testsuite_pthread_program],[dnl
libcairo_pthread_program
pthread_once_t once_control = PTHREAD_ONCE_INIT;
void test_once_init (void) {}
int test_once (void)
{
return pthread_once (&once_control, test_once_init);
}
pthread_key_t test_specific_key;
int test_specific (void)
{
int x = 0;
x |= pthread_key_create (&test_specific_key, NULL);
x |= pthread_setspecific (test_specific_key, NULL);
x |= pthread_getspecific (test_specific_key) != NULL;
return x;
}
void cleaner (void *arg) { (void)arg; }
void *
test_thread_main (void *arg)
{
pthread_cleanup_push (cleaner, arg);
pthread_exit (arg);
pthread_cleanup_pop (1);
return arg;
}
int
test_threads (void)
{
int x = 0;
pthread_t thread;
pthread_attr_t attr;
void *arg = NULL;
x |= pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
x |= pthread_create (&thread, &attr, test_thread_main, arg);
x |= pthread_equal (pthread_self(), thread);
x |= pthread_join (thread, &arg);
x |= pthread_attr_destroy (&attr);
return x;
}])
dnl -----------------------------------------------------------------------
dnl CAIRO_CHECK_PTHREAD(tag, cflags, libs, program, true-action, false-action)
dnl Set <tag>_{CFLAGS,LIBS} to {<cflags>,<libs>} if we can compile and link
dnl <program> with the given flags and libs. Execute <true-action> on
dnl success and <false-action> on failure.
AC_DEFUN([CAIRO_CHECK_PTHREAD],[dnl
CAIRO_CC_TRY_LINK_WITH_ENV_SILENT(
[CFLAGS="$CFLAGS $2";
LIBS="$LIBS $3"],
[$4],
[$1_CFLAGS="$2";
$1_LIBS="$3";
$5],
[$1_CFLAGS="";
$1_LIBS="";
$6])
])
dnl CAIRO_CONFIGURE_PTHREADS(): Look for pthreads.
dnl
dnl If the user specifies PTHREAD_CFLAGS and PTHREAD_LIBS then we use
dnl those. Otherwise we try CFLAGS=-D_REENTRANT and LIBS=-lpthread for
dnl full pthread support, and look for stubs in libc for the minimal
dnl pthread support.
dnl
dnl CFLAGS=-D_REENTRANT LIBS=-lpthread has been tested to work on:
dnl
dnl Solaris 9 (5.9) Sun C 5.8 Patch 121015-04 2007/01/10
dnl OpenSolaris (5.11) Sun C 5.9 Patch 124868-08 2008/11/25
dnl OpenSolaris (5.11) clang version 1.1 (trunk 90017)
dnl Tru64/OSF1 V5.1 Compaq C V6.5-003
dnl Mac OS X 10.5.5 gcc 4.0.1 (Apple Inc. build 5465)
dnl Mac OS X 10.6 gcc 4.2.1 (Apple Inc. build 5659)
dnl FreeBSD 7.2 gcc 4.2
dnl OpenBSD 4.5 gcc 3.3.5 (propolice)
dnl Debian Linux (Etch) gcc 4.3
dnl
dnl Thread support is also in various libcs directly, so often using no
dnl flags at all works as well, but unfortunately Solaris 9 has
dnl practically _all_ of libpthread stubbed out in libc, so we cannot
dnl distinguish between a working libpthread and a stubbed out one by a
dnl link-only test.
dnl
dnl We also explicitly do not link to pthread-stubs or whatever other
dnl third-party stubs library, since that forces cairo clients to be
dnl extra careful when giving both libcairo and libpthread on the
dnl command line: the user would have to use "-lpthread -lcairo" rather
dnl than the more common "-lcairo -lpthread" to not accidentally use
dnl stubs pulled in by libcairo everywhere in the application. We
dnl might also need to have a way to teach pkg-config about library
dnl ordering constraints which aren't actual dependencies, and at this
dnl point it just starts doing my head in.
dnl
dnl If your unix-like doesn't work with the secret handshake
dnl -D_REENTRANT -lpthread and you can actually compile the rest of
dnl cairo just fine otherwise, please take a moment complain loudly
dnl to the cairo mailing list!
dnl
AC_DEFUN([CAIRO_CONFIGURE_PTHREAD],[dnl
dnl Try to use the user's PTHREAD_LIBS/CFLAGS
dnl if they're available.
if test "x$PTHREAD_CFLAGS" = "x"; then
PTHREAD_CFLAGS="-D_REENTRANT"
fi
if test "x$PTHREAD_LIBS" = "x"; then
PTHREAD_LIBS="-lpthread"
fi
dnl First try to find the real pthreads.
CAIRO_CHECK_PTHREAD(
[real_pthread], [$PTHREAD_CFLAGS], [$PTHREAD_LIBS],
[testsuite_pthread_program],
[have_real_pthread=yes],
[have_real_pthread=no])
if test "x$have_real_pthread" != "xyes"; then
dnl Give -pthread a go.
CAIRO_CHECK_PTHREAD(
[real_pthread], [-pthread], [],
[testsuite_pthread_program],
[have_real_pthread=yes],
[have_real_pthread="no (can't link with -lpthread or -pthread)"])
fi
PTHREAD_CFLAGS=
PTHREAD_LIBS=
dnl Check if we can use libc's stubs in libcairo.
dnl Only do this if the user hasn't explicitly enabled
dnl pthreads, but is relying on automatic configuration.
have_pthread="no"
if test "x$enable_pthread" != "xyes"; then
CAIRO_CHECK_PTHREAD(
[pthread], [-D_REENTRANT], [],
[libcairo_pthread_program],
[have_pthread=yes],
[])
fi
dnl Default to using the real pthreads for libcairo.
if test "x$have_pthread" != "xyes"; then
have_pthread="$have_real_pthread";
pthread_CFLAGS="$real_pthread_CFLAGS";
pthread_LIBS="$real_pthread_LIBS";
fi
dnl Tell autoconf about the results.
if test "x$have_real_pthread" = "xyes"; then
AC_DEFINE([CAIRO_HAS_REAL_PTHREAD], 1,
[Define to 1 if we have full pthread support])
fi
if test "x$have_pthread" = "xyes"; then
AC_DEFINE([CAIRO_HAS_PTHREAD], 1,
[Define to 1 f we have minimal pthread support])
fi
dnl Make sure we scored some pthreads.
if test "x$enable_pthread" = "xyes" -a "x$have_pthread" != "xyes"; then
AC_MSG_ERROR([pthread requested but not found])
fi
dnl Set the output variables for CAIRO_ENABLE.
use_pthread="$have_pthread"
pthread_REQUIRES=""
])

170
build/configure.ac.system
View file

@ -1,170 +0,0 @@
dnl Non-failing checks for functions, headers, libraries, etc go here
dnl ====================================================================
dnl Feature checks
dnl ====================================================================
AM_CONDITIONAL(CROSS_COMPILING, test "x$cross_compiling" = "xyes")
CAIRO_BIGENDIAN
AC_ARG_ENABLE(atomic,
[AS_HELP_STRING([--disable-atomic],
[disable use of native atomic operations])],
[use_atomic=$enableval], [use_atomic=yes])
AS_IF([test "x$use_atomic" = "xyes"], [
CAIRO_CHECK_NATIVE_ATOMIC_PRIMITIVES
CAIRO_CHECK_ATOMIC_OP_NEEDS_MEMORY_BARRIER
])
AC_CHECK_SIZEOF(void *)
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(long)
AC_CHECK_SIZEOF(long long)
AC_CHECK_SIZEOF(size_t)
AC_MSG_CHECKING([for native Win32])
case "$host" in
*-*-mingw*)
cairo_os_win32=yes
;;
*)
cairo_os_win32=no
;;
esac
AC_MSG_RESULT([$cairo_os_win32])
AM_CONDITIONAL(OS_WIN32, test "$cairo_os_win32" = "yes")
AC_MSG_CHECKING([for Sun Solaris (non-POSIX ctime_r)])
case "$host" in
*-*-solaris*)
CFLAGS="$CFLAGS -D_POSIX_PTHREAD_SEMANTICS"
solaris_posix_pthread=yes
;;
*)
solaris_posix_pthread=no
;;
esac
AC_MSG_RESULT([$solaris_posix_pthread])
dnl ====================================================================
dnl Library checks
dnl ====================================================================
LT_LIB_M
LIBS="$LIBS $LIBM"
AC_CHECK_LIB(rt, sched_yield)
has_shm_open=
AC_CHECK_LIB(rt, shm_open, [
SHM_LIBS=-lrt
has_shm_open=yes
], [SHM_LIBS=])
AM_CONDITIONAL(HAVE_SHM, test "x$has_shm_open" = "xyes")
AC_SUBST(SHM_LIBS)
AC_CHECK_LIB(socket, connect, [SOCKET_LIBS=-lsocket], [SOCKET_LIBS=])
CAIROBOILERPLATE_LIBS=$SOCKET_LIBS
AC_SUBST(CAIROBOILERPLATE_LIBS)
dnl ====================================================================
dnl Header/function checks
dnl ====================================================================
dnl check if we have a __builtin_return_address for the cairo-trace
dnl utility.
AC_MSG_CHECKING([for __builtin_return_address(0)])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[__builtin_return_address(0);]])],[have_builtin_return_address=yes],[have_builtin_return_address=no])
AC_MSG_RESULT($have_builtin_return_address)
if test "x$have_builtin_return_address" = "xyes"; then
AC_DEFINE(HAVE_BUILTIN_RETURN_ADDRESS, 1,
[Define to 1 if your compiler supports the __builtin_return_address() intrinsic.])
fi
dnl Checks for precise integer types
AC_CHECK_HEADERS([stdint.h inttypes.h sys/int_types.h])
AC_CHECK_TYPES([uint64_t, uint128_t, __uint128_t])
dnl Check for socket support for any2ppm daemon
AC_CHECK_HEADERS([fcntl.h unistd.h signal.h poll.h sys/stat.h sys/socket.h sys/poll.h sys/un.h])
dnl Check for infinite loops
AC_CHECK_FUNCS([alarm])
dnl check for CPU affinity support
AC_CHECK_HEADERS([sched.h], [AC_CHECK_FUNCS([sched_getaffinity])])
dnl check for mmap support
AC_CHECK_HEADERS([sys/mman.h], [AC_CHECK_FUNCS([mmap])])
dnl check for clock_gettime() support
AC_CHECK_HEADERS([time.h], [AC_CHECK_FUNCS([clock_gettime])])
dnl check for GNU-extensions to fenv
AC_CHECK_HEADER(fenv.h,
[AC_CHECK_FUNCS(feenableexcept fedisableexcept feclearexcept)])
dnl check for misc headers and functions
AC_CHECK_HEADERS([libgen.h byteswap.h signal.h setjmp.h fenv.h sys/wait.h])
AC_CHECK_FUNCS([ctime_r localtime_r gmtime_r drand48 flockfile funlockfile getline link strndup])
dnl Check if the runtime platform is a native Win32 host.
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [[
#ifdef _WIN32
choke me
#endif
]])], [have_windows=no], [have_windows=yes])
dnl Possible headers for mkdir
AC_CHECK_HEADERS([sys/stat.h io.h])
AC_CHECK_FUNC(mkdir,
[AC_MSG_CHECKING([mkdir variant])
mkdir_variant="unknown"
save_CFLAGS="$CFLAGS"
CFLAGS=$WARN_CFLAGS
AC_COMPILE_IFELSE(
[
AC_LANG_PROGRAM([[
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_IO_H
#include <io.h>
#endif
]],
[[mkdir ("hello.world", 0777)]])
],
[mkdir_variant="mkdir(path, mode)"],
[
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM([[
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_IO_H
#include <io.h>
#endif
]],
[[mkdir ("hello.world")]])
],
mkdir_variant="mkdir(path)")
])
AC_MSG_RESULT($mkdir_variant)
CFLAGS="$save_CFLAGS"
if test "x$mkdir_variant" = "xmkdir(path, mode)"; then
AC_DEFINE(HAVE_MKDIR, 2,
[Define to non-zero if your system has mkdir, and to 2 if your version of mkdir requires a mode parameter])
else
AC_DEFINE(HAVE_MKDIR, 1,
[Define to non-zero if your system has mkdir, and to 2 if your version of mkdir requires a mode parameter])
fi
])
dnl ===========================================================================
dnl Test for the tools required for building one big test binary
AC_CHECK_FUNCS(fork waitpid raise)

24
build/configure.ac.tools
View file

@ -1,24 +0,0 @@
AC_PATH_PROG(FIND, find)
AC_PATH_PROG(XARGS, xargs)
AC_PROG_CC
AC_PROG_CPP
AM_PROG_CC_C_O
AC_C_INLINE
dnl ===========================================================================
PKG_PROG_PKG_CONFIG()
if test "x$PKG_CONFIG" = x; then
AC_MSG_ERROR([pkg-config >= $PKGCONFIG_REQUIRED required but not found (https://pkgconfig.freedesktop.org/)])
fi
dnl Check for recent pkg-config which supports Requires.private
case `$PKG_CONFIG --version` in
[0.?|0.?.?|0.1[0-7]|0.1[0-7].?]) PKGCONFIG_REQUIRES="Requires"; ;;
*) PKGCONFIG_REQUIRES="Requires.private"; ;;
esac
AC_SUBST(PKGCONFIG_REQUIRES)

42
build/configure.ac.version
View file

@ -1,42 +0,0 @@
dnl
dnl Version stuff
dnl
dnl This macro expands to one of 'git', 'snapshot', or 'release'
m4_define([cairo_release_status],
[m4_if(m4_eval(cairo_version_micro % 2), [1], [git],
[m4_if(m4_eval(cairo_version_minor % 2), [1], [snapshot],
[release])])])
dnl This is the .so/dll number. 2 for cairo-1.x.x
m4_define([cairo_version_sonum], m4_eval(cairo_version_major + 1))
dnl The libtool shared library version stuff
m4_define([cairo_version],
m4_eval(cairo_version_major*10000 + cairo_version_minor*100 + cairo_version_micro))
m4_if(m4_eval(cairo_version_minor % 2), [1],
[
dnl for unstable releases
m4_define([cairo_libtool_revision], 0)
],
[
dnl for stable releases
m4_define([cairo_libtool_revision], cairo_version_micro)
])
m4_define([cairo_libtool_current],
m4_eval(cairo_version_sonum + cairo_version - cairo_libtool_revision))
m4_define([cairo_libtool_age],
m4_eval(cairo_libtool_current - cairo_version_sonum))
CAIRO_VERSION_MAJOR=cairo_version_major
CAIRO_VERSION_MINOR=cairo_version_minor
CAIRO_VERSION_MICRO=cairo_version_micro
CAIRO_VERSION_SONUM=cairo_version_sonum
CAIRO_RELEASE_STATUS=cairo_release_status
CAIRO_LIBTOOL_VERSION_INFO=cairo_libtool_current:cairo_libtool_revision:cairo_libtool_age
AC_SUBST(CAIRO_VERSION_MAJOR)
AC_SUBST(CAIRO_VERSION_MINOR)
AC_SUBST(CAIRO_VERSION_MICRO)
AC_SUBST(CAIRO_VERSION_SONUM)
AC_SUBST(CAIRO_RELEASE_STATUS)
AC_SUBST(CAIRO_LIBTOOL_VERSION_INFO)

99
build/configure.ac.warnings
View file

@ -1,99 +0,0 @@
dnl Use lots of warning flags with with gcc and compatible compilers
dnl Note: if you change the following variable, the cache is automatically
dnl skipped and all flags rechecked. So there's no need to do anything
dnl else. If for any reason you need to force a recheck, just change
dnl MAYBE_WARN in an ignorable way (like adding whitespace)
# -Wcast-align generates lots of false positive reports we need to
# cast image data from uint8_t to uin32_t.
# -Wlogical-op causes too much noise from strcmp("literal", str)
MAYBE_WARN="-Wall -Wextra \
-Wmissing-declarations -Werror-implicit-function-declaration \
-Wpointer-arith -Wwrite-strings -Wsign-compare -Wpacked \
-Wswitch-enum -Wmissing-format-attribute -Wvolatile-register-var \
-Wstrict-aliasing=2 -Winit-self -Wunsafe-loop-optimizations \
-Wno-missing-field-initializers -Wno-unused-parameter \
-Wno-attributes -Wno-long-long -Winline"
MAYBE_C_SPECIFIC_WARN="-Wold-style-definition \
-Wdeclaration-after-statement -Wstrict-prototypes \
-Wmissing-prototypes -Wbad-function-cast -Wnested-externs"
# New -Wno options should be added here
# gcc-4.4 and later accept every -Wno- option but may complain later that this
# option is unknown each time another warning happens.
# -Wunused-but-set-variable is too noisy at present
NO_WARN="unused-but-set-variable"
dnl Sun Studio 12 likes to rag at us for abusing enums like
dnl having cairo_status_t variables hold cairo_int_status_t
dnl values. It's bad, we know. Now please be quiet.
MAYBE_WARN="$MAYBE_WARN -erroff=E_ENUM_TYPE_MISMATCH_ARG \
-erroff=E_ENUM_TYPE_MISMATCH_OP"
dnl We also abuse the warning-flag facility to enable other compiler
dnl options. Namely, the following:
MAYBE_WARN="$MAYBE_WARN -fno-strict-aliasing -fno-common"
dnl Also to turn various gcc/glibc-specific preprocessor checks
MAYBE_WARN="$MAYBE_WARN -Wp,-D_FORTIFY_SOURCE=2"
# invalidate cached value if MAYBE_WARN has changed
if test "x$cairo_cv_warn_maybe" != "x$MAYBE_WARN"; then
unset cairo_cv_warn_cflags
fi
AC_CACHE_CHECK([for supported warning flags], cairo_cv_warn_cflags, [
echo
WARN_CFLAGS=""
# Some warning options are not supported by all versions of
# gcc, so test all desired options against the current
# compiler.
#
# Note that there are some order dependencies
# here. Specifically, an option that disables a warning will
# have no net effect if a later option then enables that
# warnings, (perhaps implicitly). So we put some grouped
# options (-Wall and -Wextra) up front and the -Wno options
# last.
for W in $MAYBE_WARN; do
CAIRO_CC_TRY_FLAG([$W],, [WARN_CFLAGS="$WARN_CFLAGS $W"])
done
for W in $NO_WARN; do
CAIRO_CC_TRY_FLAG([-W$W -Wno-$W],, [WARN_CFLAGS="$WARN_CFLAGS -Wno-$W"])
done
cairo_cv_warn_cflags=$WARN_CFLAGS
cairo_cv_warn_maybe="$MAYBE_WARN $MAYBE_C_SPECIFIC_WARN"
AC_MSG_CHECKING([which warning flags were supported])
])
WARN_CFLAGS="$cairo_cv_warn_cflags"
CAIRO_CFLAGS="$CAIRO_CFLAGS $WARN_CFLAGS"
# We only wish to enable attribute(warn_unused_result) if we can prevent
# gcc from generating thousands of warnings about the misapplication of the
# attribute to void functions and variables.
AC_CACHE_CHECK([how to enable unused result warnings], cairo_cv_warn_unused_result, [
AC_REQUIRE([AC_PROG_GREP])
cairo_cv_warn_unused_result=""
if echo $WARN_CFLAGS | $GREP -e '-Wno-attributes' >/dev/null; then
CAIRO_CC_TRY_FLAG_SILENT(
[-Wno-attributes],
[__attribute__((__warn_unused_result__)) void f (void) {}
__attribute__((__warn_unused_result__)) int g;],
[cairo_cv_warn_unused_result="__attribute__((__warn_unused_result__))"])
fi
])
AC_DEFINE_UNQUOTED([WARN_UNUSED_RESULT], [$cairo_cv_warn_unused_result],
[Define to the value your compiler uses to support the warn-unused-result attribute])
dnl check linker flags
AC_CACHE_CHECK([how to allow undefined symbols in shared libraries used by test suite], cairo_cv_test_undefined_ldflags,
[CAIRO_CC_TRY_FLAG_SILENT([-Wl,--allow-shlib-undefined], [],
[cairo_cv_test_undefined_ldflags="-Wl,--allow-shlib-undefined]")])
CAIRO_TEST_UNDEFINED_LDFLAGS="$cairo_cv_test_undefined_ldflags"
AC_SUBST(CAIRO_TEST_UNDEFINED_LDFLAGS)

819
configure.ac
View file

@ -1,819 +0,0 @@
AC_PREREQ([2.63])
CAIRO_PARSE_VERSION
AC_INIT([cairo],
[cairo_version_major.cairo_version_minor.cairo_version_micro],
[https://gitlab.freedesktop.org/cairo/cairo/-/issues],
[cairo],
[https://cairographics.org/])
AC_CONFIG_AUX_DIR(build)
AC_CONFIG_MACRO_DIR(build)
AC_USE_SYSTEM_EXTENSIONS
AC_CONFIG_SRCDIR(src/cairo.h)
AC_CONFIG_HEADERS(config.h)
AC_CHECK_HEADERS([unistd.h sys/ioctl.h])
AC_C_TYPEOF
AM_INIT_AUTOMAKE([1.11 foreign -Wall no-define no-dist-gzip dist-xz serial-tests subdir-objects])
AM_SILENT_RULES([yes])
m4_ifdef([AM_PROG_AR], [AM_PROG_AR]) dnl Workaround for Automake 1.12
# Initialize libtool
LT_PREREQ([2.2])
LT_INIT([win32-dll])
# Api documentation
GTK_DOC_CHECK([1.15],[--flavour no-tmpl])
AC_SYS_LARGEFILE
dnl ===========================================================================
dnl
dnl The order of the includes here is rather important
dnl
m4_include(build/configure.ac.version) dnl macros setting up various version declares
m4_include(build/configure.ac.tools) dnl checks for tools we use
m4_include(build/configure.ac.features) dnl macros for backend/feature handling
m4_include(build/configure.ac.warnings) dnl checks for compiler warning
m4_include(build/configure.ac.system) dnl checks for system functions, headers, libs
m4_include(build/configure.ac.analysis) dnl checks for analysis tools (lcov, etc)
m4_include(build/configure.ac.noversion) dnl disable builtin libtool versioning
m4_include(build/configure.ac.pthread) dnl checks for pthreads
AC_CACHE_SAVE
dnl ===========================================================================
AC_CHECK_LIB(z, compress,
[AC_CHECK_HEADER(zlib.h, [
have_libz=yes
AC_DEFINE(HAVE_ZLIB, 1, [Define to 1 if you have zlib available])
],
[have_libz="no (requires zlib http://www.gzip.org/zlib/)"])],
[have_libz="no (requires zlib http://www.gzip.org/zlib/)"])
save_LIBS="$LIBS"
AC_CHECK_LIB(lzo2, lzo2a_decompress,
[AC_CHECK_HEADER(lzo/lzo2a.h, [
have_lzo=yes
AC_DEFINE(HAVE_LZO, 1, [Define to 1 if you have lzo available])
lzo_LIBS="-llzo2"
],
[have_lzo="no (requires lzpo http://www.oberhumer.com/opensource/lzo/)"])],
[have_lzo="no (requires lzpo http://www.oberhumer.com/opensource/lzo/)"])
AC_SUBST(lzo_LIBS)
LIBS="$save_LIBS"
AC_CHECK_LIB(dl, dlsym,
[have_dlsym=yes; have_dl=yes],
[have_dlsym=no; have_dl=no])
if test "x$have_dlsym" = "xno"; then
AC_CHECK_FUNC(dlsym, [have_dlsym=yes], [have_dlsym=no])
fi
AC_CHECK_HEADERS(dlfcn.h, [have_dlsym=yes], [have_dlsym=no])
AM_CONDITIONAL(CAIRO_HAS_DL, test "x$have_dl" = "xyes")
if test "x$have_dlsym" = "xyes"; then
AC_DEFINE([CAIRO_HAS_DLSYM], 1, [Define to 1 if dlsym is available])
fi
AM_CONDITIONAL(CAIRO_HAS_DLSYM, test "x$have_dlsym" = "xyes")
AC_CHECK_HEADERS(xlocale.h)
AC_CHECK_FUNCS(newlocale strtod_l)
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(xlib, Xlib, auto, [
xlib_REQUIRES="x11 xext"
PKG_CHECK_MODULES(xlib, $xlib_REQUIRES, ,
[xlib_REQUIRES=""
AC_PATH_XTRA
if test "x$no_x" = xyes; then
use_xlib="no (requires X development libraries)"
else
xlib_NONPKGCONFIG_LIBS="$X_PRE_LIBS $X_LIBS -lX11 -lXext $X_EXTRA_LIBS"
xlib_NONPKGCONFIG_CFLAGS=$X_CFLAGS
fi])
AC_CHECK_HEADER(sys/ipc.h)
AC_CHECK_HEADER(sys/shm.h)
if test "$ac_cv_header_sys_ipc_h" = "yes" -a "$ac_cv_header_sys_shm_h" = "yes"; then
AC_MSG_CHECKING(whether shmctl IPC_RMID allowes subsequent attaches)
AC_RUN_IFELSE([AC_LANG_SOURCE([[
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
int main()
{
char *shmaddr;
int id = shmget (IPC_PRIVATE, 4, IPC_CREAT | 0600);
if (id == -1) return 2;
shmaddr = shmat (id, 0, 0);
shmctl (id, IPC_RMID, 0);
if ((char*) shmat (id, 0, 0) == (char*) -1) {
shmdt (shmaddr);
return 1;
}
shmdt (shmaddr);
shmdt (shmaddr);
return 0;
}
]])],
[
AC_DEFINE(IPC_RMID_DEFERRED_RELEASE, 1, Define to 1 if shared memory segments are released deferred.)
AC_MSG_RESULT(yes)],
[AC_MSG_RESULT(no)],[AC_MSG_RESULT(assuming no)])
fi
AC_CHECK_HEADERS([X11/extensions/XShm.h X11/extensions/shmproto.h X11/extensions/shmstr.h], [], [],
[#include <X11/Xlibint.h>
#include <X11/Xproto.h>])
])
CAIRO_ENABLE_SURFACE_BACKEND(xlib_xrender, Xlib Xrender, auto, [
if test "x$use_xlib" != "xyes"; then
use_xlib_xrender="no (requires --enable-xlib)"
else
dnl Check for Xrender header files if the Xrender package is not installed:
xlib_xrender_BASE=cairo-xlib
dnl Keep in sync with meson.build!
xlib_xrender_REQUIRES="xrender >= 0.6"
PKG_CHECK_MODULES(xlib_xrender, $xlib_xrender_REQUIRES, ,
[xlib_xrender_REQUIRES=""
old_CPPFLAGS=$CPPFLAGS
CPPFLAGS="$CPPFLAGS $xlib_CFLAGS $xlib_NONPKGCONFIG_CFLAGS"
AC_CHECK_HEADER(X11/extensions/Xrender.h,
[xlib_xrender_NONPKGCONFIG_LIBS="-lXrender"],
[use_xlib_xrender="no (requires $xlib_xrender_REQUIRES https://freedesktop.org/Software/xlibs)"],
[#include <X11/X.h>])
CPPFLAGS=$old_CPPFLAGS
])
old_CFLAGS=$CFLAGS
old_LIBS=$LIBS
CFLAGS="$CFLAGS $xlib_CFLAGS $xlib_NONPKGCONFIG_CFLAGS $xlib_xrender_CFLAGS $xlib_xrender_NONPKGCONFIG_CFLAGS"
LIBS="$LIBS $xlib_LIBS $xlib_NONPKGCONFIG_LIBS $xlib_xrender_LIBS $xlib_xrender_NONPKGCONFIG_LIBS"
AC_CHECK_FUNCS([XRenderCreateSolidFill XRenderCreateLinearGradient XRenderCreateRadialGradient XRenderCreateConicalGradient])
CFLAGS=$old_CFLAGS
LIBS=$old_LIBS
fi
])
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(xcb, XCB, auto, [
dnl Keep in sync with meson.build!
xcb_REQUIRES="xcb >= 1.6 xcb-render >= 1.6"
PKG_CHECK_MODULES(xcb, $xcb_REQUIRES, ,
[use_xcb="no (requires $xcb_REQUIRES https://xcb.freedesktop.org)"])
])
CAIRO_ENABLE_FUNCTIONS(xlib_xcb, Xlib/XCB, no, [
if test "x$use_xcb" = "xyes" -a "x$use_xlib" = "xyes"; then
xlib_xcb_REQUIRES="x11-xcb"
PKG_CHECK_MODULES(xlib_xcb, $xlib_xcb_REQUIRES, ,
[use_xlib_xcb="no (requires $xlib_xcb_REQUIRES https://xcb.freedesktop.org)"])
else
use_xlib_xcb="no (requires both --enable-xlib and --enable-xcb)"
fi
])
CAIRO_ENABLE_FUNCTIONS(xcb_shm, XCB/SHM, auto, [
if test "x$use_xcb" = "xyes"; then
xcb_shm_REQUIRES="xcb-shm"
PKG_CHECK_MODULES(xcb_shm, $xcb_shm_REQUIRES, ,
[use_xcb_shm="no (requires $xcb_shm https://xcb.freedesktop.org)"])
else
use_xcb_shm="no (requires --enable-xcb)"
fi
])
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(quartz, Quartz, auto, [
dnl There is no pkgconfig for quartz; lets do a header check
AC_CHECK_HEADER(ApplicationServices/ApplicationServices.h, , [use_quartz="no (requires ApplicationServices framework)"])
AC_CHECK_FUNC([CTFontDrawGlyphs],,[use_quartz_fonts="no (requires Mac OS X 10.7 or later)"])
if test "x$use_quartz" = "xyes" ; then
quartz_LIBS="-Xlinker -framework -Xlinker ApplicationServices"
fi
])
CAIRO_ENABLE_FONT_BACKEND(quartz_font, Quartz, auto, [
use_quartz_font=$use_quartz
])
CAIRO_ENABLE_SURFACE_BACKEND(quartz_image, Quartz Image, no, [
use_quartz_image=$use_quartz
])
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(win32, Microsoft Windows, auto, [
if test "x$have_windows" != xyes; then
use_win32="no (requires a Win32 platform)"
fi
win32_LIBS="-lgdi32 -lmsimg32"
])
CAIRO_ENABLE_FONT_BACKEND(win32_font, Microsoft Windows, auto, [
use_win32_font=$use_win32
])
test_win32_printing=no
if test "x$use_win32" = "xyes"; then
AC_CHECK_PROG(GS, gs, gs)
if test "$GS"; then
AC_DEFINE([CAIRO_CAN_TEST_WIN32_PRINTING_SURFACE], 1, [Define to 1 if the Win32 Printing backend can be tested (needs ghostscript)])
test_win32_printing="yes"
else
AC_MSG_WARN([Win32 Printing backend will not be tested since ghostscript is not available])
test_win32_printing="no (requires ghostscript)"
fi
fi
AM_CONDITIONAL(CAIRO_CAN_TEST_WIN32_PRINTING_SURFACE, test "x$test_win32_printing" = "xyes")
dnl ===========================================================================
CAIRO_ENABLE_FUNCTIONS(png, PNG, yes, [
use_png=no
AC_ARG_VAR([png_REQUIRES], [module name for libpng to search for using pkg-config])
if test "x$png_REQUIRES" = x; then
# libpng13 is GnuWin32's libpng-1.2.8 :-(
for l in libpng libpng14 libpng12 libpng13 libpng10; do
if $PKG_CONFIG --exists $l ; then
png_REQUIRES=$l
use_png=yes
break
fi
done
else
use_png=yes
fi
if test "x$use_png" = "xyes" ; then
PKG_CHECK_MODULES(png, $png_REQUIRES, , : )
else
AC_MSG_WARN([Could not find libpng in the pkg-config search path])
fi
])
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(gl, OpenGL, no, [
gl_REQUIRES="gl"
PKG_CHECK_MODULES(gl, $gl_REQUIRES,, [
dnl Fallback to searching for headers
AC_CHECK_HEADER(GL/gl.h,, [use_gl="no (gl.pc nor OpenGL headers not found)"])
if test "x$use_gl" = "xyes"; then
gl_NONPKGCONFIG_CFLAGS=
gl_NONPKGCONFIG_LIBS="-lGL"
fi])
if test "x$have_dl" = "xyes" -a "x$have_dlsym" = "xyes"; then
gl_LIBS="$gl_LIBS -ldl"
fi
need_glx_functions=yes
need_wgl_functions=yes
need_egl_functions=yes
])
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(glesv2, OpenGLESv2, no, [
glesv2_REQUIRES="glesv2"
PKG_CHECK_MODULES(glesv2, $glesv2_REQUIRES,, [
dnl Fallback to searching for headers
AC_CHECK_HEADER(GLES2/gl2.h,, [use_glesv2="no (glesv2.pc nor OpenGL ES 2.0 headers not found)"])
if test "x$use_glesv2" = "xyes"; then
glesv2_NONPKGCONFIG_CFLAGS=
glesv2_NONPKGCONFIG_LIBS="-lGLESv2"
fi])
if test "x$have_dl" = "xyes" -a "x$have_dlsym" = "xyes"; then
glesv2_LIBS="$glesv2_LIBS -ldl"
fi
if test "x$use_glesv2" = "xyes" -a "x$use_gl" = "xyes"; then
AC_MSG_ERROR([use either --enable-gl=yes or --enable-glesv2=yes. Not both at the same time.])
fi
need_egl_functions=yes
])
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(glesv3, OpenGLESv3, no, [
dnl glesv3 is provided via libGLESv2.so, so require glesv2.pc (there is no libGLESv3, nor glesv3.pc)
glesv3_REQUIRES="glesv2"
PKG_CHECK_MODULES(glesv3, $glesv3_REQUIRES,, [
use_glesv3="no (glesv2.pc not found, required for glesv3)"
])
dnl Since there is no glesv3.pc, need to search for header files
AC_CHECK_HEADER(GLES3/gl3.h,, [use_glesv3="no (OpenGL ES 3.0 headers not found)"])
if test "x$use_glesv3" = "xyes"; then
glesv3_NONPKGCONFIG_CFLAGS=
glesv3_NONPKGCONFIG_LIBS="-lGLESv2"
fi
if test "x$have_dl" = "xyes" -a "x$have_dlsym" = "xyes"; then
glesv3_LIBS="$glesv3_LIBS -ldl"
fi
if test "x$use_glesv3" = "xyes" -a "x$use_gl" = "xyes"; then
AC_MSG_ERROR([use either --enable-gl=yes or --enable-glesv3=yes. Not both at the same time.])
fi
need_egl_functions=yes
])
dnl ===========================================================================
CAIRO_ENABLE_FUNCTIONS(egl, EGL, auto, [
if test "x$need_egl_functions" = "xyes"; then
egl_REQUIRES="egl"
PKG_CHECK_MODULES(egl, $egl_REQUIRES, ,
[egl_REQUIRES=""
AC_CHECK_HEADER(EGL/egl.h,, [use_egl="no (EGL headers not found)"])
if test "x$use_egl" = "xyes"; then
egl_NONPKGCONFIG_CFLAGS=
egl_NONPKGCONFIG_LIBS=
save_LIBS="$LIBS"
other_egl_LIBS=""
# Temporary workaround for missing link from egl13
AC_CHECK_LIB(csi, csi_stream_attachresource, other_egl_LIBS="-lcsi")
LIBS="$other_egl_LIBS $LIBS"
for egl_lib in EGL egl13 egl12 egl11; do
if test -z "$egl_NONPKGCONFIG_LIBS"; then
AC_CHECK_LIB($egl_lib, eglGetError, egl_NONPKGCONFIG_LIBS="-l$egl_lib")
fi
done
if test -z "$egl_NONPKGCONFIG_LIBS"; then
use_egl="no (EGL library not found)"
else
egl_NONPKGCONFIG_LIBS="$egl_NONPKGCONFIG_LIBS $other_egl_LIBS"
fi
LIBS="$save_LIBS"
fi
])
else
use_egl="no (not required by any backend)"
fi
])
CAIRO_ENABLE_FUNCTIONS(glx, GLX, auto, [
if test "x$need_glx_functions" = "xyes"; then
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $gl_CFLAGS $gl_NONPKGCONFIG_CFLAGS"
AC_CHECK_HEADER(GL/glx.h,, [use_glx="no (GLX headers not found)"])
glx_NONPKGCONFIG_CFLAGS=
glx_NONPKGCONFIG_LIBS="-lGL"
CFLAGS="$save_CFLAGS"
else
use_glx="no (not required by any backend)"
fi
])
CAIRO_ENABLE_FUNCTIONS(wgl, WGL, auto, [
if test "x$need_wgl_functions" = "xyes"; then
AC_CHECK_HEADER(windows.h,, [use_wgl="no (WGL headers not found)"])
else
use_wgl="no (not required by any backend)"
fi
])
dnl ===========================================================================
any2ppm_cs=no
CAIRO_ENABLE_SURFACE_BACKEND(script, script, yes, [
any2ppm_cs=yes
# The script backend requires zlib.
use_script=$have_libz
script_NONPKGCONFIG_LIBS=-lz
])
dnl ===========================================================================
# We use pkg-config to look for freetype2, but fall back to
# freetype-config if it fails. We prefer pkg-config, since we can
# then just put freetype2 >= $FREETYPE_MIN_VERSION in
# Requires.private, but at least up to 2003-06-07, there was no
# freetype2.pc in the release.
#
# FreeType versions come in three forms:
# release (such as 2.1.9)
# libtool (such as 9.7.3) (returned by freetype-config and pkg-config)
# platform-specific/soname (such as 6.3.4)
# and they recommend you never use the platform-specific version
# (see docs/VERSION.DLL in freetype2 sources)
#
# Set these as appropriate:
# release number - for information only
FREETYPE_MIN_RELEASE=2.1.9
# libtool-specific version - this is what is checked
# Keep in sync with meson.build!
FREETYPE_MIN_VERSION=9.7.3
CAIRO_ENABLE_FONT_BACKEND(ft, FreeType, auto, [
PKG_CHECK_MODULES(FREETYPE, freetype2 >= $FREETYPE_MIN_VERSION,
[freetype_pkgconfig=yes],
[freetype_pkgconfig=no])
if test "x$freetype_pkgconfig" = "xyes"; then
ft_REQUIRES="freetype2 >= $FREETYPE_MIN_VERSION $ft_REQUIRES"
else
if test -z "$FREETYPE_CONFIG"; then
AC_PATH_PROG(FREETYPE_CONFIG, freetype-config, no)
fi
if test "x$FREETYPE_CONFIG" = "xno" ; then
use_ft='no (freetype-config not found in path or $FREETYPE_CONFIG)'
else
AC_MSG_CHECKING(freetype2 libtool version)
FREETYPE_VERSION=`$FREETYPE_CONFIG --version`
AX_COMPARE_VERSION([$FREETYPE_VERSION], [gt], [$FREETYPE_MIN_VERSION],
[AC_MSG_RESULT($FREETYPE_VERSION - OK)
ft_NONPKGCONFIG_CFLAGS=`$FREETYPE_CONFIG --cflags`
ft_NONPKGCONFIG_LIBS=`$FREETYPE_CONFIG --libs`],
[AC_MSG_RESULT($FREETYPE_VERSION - Too old)
use_ft="no ($FREETYPE_VERSION found; version $FREETYPE_MIN_VERSION from release $FREETYPE_MIN_RELEASE required)"])
fi
fi
ft_CFLAGS="$FREETYPE_CFLAGS"
ft_LIBS="$FREETYPE_LIBS"
])
# Keep in sync with meson.build!
FONTCONFIG_MIN_VERSION=2.2.95
CAIRO_ENABLE_FONT_BACKEND(fc, Fontconfig, auto, [
use_fc=$use_ft
if test "x$use_fc" = "xyes"; then
fc_REQUIRES="fontconfig >= $FONTCONFIG_MIN_VERSION"
PKG_CHECK_MODULES(FONTCONFIG, $fc_REQUIRES,,
[use_fc="no (requires $fc_REQUIRES)"])
fi
fc_CFLAGS="$FONTCONFIG_CFLAGS"
fc_LIBS="$FONTCONFIG_LIBS"
])
if test "x$use_ft" = "xyes"; then
_save_libs="$LIBS"
_save_cflags="$CFLAGS"
LIBS="$LIBS $ft_LIBS"
CFLAGS="$CFLAGS $ft_CFLAGS"
AC_CHECK_FUNCS(FT_Get_X11_Font_Format FT_GlyphSlot_Embolden FT_GlyphSlot_Oblique FT_Load_Sfnt_Table FT_Library_SetLcdFilter FT_Get_Var_Design_Coordinates FT_Done_MM_Var FT_Palette_Select)
AC_CHECK_TYPES([FT_SVG_Document], [have_ft_svg=yes], [have_ft_svg=no], [[#include <freetype/otsvg.h>]])
AM_CONDITIONAL(HAVE_FT_SVG_DOCUMENT, test "x$have_ft_svg=" = "xyes")
AC_MSG_CHECKING(for FT_HAS_COLOR)
AC_LINK_IFELSE([AC_LANG_PROGRAM([
#include <ft2build.h>
#include FT_FREETYPE_H
],[
FT_Long has_color = FT_HAS_COLOR( ((FT_Face)NULL) );
])],[AC_MSG_RESULT([yes])],[
AC_DEFINE([FT_HAS_COLOR(x)], [(0)], [Define to (0) if freetype2 does not support color fonts])
AC_MSG_RESULT([no, disable color font (freetype2 >= 2.5.1 is required)])
])
LIBS="$_save_libs"
CFLAGS="$_save_cflags"
fi
if test "x$use_fc" = "xyes"; then
CAIRO_CHECK_FUNCS_WITH_FLAGS(FcInit FcFini, [$FONTCONFIG_CFLAGS], [$FONTCONFIG_LIBS])
fi
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(ps, PostScript, yes, [
# The ps backend requires zlib.
use_ps=$have_libz
ps_NONPKGCONFIG_LIBS=-lz
])
dnl ===========================================================================
# Keep in sync with meson.build!
SPECTRE_VERSION_REQUIRED=0.2.0
test_ps=no
any2ppm_ps=no
if test "x$use_ps" = "xyes"; then
AC_CHECK_PROG(GS, gs, gs)
if test "$GS"; then
AC_DEFINE([CAIRO_CAN_TEST_PS_SURFACE], 1, [Define to 1 if the PS backend can be tested (needs ghostscript)])
test_ps="yes"
else
AC_MSG_WARN([PS backend will not be tested since ghostscript is not available])
test_ps="no (requires ghostscript)"
fi
libspectre_DEPENDENCY="libspectre >= $SPECTRE_VERSION_REQUIRED"
PKG_CHECK_MODULES(LIBSPECTRE, $libspectre_DEPENDENCY,
[any2ppm_ps=yes],
[test_ps="no (requires libspectre)"])
fi
AM_CONDITIONAL(CAIRO_CAN_TEST_PS_SURFACE, test "x$test_ps" = "xyes")
AM_CONDITIONAL(CAIRO_HAS_SPECTRE, test "x$any2ppm_ps" = "xyes")
if test "x$any2ppm_ps" = "xyes"; then
AC_DEFINE([CAIRO_HAS_SPECTRE], 1, [Define to 1 if libspectre is available])
fi
AC_SUBST(LIBSPECTRE_CFLAGS)
AC_SUBST(LIBSPECTRE_LIBS)
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(pdf, PDF, yes, [
# The pdf backend requires zlib.
use_pdf=$have_libz
pdf_NONPKGCONFIG_LIBS=-lz
])
dnl ===========================================================================
# poppler-0.17.4 fixes text-pattern and text-transform
# Keep in sync with meson.build!
POPPLER_VERSION_REQUIRED=0.17.4
test_pdf=no
any2ppm_pdf=no
if test "x$use_pdf" = "xyes"; then
poppler_DEPENDENCY="poppler-glib >= $POPPLER_VERSION_REQUIRED"
PKG_CHECK_MODULES(POPPLER, $poppler_DEPENDENCY,
[CAIRO_CHECK_FUNCS_WITH_FLAGS(poppler_page_render, [$POPPLER_CFLAGS], [$POPPLER_LIBS],
[test_pdf=yes; any2ppm_pdf=yes],
[test_pdf="no (requires $poppler_DEPENDENCY)"])],
[test_pdf="no (requires $poppler_DEPENDENCY)"])
if test "x$test_pdf" = "xyes"; then
AC_DEFINE([CAIRO_CAN_TEST_PDF_SURFACE], 1, [Define to 1 if the PDF backend can be tested (need poppler and other dependencies for pdf2png)])
else
AC_MSG_WARN([PDF backend will not be tested since poppler >= $POPPLER_VERSION_REQUIRED is not available])
fi
fi
AM_CONDITIONAL(CAIRO_CAN_TEST_PDF_SURFACE, test "x$test_pdf" = "xyes")
AC_SUBST(POPPLER_CFLAGS)
AC_SUBST(POPPLER_LIBS)
AM_CONDITIONAL(CAIRO_HAS_MULTI_PAGE_SURFACES, test "x$use_ps" = "xyes" -o "x$use_pdf" = "xyes")
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(svg, SVG, yes, [
if test "x$use_png" != "xyes"; then
use_svg="no (requires --enable-png)"
fi
])
dnl Keep in sync with meson.build!
LIBRSVG_VERSION_REQUIRED=2.35.0
test_svg=no
any2ppm_svg=no
if test "x$use_svg" = "xyes"; then
librsvg_DEPENDENCY="librsvg-2.0 >= $LIBRSVG_VERSION_REQUIRED"
PKG_CHECK_MODULES(LIBRSVG, $librsvg_DEPENDENCY gdk-2.0,
[CAIRO_CHECK_FUNCS_WITH_FLAGS(rsvg_pixbuf_from_file, [$LIBRSVG_CFLAGS], [$LIBRSVG_LIBS],
[test_svg=yes; any2ppm_svg=yes],
[test_svg="no (requires $librsvg_DEPENDENCY)"])],
[test_svg="no (requires $librsvg_DEPENDENCY)"])
if test "x$test_svg" = "xyes"; then
AC_DEFINE([CAIRO_CAN_TEST_SVG_SURFACE], 1, [Define to 1 if the SVG backend can be tested])
else
AC_MSG_WARN([SVG backend will not be tested since librsvg >= $LIBRSVG_VERSION_REQUIRED is not available])
fi
fi
AM_CONDITIONAL(CAIRO_CAN_TEST_SVG_SURFACE, test "x$test_svg" = "xyes")
AC_SUBST(LIBRSVG_CFLAGS)
AC_SUBST(LIBRSVG_LIBS)
dnl ===========================================================================
dnl XXX make this a private feature?
CAIRO_ENABLE(test_surfaces, test surfaces, no)
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(image, image, always, [
dnl Keep in sync with meson.build!
pixman_REQUIRES="pixman-1 >= 0.36.0"
PKG_CHECK_MODULES(pixman, $pixman_REQUIRES, ,
[use_image="no (requires $pixman_REQUIRES https://cairographics.org/releases/)"])
image_REQUIRES=$pixman_REQUIRES
image_CFLAGS=$pixman_CFLAGS
image_LIBS=$pixman_LIBS
])
if pkg-config --exists 'pixman-1 >= 0.27.1'; then
AC_DEFINE([HAS_PIXMAN_GLYPHS], 1, [Enable pixman glyph cache])
fi
dnl ===========================================================================
CAIRO_ENABLE_SURFACE_BACKEND(mime, mime, always)
CAIRO_ENABLE_SURFACE_BACKEND(recording, recording, always)
CAIRO_ENABLE_SURFACE_BACKEND(observer, observer, always)
CAIRO_ENABLE_SURFACE_BACKEND(tee, tee, no)
CAIRO_ENABLE_SURFACE_BACKEND(xml, xml, no, [
if test "x$use_png" != "xyes"; then
use_xml="no (requires --enable-png)"
else
use_xml=$have_libz
xml_NONPKGCONFIG_LIBS=-lz
fi
])
dnl ===========================================================================
CAIRO_ENABLE_FONT_BACKEND(user, user, always)
dnl ===========================================================================
dnl
dnl This needs to be last on our list of features so that the pthread libs and flags
dnl gets prefixed in front of everything else in CAIRO_{CFLAGS,LIBS}.
dnl
have_real_pthread=no
have_pthread=no
CAIRO_ENABLE(pthread, pthread, auto, [CAIRO_CONFIGURE_PTHREAD])
AM_CONDITIONAL(HAVE_REAL_PTHREAD, test "x$use_pthread" = "xyes" -a "x$have_real_pthread" = "xyes")
AM_CONDITIONAL(HAVE_PTHREAD, test "x$use_pthread" = "xyes")
AC_SUBST(pthread_CFLAGS)
AC_SUBST(pthread_LIBS)
AC_SUBST(real_pthread_CFLAGS)
AC_SUBST(real_pthread_LIBS)
dnl ===========================================================================
dnl Build gobject integration library
CAIRO_ENABLE_FUNCTIONS(gobject, gobject, auto, [
dnl Keep in sync with meson.build!
gobject_REQUIRES="gobject-2.0 glib-2.0 >= 2.14"
PKG_CHECK_MODULES(GOBJECT, $gobject_REQUIRES, ,
[use_gobject="no (requires $gobject_REQUIRES https://download.gnome.org/pub/GNOME/sources/glib/)"])
gobject_NONPKGCONFIG_EXTRA_LIBS="-L\${libdir} -lcairo-gobject"
])
dnl I'm too lazy to fix the caching properly
if test "x$use_gobject" = "xyes"; then
PKG_CHECK_MODULES(GOBJECT, $gobject_REQUIRES, : )
fi
dnl ===========================================================================
dnl Default to quick testing during development, but force a full test before
dnl release
AC_ARG_ENABLE(full-testing,
AS_HELP_STRING([--enable-full-testing],
[Sets the test suite to perform full testing by default, which
will dramatically slow down make check, but is a
*requirement* before release.]), [
if test "x$enableval" = "xyes"; then
CAIRO_TEST_MODE=full
AC_SUBST(CAIRO_TEST_MODE)
fi
])
dnl ===========================================================================
dnl Build the external converter if we have any of the test backends
AM_CONDITIONAL(BUILD_ANY2PPM,
test "x$any2ppm_svg" = "xyes" \
-o "x$any2ppm_pdf" = "xyes" \
-o "x$any2ppm_ps" = "xyes" \
-o "x$any2ppm_cs" = "xyes")
dnl ===========================================================================
dnl Some utilities need to dlopen the shared libraries, so they need to
dnl know how libtools will name them
case $host in
*-*-darwin*)
SHLIB_EXT="dylib"
;;
*)
SHLIB_EXT="so"
;;
esac
AC_DEFINE_UNQUOTED(SHARED_LIB_EXT, "${SHLIB_EXT}", [Shared library file extension])
AC_SUBST(SHLIB_EXT)
dnl ===========================================================================
dnl The tracing utility requires LD_PRELOAD, so only build it for systems
dnl that are known to work.
case $host in
*-linux*|*-*bsd*|*-solaris*|*-*-darwin*|*-dragonfly*|*-*-gnu*)
have_ld_preload="yes"
;;
*)
have_ld_preload="no"
;;
esac
CAIRO_ENABLE(trace, cairo-trace, auto, [
if test "x$have_ld_preload" != "xyes" -o \
"x$have_libz" != "xyes" -o \
"x$have_real_pthread" != "xyes" -o \
"x$have_dlsym" != "xyes"; then
use_trace="no (requires dynamic linker and zlib and real pthreads)"
fi
])
CAIRO_ENABLE(interpreter, cairo-script-interpreter, yes, [
if test "x$have_libz" != "xyes"; then
use_interpreter="no (requires zlib)"
fi
])
AC_CHECK_LIB(bfd, bfd_openr,
[AC_CHECK_HEADER(bfd.h, [have_bfd=yes],
[have_bfd=no])], [have_bfd=no])
dnl bfd_section_flags is an inline func so we don't bother with linking the lib in
AC_LINK_IFELSE([AC_LANG_PROGRAM([
#include <bfd.h>
asection *s;
],[
return bfd_section_flags(s) == 0;
])],[],[have_bfd=no])
if test "x$have_bfd" = "xyes"; then
AC_DEFINE([HAVE_BFD], [1], [Define to 1 if you have the binutils development files installed])
BFD_LIBS=-lbfd
AC_SUBST(BFD_LIBS)
fi
CAIRO_ENABLE(symbol_lookup, symbol-lookup, auto, [
if test "x$have_bfd" != "xyes"; then
use_symbol_lookup="no (requires bfd)"
fi
])
PKG_CHECK_MODULES(glib, glib-2.0, have_glib=yes, have_glib=no)
AC_SUBST(glib_CFLAGS)
AC_SUBST(glib_LIBS)
AM_CONDITIONAL(BUILD_SPHINX, test "x$have_glib" = "xyes" -a "x$have_windows" = "xno" -a "x$use_png" = "xyes")
save_LIBS="$LIBS"
AC_CHECK_LIB(rt, shm_open, shm_LIBS="-lrt")
AC_SUBST(shm_LIBS)
LIBS="$save_LIBS"
dnl ===========================================================================
AC_ARG_ENABLE(some-floating-point,
AS_HELP_STRING([--disable-some-floating-point],
[Disable certain code paths that rely heavily on double precision
floating-point calculation. This option can improve
performance on systems without a double precision floating-point
unit, but might degrade performance on those that do.]), [
if test "x$enableval" = "xno"; then
# A value of 'no' for $enableval means that they want to disable, which
# means 'yes' for $disable_some_floating_point.
disable_some_floating_point=yes
fi
], [disable_some_floating_point=no])
AM_CONDITIONAL(DISABLE_SOME_FLOATING_POINT,
test "x$disable_some_floating_point" = "xyes")
if test "x$disable_some_floating_point" = "xyes"; then
AC_DEFINE(DISABLE_SOME_FLOATING_POINT, 1,
[Define to 1 to disable certain code paths that rely heavily on
double precision floating-point calculation])
fi
dnl ===========================================================================
# We use GTK+ for some utility/debugging tools
PKG_CHECK_MODULES(gtk, "gtk+-2.0",have_gtk=yes, have_gtk=no)
AM_CONDITIONAL(HAVE_GTK, test "x$have_gtk" = "xyes")
AC_CONFIG_FILES([
Makefile
boilerplate/Makefile
src/Makefile
test/Makefile
test/pdiff/Makefile
perf/Makefile
perf/micro/Makefile
util/Makefile
util/cairo-fdr/Makefile
util/cairo-gobject/Makefile
util/cairo-missing/Makefile
util/cairo-script/Makefile
util/cairo-script/examples/Makefile
util/cairo-sphinx/Makefile
util/cairo-trace/Makefile
util/cairo-trace/cairo-trace
doc/Makefile
doc/public/Makefile
])
AC_CONFIG_COMMANDS([cairo-trace],
[chmod a+x util/cairo-trace/cairo-trace])
AC_OUTPUT
CAIRO_REPORT

7
doc/Makefile.am
View file

@ -1,7 +0,0 @@
include $(top_srcdir)/build/Makefile.am.common
SUBDIRS=public
doc:
cd public && $(MAKE) $(AM_MAKEFLAGS) doc
.PHONY: doc

60
doc/public/Makefile.am
View file

@ -1,60 +0,0 @@
include $(top_srcdir)/build/Makefile.am.common
include $(top_srcdir)/src/Makefile.am.features
# The name of the module.
DOC_MODULE=cairo
# The top-level SGML file.
DOC_MAIN_SGML_FILE=cairo-docs.xml
# Extra options to supply to gtkdoc-scan
SCAN_OPTIONS=--deprecated-guards="CAIRO_DISABLE_DEPRECATED" --ignore-decorators="cairo_public|cairo_private"
# The directory containing the source code.
DOC_SOURCE_DIR=$(top_srcdir)/src
# Used for dependencies
HFILE_GLOB=$(top_srcdir)/src/cairo*.h
CFILE_GLOB=$(top_srcdir)/src/cairo*.c
EXTRA_HFILES=$(top_builddir)/src/cairo-supported-features.h
# Headers to ignore
IGNORE_HFILES= \
cairo-features.h \
cairo-features-win32.h \
$(all_cairo_private) \
$(unsupported_cairo_headers) \
$(NULL)
# Extra options to supply to gtkdoc-mkdb
MKDB_OPTIONS=--sgml-mode --output-format=xml --name-space=cairo
# Non-autogenerated SGML files to be included in $(DOC_MAIN_SGML_FILE)
content_files = \
language-bindings.xml \
version.xml \
$(NULL)
version.xml: $(top_srcdir)/src/cairo-version.h
echo $(CAIRO_VERSION_MAJOR).$(CAIRO_VERSION_MINOR).$(CAIRO_VERSION_MICRO) > $@
# Images to copy into HTML directory
HTML_IMAGES =
# Extra options to supply to gtkdoc-fixref
FIXXREF_OPTIONS=
include $(top_srcdir)/build/Makefile.am.gtk-doc
dist-hook: doc
# This line really belongs in gtk-doc.mk
$(REPORT_FILES): sgml-build.stamp
if ENABLE_GTK_DOC
TESTS += check-doc-coverage.sh
endif
TESTS += check-doc-syntax.sh
EXTRA_DIST += check-doc-coverage.sh check-doc-syntax.sh
TESTS_ENVIRONMENT = srcdir="$(srcdir)" top_srcdir="$(top_srcdir)" MAKE="$(MAKE) $(AM_MAKEFLAGS)" DOC_MODULE="$(DOC_MODULE)" REPORT_FILES="$(REPORT_FILES)"

154
perf/Makefile.am
View file

@ -1,154 +0,0 @@
include $(top_srcdir)/build/Makefile.am.common
include $(top_srcdir)/perf/Makefile.sources
AM_CPPFLAGS = \
-I$(srcdir) \
-I$(top_srcdir)/boilerplate \
-I$(top_srcdir)/src \
-I$(top_srcdir)/util/cairo-missing \
-I$(top_srcdir)/util/cairo-script \
-I$(top_builddir)/src \
$(CAIRO_CFLAGS)
AM_LDFLAGS = $(CAIRO_LDFLAGS)
SUBDIRS = micro
noinst_PROGRAMS = \
cairo-analyse-trace \
cairo-perf-trace \
cairo-perf-micro \
$(NULL)
EXTRA_PROGRAMS += \
cairo-analyse-trace \
cairo-perf-micro \
cairo-perf-trace \
cairo-perf-diff-files \
cairo-perf-print \
cairo-perf-chart \
cairo-perf-compare-backends \
cairo-perf-graph-files \
$(NULL)
EXTRA_DIST += cairo-perf-diff COPYING
EXTRA_LTLIBRARIES += libcairoperf.la
LDADD = libcairoperf.la \
$(top_builddir)/boilerplate/libcairoboilerplate.la \
$(top_builddir)/src/libcairo.la
cairo_perf_micro_SOURCES = $(cairo_perf_micro_sources)
cairo_perf_micro_LDADD = \
$(top_builddir)/perf/micro/libcairo-perf-micro.la \
$(LDADD)
cairo_perf_micro_DEPENDENCIES = \
$(top_builddir)/perf/micro/libcairo-perf-micro.la \
$(LDADD)
libcairoperf_la_SOURCES = \
$(libcairoperf_sources) \
$(libcairoperf_external_sources) \
$(libcairoperf_headers) \
$(NULL)
cairo_analyse_trace_SOURCES = \
$(cairo_analyse_trace_sources) \
$(cairo_analyse_trace_external_sources)
cairo_analyse_trace_LDADD = \
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la \
$(top_builddir)/util/cairo-missing/libcairo-missing.la \
$(LDADD)
cairo_analyse_trace_DEPENDENCIES = \
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la \
$(top_builddir)/util/cairo-missing/libcairo-missing.la \
$(LDADD)
cairo_perf_trace_SOURCES = \
$(cairo_perf_trace_sources) \
$(cairo_perf_trace_external_sources)
cairo_perf_trace_LDADD = \
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la \
$(top_builddir)/util/cairo-missing/libcairo-missing.la \
$(LDADD)
cairo_perf_trace_DEPENDENCIES = \
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la \
$(top_builddir)/util/cairo-missing/libcairo-missing.la \
$(LDADD)
cairo_perf_diff_files_SOURCES = $(cairo_perf_diff_files_sources)
cairo_perf_print_SOURCES = $(cairo_perf_print_sources)
cairo_perf_chart_SOURCES = $(cairo_perf_chart_sources)
cairo_perf_compare_backends_SOURCES = $(cairo_perf_compare_backends_sources)
cairo_perf_graph_files_SOURCES = \
$(cairo_perf_graph_files_sources) \
$(cairo_perf_graph_files_headers)
cairo_perf_graph_files_CFLAGS = @gtk_CFLAGS@
cairo_perf_graph_files_LDADD = @gtk_LIBS@ $(LDADD)
# Install rules to rebuild the libraries and add explicit dependencies
$(top_builddir)/perf/micro/libcairo-perf-micro.la:
cd $(top_builddir)/perf/micro && $(MAKE) $(AM_MAKEFLAGS) libcairo-perf-micro.la
$(top_builddir)/boilerplate/libcairoboilerplate.la: $(top_builddir)/src/libcairo.la
cd $(top_builddir)/boilerplate && $(MAKE) $(AM_MAKEFLAGS) libcairoboilerplate.la
$(top_builddir)/src/libcairo.la:
cd $(top_builddir)/src && $(MAKE) $(AM_MAKEFLAGS) libcairo.la
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la: $(top_builddir)/src/libcairo.la
cd $(top_builddir)/util/cairo-script && $(MAKE) $(AM_MAKEFLAGS) libcairo-script-interpreter.la
# Do a funny transition of CAIRO_TEST_TARGET through TARGETS such that
# one can limit tested targets both through CAIRO_TEST_TARGET env var
# and TARGETS make var on the command line. Same for the rest.
TARGETS = $(CAIRO_TEST_TARGET)
TARGETS_EXCLUDE = $(CAIRO_TEST_TARGET_EXCLUDE)
FORMAT = $(CAIRO_TEST_TARGET_FORMAT)
ITERS = $(CAIRO_PERF_ITERATIONS)
CAIRO_PERF_ENVIRONMENT = CAIRO_PERF_ITERATIONS="$(ITERS)" CAIRO_TEST_TARGET="$(TARGETS)" CAIRO_TEST_TARGET_FORMAT="$(FORMAT)" CAIRO_TEST_TARGET_EXCLUDE="$(TARGETS_EXCLUDE)"
perf: cairo-perf-micro$(EXEEXT) cairo-perf-trace$(EXEEXT)
-$(CAIRO_PERF_ENVIRONMENT) ./cairo-perf-micro$(EXEEXT)
-$(CAIRO_PERF_ENVIRONMENT) ./cairo-perf-trace$(EXEEXT)
html-local: index.html
perf-tag.html : cairo-perf-micro${EXEEXT}
$(CAIRO_PERF_ENVIRONMENT) ./cairo-perf-diff -t -h $@ `git describe --abbrev=0` HEAD
perf-commit.html : cairo-perf-micro${EXEEXT}
$(CAIRO_PERF_ENVIRONMENT) ./cairo-perf-diff -t -h $@ HEAD
# Summarise changes in index.html, with details in links
index.html: perf-tag.html perf-commit.html
echo "<html><head><title>Performance Changes</title></head><body>Against <a href=\"perf-tag.html\">"`git describe --abbrev=0`"</a><br><a href=\"perf-commit.html\">Latest commit</a></body>" > $@
EXTRA_VALGRIND_FLAGS = $(CAIRO_EXTRA_VALGRIND_FLAGS)
VALGRIND_MEMCHECK_FLAGS = \
--tool=memcheck \
--suppressions=$(top_srcdir)/test/.valgrind-suppressions \
--leak-check=yes --show-reachable=yes
VALGRIND_CALLGRIND_FLAGS = \
--tool=callgrind
CLEANFILES += \
valgrind-log \
callgrind.out.* \
index.html
perf-valgrind:
$(MAKE) $(AM_MAKEFLAGS) perf \
$(top_builddir)/libtool --mode=execute \
valgrind $(VALGRIND_MEMCHECK_FLAGS) $(EXTRA_VALGRIND_FLAGS)' \
| tee valgrind-log
perf-callgrind:
$(MAKE) $(AM_MAKEFLAGS) perf \
$(top_builddir)/libtool --mode=execute \
valgrind $(VALGRIND_CALLGRIND_FLAGS) $(EXTRA_VALGRIND_FLAGS)'
.PHONY: perf perf-valgrind perf-callgrind
EXTRA_DIST += Makefile.win32

38
perf/Makefile.sources
View file

@ -1,38 +0,0 @@
libcairoperf_sources = \
cairo-perf.c \
cairo-perf-report.c \
cairo-stats.c \
$(NULL)
libcairoperf_external_sources = ../src/cairo-time.c
libcairoperf_headers = \
cairo-perf.h \
cairo-stats.h \
$(NULL)
cairo_analyse_trace_sources = cairo-analyse-trace.c
cairo_analyse_trace_external_sources = ../src/cairo-error.c
cairo_perf_trace_sources = cairo-perf-trace.c
cairo_perf_trace_external_sources = \
../src/cairo-error.c \
../src/cairo-hash.c \
$(NULL)
cairo_perf_micro_sources = cairo-perf-micro.c
cairo_perf_diff_files_sources = cairo-perf-diff-files.c
cairo_perf_print_sources = cairo-perf-print.c
cairo_perf_chart_sources = cairo-perf-chart.c
cairo_perf_compare_backends_sources = cairo-perf-compare-backends.c
cairo_perf_graph_files_sources = \
cairo-perf-graph-files.c \
cairo-perf-graph-widget.c \
$(NULL)
cairo_perf_graph_files_headers = cairo-perf-graph.h

78
perf/Makefile.win32
View file

@ -1,78 +0,0 @@
top_srcdir = ..
include $(top_srcdir)/build/Makefile.win32.common
include $(top_srcdir)/perf/Makefile.sources
CFLAGS += -I$(top_srcdir)/boilerplate -I$(top_srcdir)/util/cairo-script/
PERF_LIBS = \
$(CFG)/libcairoperf.lib \
$(top_builddir)/boilerplate/$(CFG)/boiler.lib \
$(top_builddir)/src/$(CFG)/cairo-static.lib \
$(NULL)
PERF_EXES = \
$(CFG)/cairo-perf-trace.exe \
$(CFG)/cairo-perf-micro.exe \
$(CFG)/cairo-perf-diff-files.exe \
$(CFG)/cairo-perf-print.exe \
$(CFG)/cairo-perf-chart.exe \
$(CFG)/cairo-perf-compare-backends.exe \
$(NULL)
all: inform $(PERF_EXES)
perf: inform $(CFG)/cairo-perf-micro.exe
./$(CFG)/cairo-perf-micro.exe
libcairoperf_OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(libcairoperf_sources))
$(CFG)/libcairoperf.lib: $(libcairoperf_OBJECTS)
@$(AR) $(CAIRO_ARFLAGS) -OUT:$@ $(libcairoperf_OBJECTS)
cairo_perf_trace_OBJECTS = \
$(patsubst %.c, $(CFG)/%-static.obj, $(cairo_perf_trace_sources)) \
$(top_builddir)/util/cairo-script/$(CFG)/libcairo-script-interpreter.lib \
$(NULL)
cairo_perf_micro_OBJECTS = \
$(patsubst %.c, $(CFG)/%-static.obj, $(cairo_perf_micro_sources)) \
./micro/$(CFG)/libcairo-perf-micro.lib \
$(NULL)
cairo_perf_diff_files_OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(cairo_perf_diff_files_sources))
cairo_perf_print_OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(cairo_perf_print_sources))
cairo_perf_chart_OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(cairo_perf_chart_sources))
cairo_perf_compare_backends_OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(cairo_perf_compare_backends_sources))
$(CFG)/cairo-perf-trace.exe: $(cairo_perf_trace_OBJECTS) $(PERF_LIBS)
@$(LD) $(CAIRO_LDFLAGS) -OUT:$@ $(cairo_perf_trace_OBJECTS) $(PERF_LIBS) $(CAIRO_LIBS)
$(CFG)/cairo-perf-micro.exe: $(cairo_perf_micro_OBJECTS) $(PERF_LIBS)
@$(LD) $(CAIRO_LDFLAGS) -OUT:$@ $(cairo_perf_micro_OBJECTS) $(PERF_LIBS) $(CAIRO_LIBS)
$(CFG)/cairo-perf-diff-files.exe: $(cairo_perf_diff_files_OBJECTS) $(PERF_LIBS)
@$(LD) $(CAIRO_LDFLAGS) -OUT:$@ $(cairo_perf_diff_files_OBJECTS) $(PERF_LIBS) $(CAIRO_LIBS)
$(CFG)/cairo-perf-print.exe: $(cairo_perf_print_OBJECTS) $(PERF_LIBS)
@$(LD) $(CAIRO_LDFLAGS) -OUT:$@ $(cairo_perf_print_OBJECTS) $(PERF_LIBS) $(CAIRO_LIBS)
$(CFG)/cairo-perf-chart.exe: $(cairo_perf_chart_OBJECTS) $(PERF_LIBS)
@$(LD) $(CAIRO_LDFLAGS) -OUT:$@ $(cairo_perf_chart_OBJECTS) $(PERF_LIBS) $(CAIRO_LIBS)
$(CFG)/cairo-perf-compare-backends.exe: $(cairo_perf_compare_backends_OBJECTS) $(PERF_LIBS)
@$(LD) $(CAIRO_LDFLAGS) -OUT:$@ $(cairo_perf_compare_backends_OBJECTS) $(PERF_LIBS) $(CAIRO_LIBS)
./micro/$(CFG)/libcairo-perf-micro.lib:
$(MAKE) -C micro -f Makefile.win32
$(top_builddir)/src/$(CFG)/cairo-static.lib:
$(MAKE) -C $(top_srcdir)/src -f Makefile.win32
$(top_builddir)/boilerplate/$(CFG)/boiler.lib:
$(MAKE) -C $(top_srcdir)/boilerplate -f Makefile.win32
$(top_builddir)/util/cairo-script/$(CFG)/libcairo-script-interpreter.lib:
$(MAKE) -C $(top_srcdir)/util/cairo-script -f Makefile.win32

16
perf/micro/Makefile.am
View file

@ -1,16 +0,0 @@
include $(top_srcdir)/build/Makefile.am.common
include $(top_srcdir)/perf/micro/Makefile.sources
noinst_LTLIBRARIES = libcairo-perf-micro.la
libcairo_perf_micro_la_SOURCES = \
$(libcairo_perf_micro_sources) \
$(libcairo_perf_micro_headers)
AM_CPPFLAGS = \
-I$(srcdir) \
-I$(top_srcdir)/boilerplate \
-I$(top_srcdir)/src \
-I$(top_srcdir)/perf \
-I$(top_builddir)/src \
$(CAIRO_CFLAGS)

51
perf/micro/Makefile.sources
View file

@ -1,51 +0,0 @@
libcairo_perf_micro_sources = \
cairo-perf-cover.c \
box-outline.c \
composite-checker.c \
disjoint.c \
fill.c \
hatching.c \
hash-table.c \
line.c \
a1-line.c \
long-lines.c \
mosaic.c \
paint.c \
paint-with-alpha.c \
mask.c \
pattern_create_radial.c \
rectangles.c \
rounded-rectangles.c \
stroke.c \
subimage_copy.c \
tessellate.c \
text.c \
tiger.c \
glyphs.c \
twin.c \
unaligned-clip.c \
wave.c \
world-map.c \
zrusin.c \
long-dashed-lines.c \
dragon.c \
pythagoras-tree.c \
intersections.c \
many-strokes.c \
wide-strokes.c \
many-fills.c \
wide-fills.c \
many-curves.c \
curve.c \
a1-curve.c \
spiral.c \
pixel.c \
sierpinski.c \
fill-clip.c \
$(NULL)
libcairo_perf_micro_headers = \
mosaic.h \
world-map.h \
zrusin-another.h \
$(NULL)

12
perf/micro/Makefile.win32
View file

@ -1,12 +0,0 @@
top_srcdir = ../..
include $(top_srcdir)/build/Makefile.win32.common
include $(top_srcdir)/perf/micro/Makefile.sources
CFLAGS += -I$(top_srcdir)/perf -I$(top_srcdir)/boilerplate/
OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(libcairo_perf_micro_sources))
all: inform $(CFG)/libcairo-perf-micro.lib
$(CFG)/libcairo-perf-micro.lib: $(OBJECTS)
@$(AR) $(CAIRO_ARFLAGS) -OUT:$@ $(OBJECTS)

99
src/Makefile.am
View file

@ -1,99 +0,0 @@
# Note: All source files are listed in Makefile.sources.
include $(top_srcdir)/build/Makefile.am.common
include $(srcdir)/Makefile.am.features
EXTRA_DIST += Makefile.win32 Makefile.win32.features
#MAINTAINERCLEANFILES += $(srcdir)/Makefile.win32.features
AM_CPPFLAGS = -I$(srcdir) $(CAIRO_CFLAGS)
AM_LDFLAGS = $(CAIRO_LDFLAGS)
if OS_WIN32
export_symbols = -export-symbols cairo.def
cairo_def_dependency = cairo.def
endif
$(top_builddir)/config.h: $(top_srcdir)/config.h.in
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) config.h
cairoincludedir = $(includedir)/cairo
cairoinclude_HEADERS = $(enabled_cairo_headers)
lib_LTLIBRARIES = libcairo.la
libcairo_la_SOURCES = \
$(enabled_cairo_headers) \
$(enabled_cairo_private) \
$(enabled_cairo_sources) \
$(NULL)
libcairo_la_LDFLAGS = $(AM_LDFLAGS) -version-info $(CAIRO_LIBTOOL_VERSION_INFO) -no-undefined $(export_symbols)
libcairo_la_LIBADD = $(CAIRO_LIBS)
libcairo_la_DEPENDENCIES = $(cairo_def_dependency)
# Special headers
nodist_cairoinclude_HEADERS = cairo-features.h
nodist_libcairo_la_SOURCES = cairo-features.h
BUILT_SOURCES += cairo-features.h cairo-supported-features.h
DISTCLEANFILES += cairo-features.h cairo-supported-features.h
cairo-features.h cairo-supported-features.h:
cd $(top_builddir) && ./config.status src/$@
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = $(enabled_cairo_pkgconf)
CLEANFILES += cairo.def
cairo.def: cairo-features.h $(enabled_cairo_headers)
@echo Generating $@
@(echo EXPORTS; \
(cd $(srcdir); cat $(enabled_cairo_headers) || echo 'cairo_ERROR ()' ) | \
$(EGREP) -v '^# *include' | \
( cat cairo-features.h - | $(CPP) -D__cplusplus - || echo 'cairo_ERROR ()' ) | \
$(EGREP) '^cairo_.* \(' | \
sed -e 's/[ ].*//' | \
sort; \
echo LIBRARY libcairo-$(CAIRO_VERSION_SONUM).dll; \
) >$@
@ ! grep -q cairo_ERROR $@ || ($(RM) $@; false)
TESTS_ENVIRONMENT = \
srcdir="$(srcdir)" \
MAKE="$(MAKE) $(AM_MAKEFLAGS)" \
all_cairo_files="$(all_cairo_files)" \
all_cairo_headers="$(all_cairo_headers)" \
all_cairo_private="$(all_cairo_private)" \
all_cairo_sources="$(all_cairo_sources)" \
enabled_cairo_headers="$(enabled_cairo_headers)" \
enabled_cairo_private="$(enabled_cairo_private)" \
enabled_cairo_sources="$(enabled_cairo_sources)" \
$(NULL)
TESTS_SH = \
check-def.sh \
check-doc-syntax.sh \
check-headers.sh \
check-plt.sh \
check-preprocessor-syntax.sh \
$(NULL)
TESTS += $(TESTS_SH)
if CROSS_COMPILING
else
TESTS += check-link$(EXEEXT)
endif
EXTRA_DIST += $(TESTS_SH) check-has-hidden-symbols.c check-doc-syntax.awk
check_PROGRAMS += check-link
check_link_LDADD = libcairo.la
check: headers-standalone
PREPROCESS_ARGS = $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS)
COMPILE_ARGS = $(PREPROCESS_ARGS) $(AM_CFLAGS) $(CFLAGS)
# The pre-processed result is used by check-{def,plt}.sh to determine whether
# cairo has been compiled with symbol hiding.
.c.i: $(cairoinclude_HEADERS) $(nodist_cairoinclude_HEADERS) cairoint.h $(top_builddir)/config.h
$(CPP) $(PREPROCESS_ARGS) $< -o $@
.c.s: $(cairoinclude_HEADERS) $(nodist_cairoinclude_HEADERS) cairoint.h $(top_builddir)/config.h
$(CC) $(COMPILE_ARGS) $< -S -o $@
include $(srcdir)/Makefile.am.analysis

35
src/Makefile.am.analysis
View file

@ -1,35 +0,0 @@
SPARSE = sparse
sparse:
@echo Checking enabled sources with sparse checker
@status=true; for f in $(enabled_cairo_sources); do \
echo $(SPARSE) $(PREPROCESS_ARGS) $(srcdir)/$$f; \
$(SPARSE) $(PREPROCESS_ARGS) $(srcdir)/$$f || status=false; \
done; $$status
SPLINT = splint -badflag
splint:
@echo Checking enabled sources with splint checker
@status=true; for f in $(enabled_cairo_sources); do \
echo $(SPLINT) $(PREPROCESS_ARGS) $(srcdir)/$$f; \
$(SPLINT) $(PREPROCESS_ARGS) $(srcdir)/$$f || status=false; \
done; $$status
UNO = uno
uno:
@echo Checking enabled sources with uno checker
cd $(srcdir); $(UNO) $(PREPROCESS_ARGS) -DHAVE_CONFIG_H -U__GNUC__ $(enabled_cairo_sources)
headers-standalone: $(enabled_cairo_headers) $(enabled_cairo_private)
@echo Checking that enabled public/private headers can be compiled standalone
@status=true; for f in $(enabled_cairo_headers) $(enabled_cairo_private); do \
echo " CHECK $$f"; \
echo "#include \"$(srcdir)/$$f\"" > headers-standalone-tmp.c; \
echo "int main(int argc, char * argv[]) { return 0; }" >> headers-standalone-tmp.c; \
$(COMPILE) -o headers-standalone-tmp headers-standalone-tmp.c || status=false; \
$(RM) headers-standalone-tmp headers-standalone-tmp.c; \
done; $$status
@touch $@
CLEANFILES += headers-standalone
analysis: all headers-standalone sparse splint uno

405
src/Makefile.sources
View file

@ -1,405 +0,0 @@
# Makefile.sources
#
# This file is the canonical location listing all the source files used
# to build the cairo library. Every source file is categorized as one of:
#
# * public header file
# * private header file (must end in -private.h except for cairoint.h)
# * source code file
#
# Every source file should be specified exactly once, grouped with the
# feature that uses the source file. If more than one feature use the
# file (like pdf_operators or font_subset files), the files should be
# appended to to the base cairo files, and the code inside them
# enabled/disabled using C preprocessor macros defined in cairoint.h.
# See how pdf_operators or font_subset are handled.
#
# The sources are picked up according to the configured features
# by the generated file Makefile.am.features or Makefile.win32.features.
#
# These are a few special source files. Those are not included in this
# file to not confuse build systems. Each build system must handle them
# separately. These files include:
#
# * cairo-features.h:
# This file is generated by configure and includes macros signifying
# which features are enabled. This file should be installed like
# other public headers, but should NOT be distributed in the cairo
# distribution.
#
# * cairo-supported-features.h:
# This file is generated by configure and includes macros signifying
# all supported features. This is used by gtk-doc to generate
# documentation for all those macros, enabled or not.
# This file is NOT used during the build of the library and should
# NOT be installed or distributed.
#
# Please follow the strict syntax of this file, including keeping file
# lists sorted.
#
cairo_headers = cairo.h cairo-version.h cairo-deprecated.h
cairo_private = \
cairoint.h \
cairo-analysis-surface-private.h \
cairo-arc-private.h \
cairo-array-private.h \
cairo-atomic-private.h \
cairo-backend-private.h \
cairo-box-inline.h \
cairo-boxes-private.h \
cairo-cache-private.h \
cairo-clip-inline.h \
cairo-clip-private.h \
cairo-combsort-inline.h \
cairo-compiler-private.h \
cairo-composite-rectangles-private.h \
cairo-compositor-private.h \
cairo-contour-inline.h \
cairo-contour-private.h \
cairo-damage-private.h \
cairo-default-context-private.h \
cairo-device-private.h \
cairo-error-inline.h \
cairo-error-private.h \
cairo-fixed-private.h \
cairo-fixed-type-private.h \
cairo-fontconfig-private.h \
cairo-freed-pool-private.h \
cairo-freelist-private.h \
cairo-freelist-type-private.h \
cairo-gstate-private.h \
cairo-hash-private.h \
cairo-image-info-private.h \
cairo-image-surface-inline.h \
cairo-image-surface-private.h \
cairo-line-inline.h \
cairo-line-private.h \
cairo-list-inline.h \
cairo-list-private.h \
cairo-malloc-private.h \
cairo-mempool-private.h \
cairo-mutex-impl-private.h \
cairo-mutex-list-private.h \
cairo-mutex-private.h \
cairo-mutex-type-private.h \
cairo-output-stream-private.h \
cairo-paginated-private.h \
cairo-paginated-surface-private.h \
cairo-path-fixed-private.h \
cairo-path-private.h \
cairo-pattern-inline.h \
cairo-pattern-private.h \
cairo-pixman-private.h \
cairo-private.h \
cairo-recording-surface-inline.h \
cairo-recording-surface-private.h \
cairo-reference-count-private.h \
cairo-region-private.h \
cairo-rtree-private.h \
cairo-scaled-font-private.h \
cairo-slope-private.h \
cairo-spans-compositor-private.h \
cairo-spans-private.h \
cairo-stroke-dash-private.h \
cairo-surface-backend-private.h \
cairo-surface-clipper-private.h \
cairo-surface-fallback-private.h \
cairo-surface-inline.h \
cairo-surface-observer-inline.h \
cairo-surface-observer-private.h \
cairo-surface-offset-private.h \
cairo-surface-private.h \
cairo-surface-snapshot-inline.h \
cairo-surface-snapshot-private.h \
cairo-surface-subsurface-inline.h \
cairo-surface-subsurface-private.h \
cairo-surface-wrapper-private.h \
cairo-time-private.h \
cairo-traps-private.h \
cairo-tristrip-private.h \
cairo-types-private.h \
cairo-user-font-private.h \
cairo-wideint-private.h \
cairo-wideint-type-private.h \
$(NULL)
cairo_sources = \
cairo-analysis-surface.c \
cairo-arc.c \
cairo-array.c \
cairo-atomic.c \
cairo-base64-stream.c \
cairo-base85-stream.c \
cairo-bentley-ottmann-rectangular.c \
cairo-bentley-ottmann-rectilinear.c \
cairo-bentley-ottmann.c \
cairo-botor-scan-converter.c \
cairo-boxes-intersect.c \
cairo-boxes.c \
cairo-cache.c \
cairo-clip-boxes.c \
cairo-clip-polygon.c \
cairo-clip-region.c \
cairo-clip-surface.c \
cairo-clip-tor-scan-converter.c \
cairo-clip.c \
cairo-color.c \
cairo-composite-rectangles.c \
cairo-compositor.c \
cairo-contour.c \
cairo-damage.c \
cairo-debug.c \
cairo-default-context.c \
cairo-device.c \
cairo-error.c \
cairo-fallback-compositor.c \
cairo-fixed.c \
cairo-font-face-twin-data.c \
cairo-font-face-twin.c \
cairo-font-face.c \
cairo-font-options.c \
cairo-freed-pool.c \
cairo-freelist.c \
cairo-gstate.c \
cairo-hash.c \
cairo-hull.c \
cairo-image-compositor.c \
cairo-image-info.c \
cairo-image-source.c \
cairo-image-surface.c \
cairo-line.c \
cairo-lzw.c \
cairo-mask-compositor.c \
cairo-matrix.c \
cairo-mempool.c \
cairo-mesh-pattern-rasterizer.c \
cairo-misc.c \
cairo-mono-scan-converter.c \
cairo-mutex.c \
cairo-no-compositor.c \
cairo-observer.c \
cairo-output-stream.c \
cairo-paginated-surface.c \
cairo-path-bounds.c \
cairo-path-fill.c \
cairo-path-fixed.c \
cairo-path-in-fill.c \
cairo-path-stroke-boxes.c \
cairo-path-stroke-polygon.c \
cairo-path-stroke-traps.c \
cairo-path-stroke-tristrip.c \
cairo-path-stroke.c \
cairo-path.c \
cairo-pattern.c \
cairo-pen.c \
cairo-polygon-intersect.c \
cairo-polygon-reduce.c \
cairo-polygon.c \
cairo-raster-source-pattern.c \
cairo-recording-surface.c \
cairo-rectangle.c \
cairo-rectangular-scan-converter.c \
cairo-region.c \
cairo-rtree.c \
cairo-scaled-font.c \
cairo-shape-mask-compositor.c \
cairo-slope.c \
cairo-spans-compositor.c \
cairo-spans.c \
cairo-spline.c \
cairo-stroke-dash.c \
cairo-stroke-style.c \
cairo-surface-clipper.c \
cairo-surface-fallback.c \
cairo-surface-observer.c \
cairo-surface-offset.c \
cairo-surface-snapshot.c \
cairo-surface-subsurface.c \
cairo-surface-wrapper.c \
cairo-surface.c \
cairo-time.c \
cairo-tor-scan-converter.c \
cairo-tor22-scan-converter.c \
cairo-toy-font-face.c \
cairo-traps-compositor.c \
cairo-traps.c \
cairo-tristrip.c \
cairo-unicode.c \
cairo-user-font.c \
cairo-version.c \
cairo-wideint.c \
cairo.c \
$(NULL)
_cairo_font_subset_private = \
cairo-scaled-font-subsets-private.h \
cairo-truetype-subset-private.h \
cairo-type1-private.h \
cairo-type3-glyph-surface-private.h \
$(NULL)
_cairo_font_subset_sources = \
cairo-cff-subset.c \
cairo-scaled-font-subsets.c \
cairo-truetype-subset.c \
cairo-type1-fallback.c \
cairo-type1-glyph-names.c \
cairo-type1-subset.c \
cairo-type3-glyph-surface.c \
$(NULL)
cairo_private += $(_cairo_font_subset_private)
cairo_sources += $(_cairo_font_subset_sources)
cairo_egl_sources =
cairo_glx_sources =
cairo_wgl_sources =
_cairo_pdf_operators_private = \
cairo-pdf-operators-private.h \
cairo-pdf-shading-private.h \
cairo-tag-attributes-private.h \
$(NULL)
_cairo_pdf_operators_sources = \
cairo-pdf-operators.c \
cairo-pdf-shading.c \
cairo-tag-attributes.c \
$(NULL)
cairo_private += $(_cairo_pdf_operators_private)
cairo_sources += $(_cairo_pdf_operators_sources)
cairo_png_sources = cairo-png.c
cairo_ps_headers = cairo-ps.h
cairo_ps_private = cairo-ps-surface-private.h
cairo_ps_sources = cairo-ps-surface.c
_cairo_deflate_stream_sources = cairo-deflate-stream.c
cairo_sources += $(_cairo_deflate_stream_sources)
cairo_pdf_headers = cairo-pdf.h
cairo_pdf_private = cairo-pdf-surface-private.h cairo-tag-stack-private.h
cairo_pdf_sources = cairo-pdf-surface.c cairo-pdf-interchange.c cairo-tag-stack.c
cairo_svg_headers = cairo-svg.h
cairo_svg_private = cairo-svg-surface-private.h
cairo_svg_sources = cairo-svg-surface.c
cairo_ft_headers = cairo-ft.h
cairo_ft_private = cairo-ft-private.h
cairo_ft_sources = cairo-ft-font.c cairo-svg-glyph-render.c
# These are private, even though they look like public headers
cairo_test_surfaces_private = \
test-compositor-surface.h \
test-compositor-surface-private.h \
test-null-compositor-surface.h \
test-paginated-surface.h \
$(NULL)
cairo_test_surfaces_sources = \
test-compositor-surface.c \
test-null-compositor-surface.c \
test-base-compositor-surface.c \
test-paginated-surface.c \
$(NULL)
cairo_xlib_headers = cairo-xlib.h
cairo_xlib_private = \
cairo-xlib-private.h \
cairo-xlib-surface-private.h \
cairo-xlib-xrender-private.h \
$(NULL)
cairo_xlib_sources = \
cairo-xlib-display.c \
cairo-xlib-core-compositor.c \
cairo-xlib-fallback-compositor.c \
cairo-xlib-render-compositor.c \
cairo-xlib-screen.c \
cairo-xlib-source.c \
cairo-xlib-surface.c \
cairo-xlib-surface-shm.c \
cairo-xlib-visual.c \
cairo-xlib-xcb-surface.c \
$(NULL)
cairo_xlib_xrender_headers = cairo-xlib-xrender.h
cairo_xcb_headers = cairo-xcb.h
cairo_xcb_private = cairo-xcb-private.h
cairo_xcb_sources = \
cairo-xcb-connection.c \
cairo-xcb-connection-core.c \
cairo-xcb-connection-render.c \
cairo-xcb-connection-shm.c \
cairo-xcb-screen.c \
cairo-xcb-shm.c \
cairo-xcb-surface.c \
cairo-xcb-surface-core.c \
cairo-xcb-surface-render.c \
cairo-xcb-resources.c \
$(NULL)
cairo_quartz_headers = cairo-quartz.h
cairo_quartz_private = cairo-quartz-private.h
cairo_quartz_sources = cairo-quartz-surface.c
cairo_quartz_image_headers = cairo-quartz-image.h
cairo_quartz_image_sources = cairo-quartz-image-surface.c
cairo_quartz_font_sources = cairo-quartz-font.c
cairo_win32_headers = cairo-win32.h
cairo_win32_private = win32/cairo-win32-private.h
cairo_win32_sources = \
win32/cairo-win32-debug.c \
win32/cairo-win32-device.c \
win32/cairo-win32-gdi-compositor.c \
win32/cairo-win32-system.c \
win32/cairo-win32-surface.c \
win32/cairo-win32-display-surface.c \
win32/cairo-win32-printing-surface.c \
$(NULL)
cairo_win32_font_sources = \
win32/cairo-win32-font.c \
$(NULL)
cairo_gl_headers = cairo-gl.h
cairo_gl_private = cairo-gl-private.h \
cairo-gl-dispatch-private.h \
cairo-gl-ext-def-private.h \
cairo-gl-gradient-private.h
cairo_gl_sources = cairo-gl-composite.c \
cairo-gl-device.c \
cairo-gl-dispatch.c \
cairo-gl-glyphs.c \
cairo-gl-gradient.c \
cairo-gl-info.c \
cairo-gl-msaa-compositor.c \
cairo-gl-operand.c \
cairo-gl-shaders.c \
cairo-gl-source.c \
cairo-gl-spans-compositor.c \
cairo-gl-surface.c \
cairo-gl-traps-compositor.c
cairo_glesv2_headers = $(cairo_gl_headers)
cairo_glesv2_private = $(cairo_gl_private)
cairo_glesv2_sources = $(cairo_gl_sources)
cairo_glesv3_headers = $(cairo_gl_headers)
cairo_glesv3_private = $(cairo_gl_private)
cairo_glesv3_sources = $(cairo_gl_sources)
cairo_egl_sources += cairo-egl-context.c
cairo_glx_sources += cairo-glx-context.c
cairo_wgl_sources += cairo-wgl-context.c
cairo_script_headers = cairo-script.h
cairo_script_private = cairo-script-private.h
cairo_script_sources = cairo-script-surface.c
cairo_tee_headers = cairo-tee.h
cairo_tee_private = cairo-tee-surface-private.h
cairo_tee_sources = cairo-tee-surface.c
cairo_xml_headers = cairo-xml.h
cairo_xml_sources = cairo-xml-surface.c

28
src/Makefile.win32
View file

@ -1,28 +0,0 @@
top_srcdir = ..
include $(top_srcdir)/build/Makefile.win32.common
include Makefile.win32.features
SOURCES = $(enabled_cairo_sources)
STATIC_SOURCES = cairo-system.c
OBJECTS = $(patsubst %.c, $(CFG)/%.obj, $(SOURCES))
OBJECTS_STATIC = $(patsubst %cairo-system.obj, %cairo-system-static.obj, $(OBJECTS))
static: inform $(CFG)/cairo-static.lib
dynamic: inform $(CFG)/cairo.dll
$(CFG)/cairo.dll: $(OBJECTS)
@$(LD) $(CAIRO_LDFLAGS) -DLL -OUT:$@ $(CAIRO_LIBS) $(PIXMAN_LIBS) $(OBJECTS)
$(CFG)/cairo-static.lib: $(OBJECTS_STATIC)
@$(AR) $(CAIRO_ARFLAGS) -OUT:$@ $(PIXMAN_LIBS) $(OBJECTS_STATIC)
all: inform $(CFG)/cairo.dll $(CFG)/cairo-static.lib
@echo "Built successfully!"
@echo "You should copy the following files to a proper place now:"
@echo ""
@echo " src/cairo-features.h"
@for x in $(enabled_cairo_headers); do echo " src/$$x"; done
@echo " src/$(CFG)/cairo.dll"
@echo " src/$(CFG)/cairo-static.lib"

459
src/Makefile.win32.features
View file

@ -1,459 +0,0 @@
# Generated by configure. Do not edit.
ifeq ($(top_srcdir),)
include Makefile.sources
else
include $(top_srcdir)/src/Makefile.sources
endif
supported_cairo_headers = $(cairo_headers)
unsupported_cairo_headers =
all_cairo_headers = $(cairo_headers)
all_cairo_private = $(cairo_private)
all_cairo_sources = $(cairo_sources)
enabled_cairo_headers = $(cairo_headers)
enabled_cairo_private = $(cairo_private)
enabled_cairo_sources = $(cairo_sources)
all_cairo_pkgconf = cairo.pc
enabled_cairo_pkgconf = cairo.pc
supported_cairo_headers += $(cairo_xlib_headers)
all_cairo_headers += $(cairo_xlib_headers)
all_cairo_private += $(cairo_xlib_private)
all_cairo_sources += $(cairo_xlib_sources)
ifeq ($(CAIRO_HAS_XLIB_SURFACE),1)
enabled_cairo_headers += $(cairo_xlib_headers)
enabled_cairo_private += $(cairo_xlib_private)
enabled_cairo_sources += $(cairo_xlib_sources)
endif
all_cairo_pkgconf += cairo-xlib.pc
ifeq ($(CAIRO_HAS_XLIB_SURFACE),1)
enabled_cairo_pkgconf += cairo-xlib.pc
endif
supported_cairo_headers += $(cairo_xlib_xrender_headers)
all_cairo_headers += $(cairo_xlib_xrender_headers)
all_cairo_private += $(cairo_xlib_xrender_private)
all_cairo_sources += $(cairo_xlib_xrender_sources)
ifeq ($(CAIRO_HAS_XLIB_XRENDER_SURFACE),1)
enabled_cairo_headers += $(cairo_xlib_xrender_headers)
enabled_cairo_private += $(cairo_xlib_xrender_private)
enabled_cairo_sources += $(cairo_xlib_xrender_sources)
endif
all_cairo_pkgconf += cairo-xlib-xrender.pc
ifeq ($(CAIRO_HAS_XLIB_XRENDER_SURFACE),1)
enabled_cairo_pkgconf += cairo-xlib-xrender.pc
endif
supported_cairo_headers += $(cairo_xcb_headers)
all_cairo_headers += $(cairo_xcb_headers)
all_cairo_private += $(cairo_xcb_private)
all_cairo_sources += $(cairo_xcb_sources)
ifeq ($(CAIRO_HAS_XCB_SURFACE),1)
enabled_cairo_headers += $(cairo_xcb_headers)
enabled_cairo_private += $(cairo_xcb_private)
enabled_cairo_sources += $(cairo_xcb_sources)
endif
all_cairo_pkgconf += cairo-xcb.pc
ifeq ($(CAIRO_HAS_XCB_SURFACE),1)
enabled_cairo_pkgconf += cairo-xcb.pc
endif
unsupported_cairo_headers += $(cairo_xlib_xcb_headers)
all_cairo_headers += $(cairo_xlib_xcb_headers)
all_cairo_private += $(cairo_xlib_xcb_private)
all_cairo_sources += $(cairo_xlib_xcb_sources)
ifeq ($(CAIRO_HAS_XLIB_XCB_FUNCTIONS),1)
enabled_cairo_headers += $(cairo_xlib_xcb_headers)
enabled_cairo_private += $(cairo_xlib_xcb_private)
enabled_cairo_sources += $(cairo_xlib_xcb_sources)
endif
all_cairo_pkgconf += cairo-xlib-xcb.pc
ifeq ($(CAIRO_HAS_XLIB_XCB_FUNCTIONS),1)
enabled_cairo_pkgconf += cairo-xlib-xcb.pc
endif
supported_cairo_headers += $(cairo_xcb_shm_headers)
all_cairo_headers += $(cairo_xcb_shm_headers)
all_cairo_private += $(cairo_xcb_shm_private)
all_cairo_sources += $(cairo_xcb_shm_sources)
ifeq ($(CAIRO_HAS_XCB_SHM_FUNCTIONS),1)
enabled_cairo_headers += $(cairo_xcb_shm_headers)
enabled_cairo_private += $(cairo_xcb_shm_private)
enabled_cairo_sources += $(cairo_xcb_shm_sources)
endif
all_cairo_pkgconf += cairo-xcb-shm.pc
ifeq ($(CAIRO_HAS_XCB_SHM_FUNCTIONS),1)
enabled_cairo_pkgconf += cairo-xcb-shm.pc
endif
supported_cairo_headers += $(cairo_quartz_headers)
all_cairo_headers += $(cairo_quartz_headers)
all_cairo_private += $(cairo_quartz_private)
all_cairo_sources += $(cairo_quartz_sources)
ifeq ($(CAIRO_HAS_QUARTZ_SURFACE),1)
enabled_cairo_headers += $(cairo_quartz_headers)
enabled_cairo_private += $(cairo_quartz_private)
enabled_cairo_sources += $(cairo_quartz_sources)
endif
all_cairo_pkgconf += cairo-quartz.pc
ifeq ($(CAIRO_HAS_QUARTZ_SURFACE),1)
enabled_cairo_pkgconf += cairo-quartz.pc
endif
supported_cairo_headers += $(cairo_quartz_font_headers)
all_cairo_headers += $(cairo_quartz_font_headers)
all_cairo_private += $(cairo_quartz_font_private)
all_cairo_sources += $(cairo_quartz_font_sources)
ifeq ($(CAIRO_HAS_QUARTZ_FONT),1)
enabled_cairo_headers += $(cairo_quartz_font_headers)
enabled_cairo_private += $(cairo_quartz_font_private)
enabled_cairo_sources += $(cairo_quartz_font_sources)
endif
all_cairo_pkgconf += cairo-quartz-font.pc
ifeq ($(CAIRO_HAS_QUARTZ_FONT),1)
enabled_cairo_pkgconf += cairo-quartz-font.pc
endif
unsupported_cairo_headers += $(cairo_quartz_image_headers)
all_cairo_headers += $(cairo_quartz_image_headers)
all_cairo_private += $(cairo_quartz_image_private)
all_cairo_sources += $(cairo_quartz_image_sources)
ifeq ($(CAIRO_HAS_QUARTZ_IMAGE_SURFACE),1)
enabled_cairo_headers += $(cairo_quartz_image_headers)
enabled_cairo_private += $(cairo_quartz_image_private)
enabled_cairo_sources += $(cairo_quartz_image_sources)
endif
all_cairo_pkgconf += cairo-quartz-image.pc
ifeq ($(CAIRO_HAS_QUARTZ_IMAGE_SURFACE),1)
enabled_cairo_pkgconf += cairo-quartz-image.pc
endif
supported_cairo_headers += $(cairo_win32_headers)
all_cairo_headers += $(cairo_win32_headers)
all_cairo_private += $(cairo_win32_private)
all_cairo_sources += $(cairo_win32_sources)
ifeq ($(CAIRO_HAS_WIN32_SURFACE),1)
enabled_cairo_headers += $(cairo_win32_headers)
enabled_cairo_private += $(cairo_win32_private)
enabled_cairo_sources += $(cairo_win32_sources)
endif
all_cairo_pkgconf += cairo-win32.pc
ifeq ($(CAIRO_HAS_WIN32_SURFACE),1)
enabled_cairo_pkgconf += cairo-win32.pc
endif
supported_cairo_headers += $(cairo_win32_font_headers)
all_cairo_headers += $(cairo_win32_font_headers)
all_cairo_private += $(cairo_win32_font_private)
all_cairo_sources += $(cairo_win32_font_sources)
ifeq ($(CAIRO_HAS_WIN32_FONT),1)
enabled_cairo_headers += $(cairo_win32_font_headers)
enabled_cairo_private += $(cairo_win32_font_private)
enabled_cairo_sources += $(cairo_win32_font_sources)
endif
all_cairo_pkgconf += cairo-win32-font.pc
ifeq ($(CAIRO_HAS_WIN32_FONT),1)
enabled_cairo_pkgconf += cairo-win32-font.pc
endif
supported_cairo_headers += $(cairo_png_headers)
all_cairo_headers += $(cairo_png_headers)
all_cairo_private += $(cairo_png_private)
all_cairo_sources += $(cairo_png_sources)
ifeq ($(CAIRO_HAS_PNG_FUNCTIONS),1)
enabled_cairo_headers += $(cairo_png_headers)
enabled_cairo_private += $(cairo_png_private)
enabled_cairo_sources += $(cairo_png_sources)
endif
all_cairo_pkgconf += cairo-png.pc
ifeq ($(CAIRO_HAS_PNG_FUNCTIONS),1)
enabled_cairo_pkgconf += cairo-png.pc
endif
unsupported_cairo_headers += $(cairo_gl_headers)
all_cairo_headers += $(cairo_gl_headers)
all_cairo_private += $(cairo_gl_private)
all_cairo_sources += $(cairo_gl_sources)
ifeq ($(CAIRO_HAS_GL_SURFACE),1)
enabled_cairo_headers += $(cairo_gl_headers)
enabled_cairo_private += $(cairo_gl_private)
enabled_cairo_sources += $(cairo_gl_sources)
endif
all_cairo_pkgconf += cairo-gl.pc
ifeq ($(CAIRO_HAS_GL_SURFACE),1)
enabled_cairo_pkgconf += cairo-gl.pc
endif
unsupported_cairo_headers += $(cairo_glesv2_headers)
all_cairo_headers += $(cairo_glesv2_headers)
all_cairo_private += $(cairo_glesv2_private)
all_cairo_sources += $(cairo_glesv2_sources)
ifeq ($(CAIRO_HAS_GLESV2_SURFACE),1)
enabled_cairo_headers += $(cairo_glesv2_headers)
enabled_cairo_private += $(cairo_glesv2_private)
enabled_cairo_sources += $(cairo_glesv2_sources)
endif
all_cairo_pkgconf += cairo-glesv2.pc
ifeq ($(CAIRO_HAS_GLESV2_SURFACE),1)
enabled_cairo_pkgconf += cairo-glesv2.pc
endif
unsupported_cairo_headers += $(cairo_glesv3_headers)
all_cairo_headers += $(cairo_glesv3_headers)
all_cairo_private += $(cairo_glesv3_private)
all_cairo_sources += $(cairo_glesv3_sources)
ifeq ($(CAIRO_HAS_GLESV3_SURFACE),1)
enabled_cairo_headers += $(cairo_glesv3_headers)
enabled_cairo_private += $(cairo_glesv3_private)
enabled_cairo_sources += $(cairo_glesv3_sources)
endif
all_cairo_pkgconf += cairo-glesv3.pc
ifeq ($(CAIRO_HAS_GLESV3_SURFACE),1)
enabled_cairo_pkgconf += cairo-glesv3.pc
endif
supported_cairo_headers += $(cairo_egl_headers)
all_cairo_headers += $(cairo_egl_headers)
all_cairo_private += $(cairo_egl_private)
all_cairo_sources += $(cairo_egl_sources)
ifeq ($(CAIRO_HAS_EGL_FUNCTIONS),1)
enabled_cairo_headers += $(cairo_egl_headers)
enabled_cairo_private += $(cairo_egl_private)
enabled_cairo_sources += $(cairo_egl_sources)
endif
all_cairo_pkgconf += cairo-egl.pc
ifeq ($(CAIRO_HAS_EGL_FUNCTIONS),1)
enabled_cairo_pkgconf += cairo-egl.pc
endif
supported_cairo_headers += $(cairo_glx_headers)
all_cairo_headers += $(cairo_glx_headers)
all_cairo_private += $(cairo_glx_private)
all_cairo_sources += $(cairo_glx_sources)
ifeq ($(CAIRO_HAS_GLX_FUNCTIONS),1)
enabled_cairo_headers += $(cairo_glx_headers)
enabled_cairo_private += $(cairo_glx_private)
enabled_cairo_sources += $(cairo_glx_sources)
endif
all_cairo_pkgconf += cairo-glx.pc
ifeq ($(CAIRO_HAS_GLX_FUNCTIONS),1)
enabled_cairo_pkgconf += cairo-glx.pc
endif
supported_cairo_headers += $(cairo_wgl_headers)
all_cairo_headers += $(cairo_wgl_headers)
all_cairo_private += $(cairo_wgl_private)
all_cairo_sources += $(cairo_wgl_sources)
ifeq ($(CAIRO_HAS_WGL_FUNCTIONS),1)
enabled_cairo_headers += $(cairo_wgl_headers)
enabled_cairo_private += $(cairo_wgl_private)
enabled_cairo_sources += $(cairo_wgl_sources)
endif
all_cairo_pkgconf += cairo-wgl.pc
ifeq ($(CAIRO_HAS_WGL_FUNCTIONS),1)
enabled_cairo_pkgconf += cairo-wgl.pc
endif
supported_cairo_headers += $(cairo_script_headers)
all_cairo_headers += $(cairo_script_headers)
all_cairo_private += $(cairo_script_private)
all_cairo_sources += $(cairo_script_sources)
ifeq ($(CAIRO_HAS_SCRIPT_SURFACE),1)
enabled_cairo_headers += $(cairo_script_headers)
enabled_cairo_private += $(cairo_script_private)
enabled_cairo_sources += $(cairo_script_sources)
endif
all_cairo_pkgconf += cairo-script.pc
ifeq ($(CAIRO_HAS_SCRIPT_SURFACE),1)
enabled_cairo_pkgconf += cairo-script.pc
endif
supported_cairo_headers += $(cairo_ft_headers)
all_cairo_headers += $(cairo_ft_headers)
all_cairo_private += $(cairo_ft_private)
all_cairo_sources += $(cairo_ft_sources)
ifeq ($(CAIRO_HAS_FT_FONT),1)
enabled_cairo_headers += $(cairo_ft_headers)
enabled_cairo_private += $(cairo_ft_private)
enabled_cairo_sources += $(cairo_ft_sources)
endif
all_cairo_pkgconf += cairo-ft.pc
ifeq ($(CAIRO_HAS_FT_FONT),1)
enabled_cairo_pkgconf += cairo-ft.pc
endif
supported_cairo_headers += $(cairo_fc_headers)
all_cairo_headers += $(cairo_fc_headers)
all_cairo_private += $(cairo_fc_private)
all_cairo_sources += $(cairo_fc_sources)
ifeq ($(CAIRO_HAS_FC_FONT),1)
enabled_cairo_headers += $(cairo_fc_headers)
enabled_cairo_private += $(cairo_fc_private)
enabled_cairo_sources += $(cairo_fc_sources)
endif
all_cairo_pkgconf += cairo-fc.pc
ifeq ($(CAIRO_HAS_FC_FONT),1)
enabled_cairo_pkgconf += cairo-fc.pc
endif
supported_cairo_headers += $(cairo_ps_headers)
all_cairo_headers += $(cairo_ps_headers)
all_cairo_private += $(cairo_ps_private)
all_cairo_sources += $(cairo_ps_sources)
ifeq ($(CAIRO_HAS_PS_SURFACE),1)
enabled_cairo_headers += $(cairo_ps_headers)
enabled_cairo_private += $(cairo_ps_private)
enabled_cairo_sources += $(cairo_ps_sources)
endif
all_cairo_pkgconf += cairo-ps.pc
ifeq ($(CAIRO_HAS_PS_SURFACE),1)
enabled_cairo_pkgconf += cairo-ps.pc
endif
supported_cairo_headers += $(cairo_pdf_headers)
all_cairo_headers += $(cairo_pdf_headers)
all_cairo_private += $(cairo_pdf_private)
all_cairo_sources += $(cairo_pdf_sources)
ifeq ($(CAIRO_HAS_PDF_SURFACE),1)
enabled_cairo_headers += $(cairo_pdf_headers)
enabled_cairo_private += $(cairo_pdf_private)
enabled_cairo_sources += $(cairo_pdf_sources)
endif
all_cairo_pkgconf += cairo-pdf.pc
ifeq ($(CAIRO_HAS_PDF_SURFACE),1)
enabled_cairo_pkgconf += cairo-pdf.pc
endif
supported_cairo_headers += $(cairo_svg_headers)
all_cairo_headers += $(cairo_svg_headers)
all_cairo_private += $(cairo_svg_private)
all_cairo_sources += $(cairo_svg_sources)
ifeq ($(CAIRO_HAS_SVG_SURFACE),1)
enabled_cairo_headers += $(cairo_svg_headers)
enabled_cairo_private += $(cairo_svg_private)
enabled_cairo_sources += $(cairo_svg_sources)
endif
all_cairo_pkgconf += cairo-svg.pc
ifeq ($(CAIRO_HAS_SVG_SURFACE),1)
enabled_cairo_pkgconf += cairo-svg.pc
endif
all_cairo_private += $(cairo_test_surfaces_private) $(cairo_test_surfaces_headers)
all_cairo_sources += $(cairo_test_surfaces_sources)
ifeq ($(CAIRO_HAS_TEST_SURFACES),1)
enabled_cairo_private += $(cairo_test_surfaces_private) $(cairo_test_surfaces_headers)
enabled_cairo_sources += $(cairo_test_surfaces_sources)
endif
supported_cairo_headers += $(cairo_image_headers)
all_cairo_headers += $(cairo_image_headers)
all_cairo_private += $(cairo_image_private)
all_cairo_sources += $(cairo_image_sources)
enabled_cairo_headers += $(cairo_image_headers)
enabled_cairo_private += $(cairo_image_private)
enabled_cairo_sources += $(cairo_image_sources)
supported_cairo_headers += $(cairo_mime_headers)
all_cairo_headers += $(cairo_mime_headers)
all_cairo_private += $(cairo_mime_private)
all_cairo_sources += $(cairo_mime_sources)
enabled_cairo_headers += $(cairo_mime_headers)
enabled_cairo_private += $(cairo_mime_private)
enabled_cairo_sources += $(cairo_mime_sources)
supported_cairo_headers += $(cairo_recording_headers)
all_cairo_headers += $(cairo_recording_headers)
all_cairo_private += $(cairo_recording_private)
all_cairo_sources += $(cairo_recording_sources)
enabled_cairo_headers += $(cairo_recording_headers)
enabled_cairo_private += $(cairo_recording_private)
enabled_cairo_sources += $(cairo_recording_sources)
supported_cairo_headers += $(cairo_observer_headers)
all_cairo_headers += $(cairo_observer_headers)
all_cairo_private += $(cairo_observer_private)
all_cairo_sources += $(cairo_observer_sources)
enabled_cairo_headers += $(cairo_observer_headers)
enabled_cairo_private += $(cairo_observer_private)
enabled_cairo_sources += $(cairo_observer_sources)
unsupported_cairo_headers += $(cairo_tee_headers)
all_cairo_headers += $(cairo_tee_headers)
all_cairo_private += $(cairo_tee_private)
all_cairo_sources += $(cairo_tee_sources)
ifeq ($(CAIRO_HAS_TEE_SURFACE),1)
enabled_cairo_headers += $(cairo_tee_headers)
enabled_cairo_private += $(cairo_tee_private)
enabled_cairo_sources += $(cairo_tee_sources)
endif
all_cairo_pkgconf += cairo-tee.pc
ifeq ($(CAIRO_HAS_TEE_SURFACE),1)
enabled_cairo_pkgconf += cairo-tee.pc
endif
unsupported_cairo_headers += $(cairo_xml_headers)
all_cairo_headers += $(cairo_xml_headers)
all_cairo_private += $(cairo_xml_private)
all_cairo_sources += $(cairo_xml_sources)
ifeq ($(CAIRO_HAS_XML_SURFACE),1)
enabled_cairo_headers += $(cairo_xml_headers)
enabled_cairo_private += $(cairo_xml_private)
enabled_cairo_sources += $(cairo_xml_sources)
endif
all_cairo_pkgconf += cairo-xml.pc
ifeq ($(CAIRO_HAS_XML_SURFACE),1)
enabled_cairo_pkgconf += cairo-xml.pc
endif
supported_cairo_headers += $(cairo_user_headers)
all_cairo_headers += $(cairo_user_headers)
all_cairo_private += $(cairo_user_private)
all_cairo_sources += $(cairo_user_sources)
enabled_cairo_headers += $(cairo_user_headers)
enabled_cairo_private += $(cairo_user_private)
enabled_cairo_sources += $(cairo_user_sources)
all_cairo_private += $(cairo_pthread_private) $(cairo_pthread_headers)
all_cairo_sources += $(cairo_pthread_sources)
ifeq ($(CAIRO_HAS_PTHREAD),1)
enabled_cairo_private += $(cairo_pthread_private) $(cairo_pthread_headers)
enabled_cairo_sources += $(cairo_pthread_sources)
endif
supported_cairo_headers += $(cairo_gobject_headers)
all_cairo_headers += $(cairo_gobject_headers)
all_cairo_private += $(cairo_gobject_private)
all_cairo_sources += $(cairo_gobject_sources)
ifeq ($(CAIRO_HAS_GOBJECT_FUNCTIONS),1)
enabled_cairo_headers += $(cairo_gobject_headers)
enabled_cairo_private += $(cairo_gobject_private)
enabled_cairo_sources += $(cairo_gobject_sources)
endif
all_cairo_pkgconf += cairo-gobject.pc
ifeq ($(CAIRO_HAS_GOBJECT_FUNCTIONS),1)
enabled_cairo_pkgconf += cairo-gobject.pc
endif
all_cairo_private += $(cairo_trace_private) $(cairo_trace_headers)
all_cairo_sources += $(cairo_trace_sources)
ifeq ($(CAIRO_HAS_TRACE),1)
enabled_cairo_private += $(cairo_trace_private) $(cairo_trace_headers)
enabled_cairo_sources += $(cairo_trace_sources)
endif
all_cairo_private += $(cairo_interpreter_private) $(cairo_interpreter_headers)
all_cairo_sources += $(cairo_interpreter_sources)
ifeq ($(CAIRO_HAS_INTERPRETER),1)
enabled_cairo_private += $(cairo_interpreter_private) $(cairo_interpreter_headers)
enabled_cairo_sources += $(cairo_interpreter_sources)
endif
all_cairo_private += $(cairo_symbol_lookup_private) $(cairo_symbol_lookup_headers)
all_cairo_sources += $(cairo_symbol_lookup_sources)
ifeq ($(CAIRO_HAS_SYMBOL_LOOKUP),1)
enabled_cairo_private += $(cairo_symbol_lookup_private) $(cairo_symbol_lookup_headers)
enabled_cairo_sources += $(cairo_symbol_lookup_sources)
endif

7
src/cairo-features-uninstalled.pc.in
View file

@ -1,7 +0,0 @@
Name: @FEATURE_PC@
Description: @FEATURE_NAME@ for cairo graphics library
Version: @VERSION@
Requires: @FEATURE_BASE@ @FEATURE_REQUIRES@
Libs: @FEATURE_NONPKGCONFIG_LIBS@ @FEATURE_NONPKGCONFIG_EXTRA_LIBS@
Cflags: -I${pc_top_builddir}/${pcfiledir}/@srcdir@/src @FEATURE_NONPKGCONFIG_CFLAGS@

12
src/cairo-features.pc.in
View file

@ -1,12 +0,0 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: @FEATURE_PC@
Description: @FEATURE_NAME@ for cairo graphics library
Version: @VERSION@
Requires: @FEATURE_BASE@ @FEATURE_REQUIRES@
Libs: @FEATURE_NONPKGCONFIG_LIBS@ @FEATURE_NONPKGCONFIG_EXTRA_LIBS@
Cflags: -I${includedir}/cairo @FEATURE_NONPKGCONFIG_CFLAGS@

8
src/cairo-uninstalled.pc.in
View file

@ -1,8 +0,0 @@
Name: cairo
Description: Multi-platform 2D graphics library
Version: @VERSION@
@PKGCONFIG_REQUIRES@: @CAIRO_REQUIRES@
Libs: ${pc_top_builddir}/${pcfiledir}/src/libcairo.la
Libs.private: @CAIRO_NONPKGCONFIG_LIBS@
Cflags: -I${pc_top_builddir}/${pcfiledir}/@srcdir@/src

13
src/cairo.pc.in
View file

@ -1,13 +0,0 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: cairo
Description: Multi-platform 2D graphics library
Version: @VERSION@
@PKGCONFIG_REQUIRES@: @CAIRO_REQUIRES@
Libs: -L${libdir} -lcairo
Libs.private: @CAIRO_NONPKGCONFIG_LIBS@
Cflags: -I${includedir}/cairo

48
src/check-def.sh
View file

@ -1,48 +0,0 @@
#!/bin/sh
LC_ALL=C
export LC_ALL
if which nm 2>/dev/null >/dev/null; then
:
else
echo "'nm' not found; skipping test"
exit 0
fi
test -z "$srcdir" && srcdir=.
test -z "$MAKE" && MAKE=make
stat=0
$MAKE check-has-hidden-symbols.i > /dev/null || exit 1
if tail -1 check-has-hidden-symbols.i | grep CAIRO_HAS_HIDDEN_SYMBOLS >/dev/null; then
echo "Compiler doesn't support symbol visibility; skipping test"
exit 0
fi
if [ "`uname -s`" = "Linux" ]; then
get_cairo_syms='( objdump -t "$so" | grep "^[^ ]* [^l.*]*[.]"; objdump -t "$so" | grep "[.]hidden.*\\<cairo"; ) | sed "s/.* //"'
else
get_cairo_syms='nm "$so" | grep " [BCDGINRSTVW] " | cut -d" " -f3'
fi
defs="cairo.def"
$MAKE $defs > /dev/null
for def in $defs; do
lib=`echo "$def" | sed 's/[.]def$//'`
lib=`echo "$lib" | sed 's@.*/@@'`
so=.libs/lib${lib}.so
test -f "$so" || continue
echo Checking that $so has the same symbol list as $def
{
echo EXPORTS
eval $get_cairo_syms | c++filt --no-params | grep -v '^_cairo_test_\|^_fini\|^_init\|^_save[fg]pr\|^_rest[fg]pr\|^_Z\|^__gnu\|^__bss\|^_edata\|^_end' | sort -u
# cheat: copy the last line from the def file!
tail -n1 "$def"
} | diff "$def" - >&2 || stat=1
done
exit $stat

412
test/Makefile.am
View file

@ -1,412 +0,0 @@
include $(top_srcdir)/build/Makefile.am.common
include $(top_srcdir)/test/Makefile.sources
SUBDIRS=pdiff .
# Then we have a collection of tests that are only run if certain
# features are compiled into cairo
if HAVE_REAL_PTHREAD
test_sources += $(pthread_test_sources)
endif
if CAIRO_HAS_FT_FONT
test_sources += $(ft_font_test_sources)
if CAIRO_HAS_FC_FONT
test_sources += $(fc_font_test_sources)
if HAVE_FT_SVG_DOCUMENT
test_sources += $(fc_svg_font_test_sources)
endif
endif
endif
if CAIRO_HAS_GL_SURFACE
test_sources += $(gl_surface_test_sources)
endif
if CAIRO_HAS_EGL_FUNCTIONS
test_sources += $(egl_surface_test_sources)
endif
# Need to add quartz-surface-source
if CAIRO_HAS_QUARTZ_SURFACE
test_sources += "$(quartz_surface_test_sources) $(quartz_color_font_test_sources)"
endif
if CAIRO_HAS_PDF_SURFACE
test_sources += $(pdf_surface_test_sources)
endif
if CAIRO_HAS_PS_SURFACE
test_sources += $(ps_surface_test_sources)
endif
if CAIRO_HAS_SVG_SURFACE
test_sources += $(svg_surface_test_sources)
endif
if CAIRO_HAS_TEST_SURFACES
test_sources += $(test_fallback16_surface_test_sources)
endif
if CAIRO_HAS_XCB_SURFACE
test_sources += $(xcb_surface_test_sources)
endif
if CAIRO_HAS_XLIB_SURFACE
test_sources += $(xlib_surface_test_sources)
endif
if CAIRO_HAS_XLIB_XRENDER_SURFACE
test_sources += $(xlib_xrender_surface_test_sources)
endif
if CAIRO_HAS_MULTI_PAGE_SURFACES
test_sources += $(multi_page_surface_test_sources)
endif
# Include fallback-resolution (once!) if we have any of the vector surfaces
if BUILD_ANY2PPM
if CAIRO_HAS_SVG_SURFACE
test = $(fallback_resolution_test_sources)
endif
if CAIRO_HAS_PDF_SURFACE
test = $(fallback_resolution_test_sources)
endif
if CAIRO_HAS_PS_SURFACE
test = $(fallback_resolution_test_sources)
endif
endif
test_sources += $(test)
noinst_PROGRAMS = cairo-test-suite$(EXEEXT) # always build
noinst_SCRIPTS = check-refs.sh
TESTS += cairo-test-suite$(EXEEXT)
cairo-test-constructors.c: Makefile $(test_sources) make-cairo-test-constructors.sh
(cd $(srcdir) && sh ./make-cairo-test-constructors.sh $(test_sources)) > $@ || (rm $@ ; exit 1)
cairo_test_suite_SOURCES = \
$(cairo_test_suite_sources) \
$(cairo_test_suite_headers) \
$(test_sources) \
cairo-test-constructors.c
cairo_test_suite_CFLAGS = $(AM_CFLAGS) $(real_pthread_CFLAGS)
cairo_test_suite_LDADD = \
$(real_pthread_LIBS) \
$(top_builddir)/test/pdiff/libpdiff.la \
$(top_builddir)/boilerplate/libcairoboilerplate.la \
$(top_builddir)/src/libcairo.la \
$(CAIRO_LDADD)
cairo_test_suite_DEPENDENCIES = \
$(top_builddir)/test/pdiff/libpdiff.la \
$(top_builddir)/boilerplate/libcairoboilerplate.la \
$(top_builddir)/src/libcairo.la
if BUILD_ANY2PPM
cairo_test_suite_DEPENDENCIES += \
any2ppm$(EXEEXT)
endif
if HAVE_SHM
EXTRA_PROGRAMS += cairo-test-trace
cairo_test_trace_SOURCES = \
cairo-test-trace.c \
buffer-diff.c \
buffer-diff.h
cairo_test_trace_CFLAGS = $(AM_CFLAGS) $(real_pthread_CFLAGS)
cairo_test_trace_LDADD = \
$(real_pthread_LIBS) \
$(top_builddir)/test/pdiff/libpdiff.la \
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la \
$(top_builddir)/boilerplate/libcairoboilerplate.la \
$(top_builddir)/src/libcairo.la \
$(top_builddir)/util/cairo-missing/libcairo-missing.la \
$(CAIRO_LDADD) \
$(SHM_LIBS)
cairo_test_trace_DEPENDENCIES = \
$(top_builddir)/test/pdiff/libpdiff.la \
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la \
$(top_builddir)/boilerplate/libcairoboilerplate.la \
$(top_builddir)/src/libcairo.la \
$(top_builddir)/util/cairo-missing/libcairo-missing.la \
$(NULL)
endif
BUILT_SOURCES += cairo-test-constructors.c
EXTRA_DIST += $(BUILT_SOURCES) $(noinst_SCRIPTS) COPYING make-cairo-test-constructors.sh run-cairo-test-suite.sh generate_refs.sh tiger.inc
CLEANFILES += $(BUILT_SOURCES)
EXTRA_DIST += \
6x13.pcf \
index.html \
jp2.jp2 \
jpeg.jpg \
png.png \
romedalen.jpg \
romedalen.png \
scarab.jpg \
surface-source.c \
testtable.js \
reference
# Any test that doesn't generate a log file goes here
NOLOG_TESTS = \
fallback-resolution \
font-options \
multi-page \
pdf-features \
png \
ps-eps \
ps-features \
svg-clip \
svg-surface \
toy-font-face \
font-variations \
user-data
# A target to summarise the failures
check-summary:
@FAILED_TESTS=""; \
for t in output/*.log; do \
if grep -e '\<FAIL\>' $$t >/dev/null 2>&1; then \
FAILED_TESTS="$$FAILED_TESTS $$t"; \
fi; \
done; \
if test -n "$$FAILED_TESTS"; then \
echo "Failed tests:"; \
surfaces=""; \
for t in $$FAILED_TESTS; do \
name="$${t##output/}"; name="$${name%.log}"; \
echo -n " $$name: "; \
grep -e '\<FAIL\>' $$t | sed -e 's/.*TARGET: \([^ ]*\).*/\1/' | sort | uniq | tr '\n' ' '; \
echo; \
for s in `grep -e '\<FAIL\>' $$t | sed -e 's/.*TARGET: \([^ ]*\).*/\1/' | sort | uniq`; do \
ss=`echo $$s | tr '-' '_'`; \
tt=`echo $$name | tr '-' '_'`; \
eval $$ss=\""$${!ss} $$tt"\"; \
echo $$surfaces | grep $$ss >/dev/null || surfaces="$$surfaces $$ss"; \
done; \
done; \
echo -n "Failures per surface - "; \
first=""; \
for s in $$surfaces; do \
ss=`echo $$s | tr '_' '-'`; \
test -n "$$first" && echo -n ", "; \
cnt=`echo $${!s} | wc -w`; \
echo -n "$$ss: $$cnt"; \
first="false"; \
done; \
echo "."; \
for s in $$surfaces; do \
ss=`echo $$s | tr '_' '-'`; \
cnt=`echo $${!s} | wc -w`; \
echo -n " $$ss [$$cnt]: "; \
echo $${!s} | tr '_' '-'; \
done; \
fi
AM_CPPFLAGS = \
-I$(srcdir) \
-I$(srcdir)/pdiff \
-I$(top_srcdir)/boilerplate \
-I$(top_srcdir)/util/cairo-missing \
-I$(top_srcdir)/util/cairo-script \
-I$(top_srcdir)/src \
-I$(top_builddir)/src \
$(CAIRO_CFLAGS)
AM_LDFLAGS = $(CAIRO_LDFLAGS)
$(top_builddir)/boilerplate/libcairoboilerplate.la: $(top_builddir)/src/libcairo.la
cd $(top_builddir)/boilerplate && $(MAKE) $(AM_MAKEFLAGS) libcairoboilerplate.la
$(top_builddir)/src/libcairo.la:
cd $(top_builddir)/src && $(MAKE) $(AM_MAKEFLAGS) libcairo.la
$(top_builddir)/test/pdiff/libpdiff.la:
cd $(top_builddir)/test/pdiff && $(MAKE) $(AM_MAKEFLAGS) libpdiff.la
$(top_builddir)/test/pdiff/perceptualdiff:
cd $(top_builddir)/test/pdiff && $(MAKE) $(AM_MAKEFLAGS) perceptualdiff
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la: $(top_builddir)/src/libcairo.la
cd $(top_builddir)/util/cairo-script && $(MAKE) $(AM_MAKEFLAGS) libcairo-script-interpreter.la
EXTRA_PROGRAMS += imagediff png-flatten
imagediff_SOURCES = \
imagediff.c \
buffer-diff.c \
buffer-diff.h
imagediff_LDADD = \
$(top_builddir)/test/pdiff/libpdiff.la \
$(top_builddir)/src/libcairo.la
png_flatten_SOURCES = png-flatten.c
png_flatten_LDADD = $(top_builddir)/src/libcairo.la \
$(CAIRO_LDADD)
if BUILD_ANY2PPM
check_PROGRAMS += any2ppm
any2ppm_CFLAGS = $(AM_CFLAGS) $(POPPLER_CFLAGS) $(LIBRSVG_CFLAGS) $(LIBSPECTRE_CFLAGS)
# add LDADD, so poppler/librsvg uses "our" cairo
any2ppm_LDFLAGS = $(AM_LDFLAGS) $(CAIRO_TEST_UNDEFINED_LDFLAGS)
any2ppm_LDADD = \
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la \
$(top_builddir)/src/libcairo.la \
$(CAIRO_LDADD) \
$(CAIROBOILERPLATE_LIBS) \
$(POPPLER_LIBS) \
$(LIBRSVG_LIBS) \
$(LIBSPECTRE_LIBS)
endif
if CAIRO_CAN_TEST_PDF_SURFACE
check_PROGRAMS += pdf2png
pdf2png_CFLAGS = $(AM_CFLAGS) $(POPPLER_CFLAGS)
# add LDADD, so poppler uses "our" cairo
pdf2png_LDFLAGS = $(AM_LDFLAGS) $(CAIRO_TEST_UNDEFINED_LDFLAGS)
pdf2png_LDADD = $(top_builddir)/src/libcairo.la \
$(CAIRO_LDADD) \
$(POPPLER_LIBS)
endif
if CAIRO_CAN_TEST_SVG_SURFACE
check_PROGRAMS += svg2png
svg2png_CFLAGS = $(AM_CFLAGS) $(LIBRSVG_CFLAGS)
# add LDADD, so librsvg uses "our" cairo
svg2png_LDFLAGS = $(AM_LDFLAGS) $(CAIRO_TEST_UNDEFINED_LDFLAGS)
svg2png_LDADD = $(top_builddir)/src/libcairo.la \
$(CAIRO_LDADD) \
$(LIBRSVG_LIBS)
endif
if CAIRO_HAS_SPECTRE
check_PROGRAMS += ps2png
ps2png_CFLAGS = $(AM_CFLAGS) $(LIBSPECTRE_CFLAGS)
# add LDADD, so ps2png uses "our" cairo
ps2png_LDFLAGS = $(AM_LDFLAGS) $(CAIRO_TEST_UNDEFINED_LDFLAGS)
ps2png_LDADD = $(top_builddir)/src/libcairo.la \
$(CAIRO_LDADD) \
$(LIBSPECTRE_LIBS)
endif
EXTRA_PROGRAMS += $(TESTS)
# Do a funny transition of CAIRO_TEST_TARGET through TARGETS such that
# one can limit tested targets both through CAIRO_TEST_TARGET env var
# and TARGETS make var on the command line. Same for the rest.
TARGETS = $(CAIRO_TEST_TARGET)
TARGETS_EXCLUDE = $(CAIRO_TEST_TARGET_EXCLUDE)
FORMAT = $(CAIRO_TEST_TARGET_FORMAT)
MODE = $(CAIRO_TEST_MODE)
# Same about ENV vs CAIRO_TEST_ENV. ENV is used with "make run" only
ENV = $(CAIRO_TEST_ENV)
TESTS_ENVIRONMENT = CAIRO_TEST_MODE="$(MODE)" CAIRO_TEST_TARGET="$(TARGETS)" CAIRO_TEST_TARGET_FORMAT="$(FORMAT)" CAIRO_TEST_TARGET_EXCLUDE="$(TARGETS_EXCLUDE)" $(ENV)
EXTRA_VALGRIND_FLAGS = $(CAIRO_EXTRA_VALGRIND_FLAGS)
VALGRIND_FLAGS = \
--tool=memcheck --suppressions=$(srcdir)/.valgrind-suppressions \
--track-origins=yes \
--leak-check=yes --show-reachable=yes \
$(EXTRA_VALGRIND_FLAGS)
CLEANFILES += \
valgrind-log \
ref.hash \
ref.list \
png-test.png \
png.out.png \
create-for-stream.pdf \
create-for-stream.ps \
create-for-stream.svg \
svg-surface-source.out.svg \
pdf-surface-source.out.pdf \
ps-surface-source.out.ps \
pdf-features.pdf \
pdf-mime-data.out* \
pdf-tagged-text.out* \
ps-features.ps \
svg-clip.svg \
svg-surface.svg \
multi-page.pdf \
multi-page.ps \
$(NULL)
# This used to be a simple 'echo ${RM} *.ps *.pdf *.svg *.etc', but
# most systems cannot handle all of our clean files together.
# Then it became a fancy find using many GNU extensions, but then the ugly
# reality of portability was raised and it became....
clean-local:
rm -rf output
-${FIND} . -name '*.log' -print | ${XARGS} ${RM}
-${FIND} . -name '*.[is]' -print | ${XARGS} ${RM}
clean-caches:
-${FIND} output -name '*.fail.*' -print | ${XARGS} ${RM}
-${FIND} output -name '*.pass.*' -print | ${XARGS} ${RM}
# The following definitions both should work.
#FAILED_TESTS = `grep -l '\<FAIL\>' $(test_sources:.c=.log) 2>/dev/null | sed -e 's/[.]log$$//' | xargs echo`
FAILED_TESTS = `grep -l '\<FAIL\>' $(test_sources:.c=.log) 2>/dev/null | tr '\n' ' ' | sed -e 's/[.]log */ /g; s/^ //; s/ $$//'`
recheck = check CAIRO_TESTS="$(FAILED_TESTS)"
# Re-checks all failed tests, i.e. tests with a log file that has a failure
recheck:
@echo Re-checking failed tests
@$(MAKE) $(AM_MAKEFLAGS) $(recheck)
# Checks tests.
# Target doesn't fail if tests fail.
test:
@$(MAKE) $(AM_MAKEFLAGS) check
# Re-checks tests.
# Target doesn't fail if tests fail.
retest:
@CAIRO_TESTS="$(FAILED_TESTS)"; \
$(MAKE) $(AM_MAKEFLAGS) check
# Run tests under a tool specified by TOOL. For example, make run TOOL=gdb
run:
$(MAKE) $(AM_MAKEFLAGS) check TESTS_ENVIRONMENT='$(TESTS_ENVIRONMENT) $(top_builddir)/libtool --mode=execute env $(TOOL)'
# Check tests under valgrind. Saves log to valgrind-log
check-valgrind:
$(MAKE) $(AM_MAKEFLAGS) check TESTS_ENVIRONMENT='$(TESTS_ENVIRONMENT) CAIRO_TEST_MODE="$(MODE),foreground CAIRO_TEST_TIMEOUT=0" $(top_builddir)/libtool --mode=execute valgrind $(VALGRIND_FLAGS)' 2>&1 | tee valgrind-log
#%.log: %.c cairo-test-suite
#-./cairo-test-suite $(<:.c=)
NOLOG_TESTS_LOG = $(NOLOG_TESTS:=.log)
$(NOLOG_TESTS_LOG):
@echo dummy > $@
# Identify identical reference images
check-ref-dups: check-refs.sh $(top_builddir)/test/pdiff/perceptualdiff
sh $(srcdir)/check-refs.sh $(top_builddir)/test/pdiff/perceptualdiff
# Remove identical reference images (DANGEROUS)
clean-ref-dups: check-refs.sh $(top_builddir)/test/pdiff/perceptualdiff
sh $(srcdir)/check-refs.sh | cut -d' ' -f2 | while read f; do git rm "reference/$$f"; done
results.tar:
@tar cf $@ index.html testtable.js *.log output/*.log; \
for i in output/*.fail.png ; do \
testname=$${i#output/} ; \
testname=$${testname%%.*} ; \
echo tar uf $@ reference/$${testname}*.ref.png $${i%fail.png}out.png $${i%fail.png}diff.png ; \
tar uf $@ reference/$${testname}*.ref.png $${i%fail.png}out.png $${i%fail.png}diff.png ; \
done
results.tar.gz: results.tar
gzip -c $< > $@
release-verify-sane-tests:
.PHONY: check-valgrind test recheck retest check-ref-dups release-verify-sane-tests
EXTRA_DIST += Makefile.win32

485
test/Makefile.sources
View file

@ -1,485 +0,0 @@
test_sources = \
a1-bug.c \
a1-clip.c \
a1-fill.c \
a1-image-sample.c \
a1-mask.c \
a1-mask-sample.c \
a1-sample.c \
a1-traps-sample.c \
a1-rasterisation.c \
a8-clear.c \
a8-mask.c \
aliasing.c \
alpha-similar.c \
arc-direction.c \
arc-infinite-loop.c \
arc-looping-dash.c \
api-special-cases.c \
big-line.c \
big-empty-box.c \
big-empty-triangle.c \
big-little-box.c \
big-little-triangle.c \
bug-spline.c \
big-trap.c \
bilevel-image.c \
bug-277.c \
bug-361.c \
bug-40410.c \
bug-431.c \
bug-448.c \
bug-535.c \
bug-51910.c \
bug-75705.c \
bug-84115.c \
bug-bo-rectangular.c \
bug-bo-collins.c \
bug-bo-ricotz.c \
bug-source-cu.c \
bug-extents.c \
bug-seams.c \
bug-image-compositor.c \
caps.c \
checkerboard.c \
caps-joins.c \
caps-joins-alpha.c \
caps-joins-curve.c \
caps-tails-curve.c \
caps-sub-paths.c \
clear.c \
clear-source.c \
clip-all.c \
clip-complex-bug61592.c \
clip-complex-shape.c \
clip-contexts.c \
clip-disjoint.c \
clip-disjoint-hatching.c \
clip-disjoint-quad.c \
clip-device-offset.c \
clip-double-free.c \
clip-draw-unbounded.c \
clip-empty.c \
clip-empty-group.c \
clip-empty-save.c \
clip-fill.c \
clip-fill-no-op.c \
clip-fill-rule.c \
clip-fill-rule-pixel-aligned.c \
clip-group-shapes.c \
clip-image.c \
clip-intersect.c \
clip-mixed-antialias.c \
clip-nesting.c \
clip-operator.c \
clip-push-group.c \
clip-polygons.c \
clip-rectilinear.c \
clip-shape.c \
clip-stroke.c \
clip-stroke-no-op.c \
clip-text.c \
clip-twice.c \
clip-twice-rectangle.c \
clip-unbounded.c \
clip-zero.c \
clipped-group.c \
clipped-surface.c \
close-path.c \
close-path-current-point.c \
composite-integer-translate-source.c \
composite-integer-translate-over.c \
composite-integer-translate-over-repeat.c \
copy-disjoint.c \
copy-path.c \
coverage.c \
create-for-stream.c \
create-from-broken-png-stream.c \
create-from-png.c \
create-from-png-stream.c \
culled-glyphs.c \
curve-to-as-line-to.c \
dash-caps-joins.c \
dash-curve.c \
dash-infinite-loop.c \
dash-no-dash.c \
dash-offset.c \
dash-offset-negative.c \
dash-scale.c \
dash-state.c \
dash-zero-length.c \
degenerate-arc.c \
degenerate-arcs.c \
degenerate-curve-to.c \
degenerate-dash.c \
degenerate-linear-gradient.c \
degenerate-path.c \
degenerate-pen.c \
degenerate-radial-gradient.c \
degenerate-rel-curve-to.c \
degenerate-solid-dash.c \
drunkard-tails.c \
device-offset.c \
device-offset-fractional.c \
device-offset-positive.c \
device-offset-scale.c \
error-setters.c \
extend-pad.c \
extend-pad-border.c \
extend-pad-similar.c \
extend-reflect.c \
extend-reflect-similar.c \
extend-repeat.c \
extend-repeat-similar.c \
extended-blend.c \
fallback.c \
fill-alpha.c \
fill-alpha-pattern.c \
fill-and-stroke.c \
fill-and-stroke-alpha.c \
fill-and-stroke-alpha-add.c \
fill-degenerate-sort-order.c \
fill-disjoint.c \
fill-empty.c \
fill-image.c \
fill-missed-stop.c \
fill-rule.c \
filter-bilinear-extents.c \
filter-nearest-offset.c \
filter-nearest-transformed.c \
finer-grained-fallbacks.c \
font-face-get-type.c \
font-matrix-translation.c \
font-options.c \
glyph-cache-pressure.c \
get-and-set.c \
get-clip.c \
get-group-target.c \
get-path-extents.c \
gradient-alpha.c \
gradient-constant-alpha.c \
gradient-zero-stops.c \
gradient-zero-stops-mask.c \
group-clip.c \
group-paint.c \
group-state.c \
group-unaligned.c \
hairline.c \
half-coverage.c \
halo.c \
hatchings.c \
horizontal-clip.c \
huge-linear.c \
huge-radial.c \
image-surface-source.c \
image-bug-710072.c \
implicit-close.c \
infinite-join.c \
in-fill-empty-trapezoid.c \
in-fill-trapezoid.c \
invalid-matrix.c \
inverse-text.c \
inverted-clip.c \
joins.c \
joins-loop.c \
joins-star.c \
joins-retrace.c \
large-clip.c \
large-font.c \
large-source.c \
large-source-roi.c \
large-twin-antialias-mixed.c \
leaky-dash.c \
leaky-dashed-rectangle.c \
leaky-dashed-stroke.c \
leaky-polygon.c \
line-width.c \
line-width-large-overlap.c \
line-width-overlap.c \
line-width-scale.c \
line-width-tolerance.c \
line-width-zero.c \
linear-gradient.c \
linear-gradient-extend.c \
linear-gradient-large.c \
linear-gradient-one-stop.c \
linear-gradient-reflect.c \
linear-gradient-subset.c \
linear-step-function.c \
linear-uniform.c \
long-dashed-lines.c \
long-lines.c \
map-to-image.c \
mask.c \
mask-alpha.c \
mask-ctm.c \
mask-glyphs.c \
mask-surface-ctm.c \
mask-transformed-image.c \
mask-transformed-similar.c \
mesh-pattern.c \
mesh-pattern-accuracy.c \
mesh-pattern-conical.c \
mesh-pattern-control-points.c \
mesh-pattern-fold.c \
mesh-pattern-overlap.c \
mesh-pattern-transformed.c \
mime-data.c \
mime-surface-api.c \
miter-precision.c \
move-to-show-surface.c \
negative-stride-image.c \
new-sub-path.c \
nil-surface.c \
operator.c \
operator-alpha.c \
operator-alpha-alpha.c \
operator-clear.c \
operator-source.c \
operator-www.c \
outline-tolerance.c \
overflow.c \
over-above-source.c \
over-around-source.c \
over-below-source.c \
over-between-source.c \
overlapping-boxes.c \
overlapping-glyphs.c \
overlapping-dash-caps.c \
paint.c \
paint-clip-fill.c \
paint-repeat.c \
paint-source-alpha.c \
paint-with-alpha.c \
paint-with-alpha-group-clip.c \
partial-clip-text.c \
partial-coverage.c \
pass-through.c \
path-append.c \
path-currentpoint.c \
path-stroke-twice.c \
path-precision.c \
pattern-get-type.c \
pattern-getters.c \
pdf-isolated-group.c \
pixman-downscale.c \
pixman-rotate.c \
png.c \
push-group.c \
push-group-color.c \
push-group-path-offset.c \
radial-gradient.c \
radial-gradient-extend.c \
radial-outer-focus.c \
random-clips.c \
random-intersections-eo.c \
random-intersections-nonzero.c \
random-intersections-curves-eo.c \
random-intersections-curves-nz.c \
raster-source.c \
record.c \
record1414x.c \
record2x.c \
record90.c \
recordflip.c \
record-extend.c \
record-neg-extents.c \
record-mesh.c \
record-replay-extend.c \
record-transform-paint.c \
record-write-png.c \
recording-ink-extents.c \
recording-surface-pattern.c \
recording-surface-extend.c \
rectangle-rounding-error.c \
rectilinear-fill.c \
rectilinear-grid.c \
rectilinear-miter-limit.c \
rectilinear-dash.c \
rectilinear-dash-scale.c \
rectilinear-stroke.c \
reflected-stroke.c \
rel-path.c \
rgb24-ignore-alpha.c \
rotate-image-surface-paint.c \
rotate-stroke-box.c \
rotated-clip.c \
rounded-rectangle-fill.c \
rounded-rectangle-stroke.c \
round-join-bug-520.c \
sample.c \
scale-down-source-surface-paint.c \
scale-offset-image.c \
scale-offset-similar.c \
scale-source-surface-paint.c \
scaled-font-zero-matrix.c \
stroke-ctm-caps.c \
stroke-clipped.c \
stroke-image.c \
stroke-open-box.c \
select-font-face.c \
select-font-no-show-text.c \
self-copy.c \
self-copy-overlap.c \
self-intersecting.c \
set-source.c \
show-glyphs-advance.c \
show-glyphs-many.c \
show-text-current-point.c \
shape-general-convex.c \
shape-sierpinski.c \
shifted-operator.c \
simple.c \
skew-extreme.c \
smask.c \
smask-fill.c \
smask-image-mask.c \
smask-mask.c \
smask-paint.c \
smask-stroke.c \
smask-text.c \
smp-glyph.c \
solid-pattern-cache-stress.c \
source-clip.c \
source-clip-scale.c \
source-surface-scale-paint.c \
spline-decomposition.c \
stride-12-image.c \
stroke-pattern.c \
subsurface.c \
subsurface-image-repeat.c \
subsurface-repeat.c \
subsurface-reflect.c \
subsurface-pad.c \
subsurface-modify-child.c \
subsurface-modify-parent.c \
subsurface-outside-target.c \
subsurface-scale.c \
subsurface-similar-repeat.c \
surface-finish-twice.c \
surface-pattern.c \
surface-pattern-big-scale-down.c \
surface-pattern-operator.c \
surface-pattern-scale-down.c \
surface-pattern-scale-down-extend.c \
surface-pattern-scale-up.c \
text-antialias.c \
text-antialias-subpixel.c \
text-cache-crash.c \
text-glyph-range.c \
text-pattern.c \
text-rotate.c \
text-subpixel.c \
text-transform.c \
text-unhinted-metrics.c \
text-zero-len.c \
thin-lines.c \
tighten-bounds.c \
tiger.c \
toy-font-face.c \
transforms.c \
translate-show-surface.c \
trap-clip.c \
twin.c \
twin-antialias-gray.c \
twin-antialias-mixed.c \
twin-antialias-none.c \
twin-antialias-subpixel.c \
unaligned-box.c \
unantialiased-shapes.c \
unbounded-operator.c \
unclosed-strokes.c \
user-data.c \
user-font.c \
user-font-color.c \
user-font-mask.c \
user-font-proxy.c \
user-font-rescale.c \
user-font-subpixel.c \
world-map.c \
white-in-noop.c \
xcb-huge-image-shm.c \
xcb-huge-subimage.c \
xcb-stress-cache.c \
xcb-snapshot-assert.c \
xcomposite-projection.c \
xlib-expose-event.c \
zero-alpha.c \
zero-mask.c
pthread_test_sources = \
pthread-same-source.c \
pthread-show-text.c \
pthread-similar.c \
$(NULL)
ft_font_test_sources = \
font-variations.c
fc_font_test_sources = \
bitmap-font.c \
ft-color-font.c \
ft-font-create-for-ft-face.c \
ft-show-glyphs-positioning.c \
ft-show-glyphs-table.c \
ft-text-vertical-layout-type1.c \
ft-text-vertical-layout-type3.c \
ft-text-antialias-none.c
fc_svg_font_test_sources = \
ft-svg-color-font.c
gl_surface_test_sources = \
gl-device-release.c \
gl-oversized-surface.c \
gl-surface-source.c
egl_surface_test_sources = \
egl-oversized-surface.c \
egl-surface-source.c
quartz_surface_test_sources = quartz-surface-source.c
quartz_color_font_test_sources = quartz-color-font.c
pdf_surface_test_sources = \
pdf-features.c \
pdf-mime-data.c \
pdf-operators-text.c \
pdf-surface-source.c \
pdf-tagged-text.c
ps_surface_test_sources = \
ps-eps.c \
ps-features.c \
ps-surface-source.c
svg_surface_test_sources = \
svg-surface.c \
svg-clip.c \
svg-surface-source.c
xcb_surface_test_sources = \
xcb-surface-source.c
xlib_surface_test_sources = \
xlib-surface.c \
xlib-surface-source.c
xlib_xrender_surface_test_sources = get-xrender-format.c
multi_page_surface_test_sources = multi-page.c mime-unique-id.c
fallback_resolution_test_sources = fallback-resolution.c
cairo_test_suite_headers = \
buffer-diff.h \
cairo-test.h \
cairo-test-private.h \
world-map.h \
$(NULL)
cairo_test_suite_sources = \
buffer-diff.c \
cairo-test.c \
cairo-test-runner.c

55
test/Makefile.win32
View file

@ -1,55 +0,0 @@
top_srcdir = ..
include $(top_srcdir)/build/Makefile.win32.common
include $(top_srcdir)/test/Makefile.sources
CFLAGS += \
-I$(top_srcdir)/boilerplate \
-I$(top_srcdir)/util/cairo-script/ \
-I./pdiff \
$(NULL)
TEST_LIBS = \
./pdiff/$(CFG)/pdiff.lib \
$(top_builddir)/boilerplate/$(CFG)/boiler.lib \
$(top_builddir)/src/$(CFG)/cairo-static.lib \
$(NULL)
all: inform $(CFG)/cairo-test-suite.exe
cairo-test-constructors.c: Makefile.sources Makefile.win32 $(test_sources) make-cairo-test-constructors.sh
sh ./make-cairo-test-constructors.sh $(test_sources) > $@
SOURCES = $(cairo_test_suite_sources) $(test_sources) cairo-test-constructors.c
OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(SOURCES))
ANY2PPM_OBJS = \
$(CFG)/any2ppm-static.obj \
$(top_builddir)/util/cairo-script/$(CFG)/libcairo-script-interpreter.lib \
$(top_builddir)/src/$(CFG)/cairo-static.lib \
$(NULL)
$(CFG)/cairo-test-suite.exe: $(OBJECTS) $(TEST_LIBS)
@$(LD) $(CAIRO_LDFLAGS) -OUT:$@ $(OBJECTS) $(TEST_LIBS) $(CAIRO_LIBS)
$(CFG)/any2ppm.exe: $(ANY2PPM_OBJS)
$(LD) $(CAIRO_LDFLAGS) -OUT:$@ $^ $(CAIRO_LIBS)
./pdiff/$(CFG)/pdiff.lib:
$(MAKE) -C pdiff -f Makefile.win32
$(top_builddir)/src/$(CFG)/cairo-static.lib:
$(MAKE) -C $(top_srcdir)/src -f Makefile.win32
$(top_builddir)/boilerplate/$(CFG)/boiler.lib:
$(MAKE) -C $(top_srcdir)/boilerplate -f Makefile.win32
$(top_builddir)/util/cairo-script/$(CFG)/libcairo-script-interpreter.lib:
$(MAKE) -C $(top_srcdir)/util/cairo-script -f Makefile.win32
.PHONY: check test
check: inform $(CFG)/any2ppm.exe $(CFG)/cairo-test-suite.exe
@ANY2PPM=$(CFG)\\any2ppm.exe $(CFG)/cairo-test-suite.exe
test: inform check

296
test/README
View file

@ -1,296 +0,0 @@
Regression test suite for cairo.
How to use cairo's test suite
=============================
Using this test should be as simple as running:
make test
assuming that the cairo distribution in the directory above has been
configured and built. The test suite here goes through some effort to
run against the locally compiled library rather than any installed
version, but those efforts may fall short depending on the level of your
libtool madness.
The results of the test suite run are summarized in an index.html
file, which, when viewed in a web browser makes it quite easy to
visually see any failed renderings alongside the corresponding
reference image, (and a diff image as well).
As some browsers do not permit Javascript to read from the local
filesystem, the view-test-results.py script can used to view the
results. It starts a http server serving the current directory before
displaying the test results in a browser.
The test suite needs to be run before any code is committed and before
any release. See below for hints and rules governing the use of the suite.
The test suite is built as a single binary, which allows you to choose
individual or categories of tests to run. For example, to run specific tests:
./cairo-test-suite record-neg-extents-unbounded record-neg-extents-bounded
Or if you want to run all paint.* related tests you can use:
./cairo-test-suite paint
Or if you want to check the current status of known failures:
./cairo-test-suite XFAIL
Or to run a subset of tests, use the -k option to run only the tests
that include the given keyword:
./cairo-test-suite -k downscale
The binary also permits controlling which backend is used via the
CAIRO_TEST_TARGET environment variable, so for instance:
CAIRO_TEST_TARGET=gl ./cairo-test-suite -k blur
This binary should be backwards-compatible with all library versions,
allowing you to compare current versus past behaviour for any test.
The test suite needs to find the "test" directory in the source
tree. The srcdir environment variable can be used to specify
the location of this directory. If this environment variable is not
set, the binary looks for the directory "srcdir" in the current
directory. The meson build system symlinks "srcdir" in the
$builddir/test directory to the "test" directory in the source
tree. If this is not found the binary defaults to the current
directory.
Tailoring tests running
-----------------------
There are some mechanisms to limit the tests run during "make test".
These come very handy when doing development, but should not be used
to circumvent the "pass" requirements listed below.
make's TARGETS environment variable can be used to limit the backends when
running the tests. It should contain a (space-, comma-separated) list of
backends. CAIRO_TESTS environment variable, which is a comma-, space-seperated
lists, can be used to limit the tests run.
For example:
CAIRO_TESTS="zero-alpha" make test TARGETS=image,ps
make's FORMAT variable can also be used to limit the content formats when
running the tests. It should contain a (space-, comma-separated) list of
content formats to test.
For example:
CAIRO_TESTS="zero-alpha" make test TARGETS=image,ps FORMAT="rgb,rgba"
Another very handy mechanism when trying to fix bugs is:
make retest
This will re-run the test suite, but only on tests that failed on the
last run. So this is a much faster way of checking if changes actually
fix bugs rather than running the entire test suite again.
The test suite first compares the output from the current run against the
previous in order to skip more expensive image comparisons . If you think
this is interfering with the results, you can clear the cached results using:
make clean-caches
Running tests under modified environments or tools
-------------------------------------------------
To run tests under a tool like gdb, one can use the run target and
the TOOL variable. For example:
CAIRO_TESTS=user-font make run TOOL=gdb TARGETS=pdf
If you want to run under valgrind, there is a specific target for that
that also sets a bunch of useful valgrind options. Try:
CAIRO_TESTS=user-font make check-valgrind
You can run tests under a modified environment you can use the ENV
make variable. However, that environment will also affect the libtool
wrapper of the tests. To only affect the actual test binaries, pass
such environment as TOOL:
CAIRO_TESTS=user-font make run TOOL="LD_PRELOAD=/path/to/something.so"
Getting the elusive zero failures
---------------------------------
It's generally been very difficult to achieve a test run with zero
failures. The difficulties stem from the various versions of the many
libraries that the test suite depends on, (it depends on a lot more
than cairo itself), as well as fonts and other system-specific
settings. If your system differs significantly from the system on
which the reference images were generated, then you will likely see
the test suite reporting "failures", (even if cairo is working just
fine).
We are constantly working to reduce the number of variables that need
to be tweaked to get a clean run, (for example, by bundling fonts with
the test suite itself), and also working to more carefully document
the software configuration used to generate the reference images.
Here are some of the relevant details:
* Your system must have a copy of the DejaVu font, the sha1sum of
the version used are listed in [...]. These are
"DejaVu Sans" (DejaVuSans.ttf) [e9831ee4fd2e1d0ac54508a548c6a449545eba3f];
"DejaVu Sans Mono" (DejaVuSansMono.ttf) [25d854fbd0450a372615a26a8ef9a1024bd3efc6];
"DejaVu Serif" (DejaVuSerif.ttf) [78a81850dc7883969042cf3d6dfd18eea7e43e2f];
[the DejaVu fonts can be installed from the fonts-dejavu-core 2.34-1 Debian package]
and also
"Nimbus Sans L" (n019003l.pfb)
[which can be found in the gsfonts Debian package].
* Currently, you must be using a build of cairo using freetype
(cairo-ft) as the default font backend. Otherwise all tests
involving text are likely to fail.
* To test the pdf backend, you will want the very latest version of
poppler as made available via git:
git clone git://anongit.freedesktop.org/git/poppler/poppler
As of this writing, no released version of poppler contains all
the fixes you will need to avoid false negatives from the test
suite.
* To test the ps backend, you will need ghostscript version 9.06.
* Testing the xlib backend is problematic since many X server
drivers have bugs that are exercised by the test suite. (Or, if
not actual bugs, differ slightly in their output in such a way
that the test suite will report errors.) This can be quite handy
if you want to debug an X server driver, but since most people
don't want to do that, another option is to run against a headless
X server that uses only software for all rendering. One such X
server is Xvfb which can be started like this:
Xvfb -screen 0 1680x1024x24 -ac -nolisten tcp :2
after which the test suite can be run against it like so:
DISPLAY=:2 make test
We have been using Xvfb for testing cairo releases and ensuring
that all tests behave as expected with this X server.
What if I can't make my system match?
-------------------------------------
For one reason or another, you may be unable to get a clean run of the
test suite even if cairo is working properly, (for example, you might
be on a system without freetype). In this case, it's still useful to
be able to determine if code changes you make to cairo result in any
regressions to the test suite. But it's hard to notice regressions if
there are many failures both before and after your changes.
For this scenario, you can capture the output of a run of the test
suite before your changes, and then use the CAIRO_REF_DIR environment
variable to use that output as the reference images for a run after
your changes. The process looks like this:
# Before code change there may be failures we don't care about
make test
# Let's save those output images
mkdir /some/directory/
cp -r test/output /some/directory/
# hack, hack, hack
# Now to see if nothing changed:
CAIRO_REF_DIR=/some/directory/ make test
Best practices for cairo developers
===================================
If we all follow the guidelines below, then both the test suite and
cairo itself will stay much healthier, and we'll all have a lot more
fun hacking on cairo.
Before committing
-----------------
All tests should return a result of PASS or XFAIL. The XFAIL results
indicate known bugs. The final message should be one of the following:
All XX tests behaved as expected (YY expected failures)
All XX tests passed
If any tests have a status of FAIL, then the new code has caused a
regression error which should be fixed before the code is committed.
When a new bug is found
-----------------------
A new test case should be added by imitating the style of an existing
test. This means adding the following files:
new-bug.c
reference/new-bug.ref.png
reference/new-bug.xfail.png
Where new-bug.c is a minimal program to demonstrate the bug, following
the style of existing tests. The new-bug.ref.png image should contain
the desired result of new-bug.c if the bug were fixed while
new-bug.xfail.png contains the current results of the test.
Makefile.sources should be edited by adding new-bug.c to test_sources.
And last but not least, don't forget to "git add" the new files.
When a new feature is added
---------------------------
It's important for the regression suite to keep pace with development
of the library. So a new test should be added for each new feature.
The work involved is similar the work described above for new bugs.
The only distinction is that the test is expected to pass so it
should not need a new-bug.xfail.png file.
While working on a test
-----------------------
Before a bugfix or feature is ready, it may be useful to compare
output from different builds. For convenience, you can set
CAIRO_REF_DIR to point at a previous test directory, relative
to the current test directory, and any previous output will be
used by preference as reference images.
When a bug is fixed
-------------------
The fix should be verified by running the test suite which should
result in an "unexpected pass" for the test of interest. Rejoice as
appropriate, then remove the relevant xfail.png file from git.
Before releasing
----------------
All tests should return a result of PASS for all supported (those enabled by
default) backends, meaning all known bugs are fixed, resulting in the happy
message:
All XX tests passed
Some notes on limitations in poppler
====================================
One of the difficulties of our current test infrastructure is that we
rely on external tools to convert cairo's vector output (PDF,
PostScript, and SVG), into an image that can be used for the image
comparison. This means that any bugs in that conversion tool will
result in false negatives in the test suite.
We've identified several such bugs in the poppler library which is
used to convert PDF to an image. This is particularly discouraging
because 1) poppler is free software that will be used by *many* cairo
users, and 2) poppler calls into cairo for its rendering so it should
be able to do a 100% faithful conversion.
So we have an interest in ensuring that these poppler bugs get fixed
sooner rather than later. As such, we're trying to be good citizens by
reporting all such poppler bugs that we identify to the poppler
bugzilla. Here's a tracking bug explaining the situation:
Poppler does not yet handle everything in the cairo test suite
https://bugs.freedesktop.org/show_bug.cgi?id=12143
Here's the rule: If a cairo-pdf test reports a failure, but viewing
the resulting PDF file with acroread suggests that the PDF itself is
correct, then there's likely a bug in poppler. In this case, we can
simply report the poppler bug, (making it block 12143 above), post the
PDF result from the test suite, and list the bug in this file. Once
we've done this, we can capture poppler's buggy output as a
pdf-specific reference image (as reference/*.xfail.png) so that the
test suite will regard the test as passing, (and we'll ensure there
is no regression).
Once the poppler bug gets fixed, the test suite will start reporting a
false negative again, and this will be easy to fix by simply removing
the pdf-specific reference image.
Here are the reported poppler bugs and the tests they affect:
[Newest was closed in 2009.]

55
test/pdiff/CMakeLists.txt
View file

@ -1,55 +0,0 @@
PROJECT (PerceptualDiff)
SET(DIFF_SRC PerceptualDiff.cpp LPyramid.cpp RGBAImage.cpp
CompareArgs.cpp Metric.cpp)
ADD_EXECUTABLE (perceptualdiff ${DIFF_SRC})
# look for libtiff
FIND_PATH(TIFF_INCLUDE_DIR tiff.h
/usr/local/include
/usr/include
/opt/local/include
)
FIND_LIBRARY(TIFF_LIBRARY tiff
/usr/lib
/usr/local/lib
/opt/local/lib
)
IF(TIFF_INCLUDE_DIR)
IF(TIFF_LIBRARY)
SET( TIFF_FOUND "YES" )
SET( TIFF_LIBRARIES ${TIFF_LIBRARY} )
ENDIF(TIFF_LIBRARY)
ENDIF(TIFF_INCLUDE_DIR)
IF(TIFF_FOUND)
INCLUDE_DIRECTORIES(${TIFF_INCLUDE_DIR})
TARGET_LINK_LIBRARIES(perceptualdiff ${TIFF_LIBRARY})
ENDIF(TIFF_FOUND)
# look for libpng
FIND_PATH(PNG_INCLUDE_DIR png.h
/usr/local/include
/usr/include
/opt/local/include
)
FIND_LIBRARY(PNG_LIBRARY png
/usr/lib
/usr/local/lib
/opt/local/lib
)
IF(PNG_INCLUDE_DIR)
IF(PNG_LIBRARY)
SET( PNG_FOUND "YES" )
SET( PNG_LIBRARIES ${PNG_LIBRARY} )
ENDIF(PNG_LIBRARY)
ENDIF(PNG_INCLUDE_DIR)
IF(PNG_FOUND)
INCLUDE_DIRECTORIES(${PNG_INCLUDE_DIR})
TARGET_LINK_LIBRARIES(perceptualdiff ${PNG_LIBRARY})
ENDIF(PNG_FOUND)

19
test/pdiff/Makefile.am
View file

@ -1,19 +0,0 @@
include $(top_srcdir)/build/Makefile.am.common
EXTRA_PROGRAMS += perceptualdiff
EXTRA_DIST += gpl.txt
noinst_LTLIBRARIES = libpdiff.la
libpdiff_la_SOURCES = \
pdiff.h \
lpyramid.c \
lpyramid.h \
pdiff.c
perceptualdiff_SOURCES = \
args.c \
args.h \
perceptualdiff.c
AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_builddir)/src $(CAIRO_CFLAGS)
LDADD = libpdiff.la $(top_builddir)/src/libcairo.la

14
test/pdiff/Makefile.win32
View file

@ -1,14 +0,0 @@
top_srcdir = ../..
include $(top_srcdir)/build/Makefile.win32.common
SOURCES = \
lpyramid.c \
pdiff.c \
$(NULL)
OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(SOURCES))
all: $(CFG)/pdiff.lib
$(CFG)/pdiff.lib: $(OBJECTS)
@$(AR) $(CAIRO_ARFLAGS) -OUT:$@ $(OBJECTS)

98
util/Makefile.am
View file

@ -1,98 +0,0 @@
include $(top_srcdir)/build/Makefile.am.common
SUBDIRS = . cairo-missing
if CAIRO_HAS_GOBJECT_FUNCTIONS
SUBDIRS += cairo-gobject
endif
if CAIRO_HAS_INTERPRETER
SUBDIRS += cairo-script
endif
if CAIRO_HAS_TRACE
SUBDIRS += cairo-trace
if CAIRO_HAS_DLSYM
if CAIRO_HAS_SCRIPT_SURFACE
if CAIRO_HAS_TEE_SURFACE
SUBDIRS += cairo-fdr
endif
endif
endif
endif
if BUILD_SPHINX
if CAIRO_HAS_DLSYM
if CAIRO_HAS_SCRIPT_SURFACE
if CAIRO_HAS_TEE_SURFACE
SUBDIRS += cairo-sphinx
endif
endif
endif
endif
AM_CPPFLAGS = -I$(top_srcdir)/src \
-I$(top_builddir)/src \
-I$(top_srcdir)/util/cairo-script \
$(CAIRO_CFLAGS)
EXTRA_PROGRAMS += show-contour show-traps show-edges show-polygon show-events
if CAIRO_HAS_INTERPRETER
EXTRA_PROGRAMS += trace-to-xml xml-to-trace
endif
trace_to_xml_LDADD = cairo-script/libcairo-script-interpreter.la $(top_builddir)/src/libcairo.la $(CAIRO_LDADD)
xml_to_trace_LDADD = -lexpat
show_traps_SOURCES = show-traps.c
show_traps_CFLAGS = $(gtk_CFLAGS)
#show_traps_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS)
show_traps_LDADD = $(gtk_LIBS)
show_polygon_SOURCES = show-polygon.c
show_polygon_CFLAGS = $(gtk_CFLAGS)
#show_polygon_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS)
show_polygon_LDADD = $(gtk_LIBS)
show_edges_SOURCES = show-edges.c
show_edges_CFLAGS = $(gtk_CFLAGS)
#show_edges_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS)
show_edges_LDADD = $(gtk_LIBS)
show_contour_SOURCES = show-contour.c
show_contour_CFLAGS = $(gtk_CFLAGS)
#show_contour_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS)
show_contour_LDADD = $(gtk_LIBS)
show_events_SOURCES = show-events.c
show_events_CFLAGS = $(gtk_CFLAGS)
#show_events_LDADD = $(top_builddir)/src/libcairo.la $(gtk_LIBS)
show_events_LDADD = $(gtk_LIBS)
util: malloc-stats.so
.la.so:
$(RM) $@
$(LN_S) .libs/$*.so $@
CLEANFILES += *.so
# The -rpath is needed to build shared objects that are not installed,
# ie. with EXTRA_LTLIBRARIES
AM_LDFLAGS = -module -avoid-version -export-dynamic -rpath /dev/null
EXTRA_LTLIBRARIES += malloc-stats.la
if HAVE_GTK
EXTRA_PROGRAMS += font-view
font_view_CFLAGS = $(gtk_CFLAGS)
font_view_LDADD = ../src/libcairo.la $(gtk_LIBS)
endif
EXTRA_DIST += \
COPYING \
xr2cairo \
cairo-api-update \
cairo-view \
waterfall

15
util/cairo-fdr/Makefile.am
View file

@ -1,15 +0,0 @@
cairolibdir = $(libdir)/cairo
#bin_SCRIPTS = cairo-fdr
cairolib_LTLIBRARIES = cairo-fdr.la
AM_CPPFLAGS = -I$(top_srcdir)/src \
-I$(top_builddir)/src
cairo_fdr_la_SOURCES = fdr.c
cairo_fdr_la_CPPFLAGS = $(AM_CPPFLAGS)
cairo_fdr_la_CFLAGS = $(CAIRO_CFLAGS)
cairo_fdr_la_LDFLAGS = -module -no-undefined -avoid-version
if CAIRO_HAS_DL
cairo_fdr_la_LIBADD = -ldl
endif

15
util/cairo-gobject/Makefile.am
View file

@ -1,15 +0,0 @@
lib_LTLIBRARIES = libcairo-gobject.la
AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_builddir)/src
cairoincludedir=$(includedir)/cairo
cairoinclude_HEADERS = cairo-gobject.h
libcairo_gobject_la_SOURCES = \
cairo-gobject-enums.c \
cairo-gobject-structs.c \
$(NULL)
libcairo_gobject_la_CFLAGS = $(CAIRO_CFLAGS) $(GOBJECT_CFLAGS)
libcairo_gobject_la_LDFLAGS = -version-info $(CAIRO_LIBTOOL_VERSION_INFO) -no-undefined $(export_symbols)
libcairo_gobject_la_LIBADD = $(top_builddir)/src/libcairo.la $(CAIRO_LIBS) $(GOBJECT_LIBS)

10
util/cairo-missing/Makefile.am
View file

@ -1,10 +0,0 @@
include $(top_srcdir)/util/cairo-missing/Makefile.sources
AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_builddir)/src
noinst_LTLIBRARIES = libcairo-missing.la
libcairo_missing_la_SOURCES = \
$(libcairo_missing_sources) \
$(libcairo_missing_headers) \
$(NULL)

8
util/cairo-missing/Makefile.sources
View file

@ -1,8 +0,0 @@
libcairo_missing_sources = \
strndup.c \
getline.c \
$(NULL)
libcairo_missing_headers = \
cairo-missing.h \
$(NULL)

10
util/cairo-missing/Makefile.win32
View file

@ -1,10 +0,0 @@
top_srcdir = ../../
include $(top_srcdir)/build/Makefile.win32.common
include $(top_srcdir)/util/cairo-missing/Makefile.sources
all: inform $(CFG)/libcairo-missing.lib
libcairo_missing_OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(libcairo_missing_sources))
$(CFG)/libcairo-missing.lib: $(libcairo_missing_OBJECTS)
@$(AR) $(CAIRO_ARFLAGS) -OUT:$@ $^

37
util/cairo-script/Makefile.am
View file

@ -1,37 +0,0 @@
include $(top_srcdir)/util/cairo-script/Makefile.sources
SUBDIRS = examples
lib_LTLIBRARIES = libcairo-script-interpreter.la
EXTRA_PROGRAMS = csi-replay csi-exec csi-bind
AM_CPPFLAGS = -I$(top_srcdir)/src -I$(top_builddir)/src
cairoincludedir=$(includedir)/cairo
cairoinclude_HEADERS = cairo-script-interpreter.h
libcairo_script_interpreter_la_SOURCES = \
$(libcairo_script_interpreter_sources) \
$(libcairo_script_interpreter_headers) \
$(NULL)
libcairo_script_interpreter_la_CFLAGS = $(CAIRO_CFLAGS)
libcairo_script_interpreter_la_LDFLAGS = -version-info $(CAIRO_LIBTOOL_VERSION_INFO) -no-undefined $(export_symbols)
libcairo_script_interpreter_la_LIBADD = $(top_builddir)/src/libcairo.la $(CAIRO_LIBS) $(lzo_LIBS) -lz
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = cairo-script-interpreter.pc
csi_replay_SOURCES = csi-replay.c
csi_replay_CFLAGS = $(CAIRO_CFLAGS)
csi_replay_LDADD = libcairo-script-interpreter.la $(top_builddir)/src/libcairo.la $(CAIRO_LIBS)
csi_exec_SOURCES = csi-exec.c
csi_exec_LDADD = libcairo-script-interpreter.la $(top_builddir)/src/libcairo.la $(CAIRO_LIBS)
if CAIRO_HAS_SCRIPT_SURFACE
EXTRA_PROGRAMS += csi-trace
csi_trace_SOURCES = csi-trace.c
csi_trace_LDADD = libcairo-script-interpreter.la $(top_builddir)/src/libcairo.la $(CAIRO_LIBS)
endif
EXTRA_DIST = \
COPYING

13
util/cairo-script/Makefile.sources
View file

@ -1,13 +0,0 @@
libcairo_script_interpreter_sources = \
cairo-script-file.c \
cairo-script-hash.c \
cairo-script-interpreter.c \
cairo-script-objects.c \
cairo-script-operators.c \
cairo-script-scanner.c \
cairo-script-stack.c \
$(NULL)
libcairo_script_interpreter_headers = \
cairo-script-private.h \
$(NULL)

10
util/cairo-script/Makefile.win32
View file

@ -1,10 +0,0 @@
top_srcdir = ../../
include $(top_srcdir)/build/Makefile.win32.common
include $(top_srcdir)/util/cairo-script/Makefile.sources
all: inform $(CFG)/libcairo-script-interpreter.lib
libcairo_script_interpreter_OBJECTS = $(patsubst %.c, $(CFG)/%-static.obj, $(libcairo_script_interpreter_sources))
$(CFG)/libcairo-script-interpreter.lib: $(libcairo_script_interpreter_OBJECTS)
@$(AR) $(CAIRO_ARFLAGS) -OUT:$@ $(libcairo_script_interpreter_OBJECTS)

10
util/cairo-script/examples/Makefile.am
View file

@ -1,10 +0,0 @@
EXTRA_DIST = \
dragon.cs \
hilbert.cs \
infinichess.cs \
interference.cs \
pythagoras-tree.cs \
sierpinski.cs \
wedgeAnnulus_crop_ybRings.cs \
world-map.cs \
zrusin.cs

43
util/cairo-sphinx/Makefile.am
View file

@ -1,43 +0,0 @@
cairolibdir = $(libdir)/cairo
cairolib_LTLIBRARIES = cairo-sphinx.la
bin_PROGRAMS = cairo-sphinx
AM_CPPFLAGS = -I$(top_srcdir)/src \
-I$(top_builddir)/src \
-I$(top_srcdir)/boilerplate \
-I$(top_srcdir)/util/cairo-script
cairo_sphinx_la_SOURCES = fdr.c
cairo_sphinx_la_CPPFLAGS = $(AM_CPPFLAGS)
cairo_sphinx_la_CFLAGS = $(CAIRO_CFLAGS)
cairo_sphinx_la_LDFLAGS = -module -no-undefined -avoid-version
if CAIRO_HAS_DL
cairo_sphinx_la_LIBADD = -ldl
endif
cairo_sphinx_SOURCES = sphinx.c
cairo_sphinx_CPPFLAGS = $(AM_CPPFLAGS) -DLIBDIR="\"$(cairolibdir)\""
cairo_sphinx_CFLAGS = $(CAIRO_CFLAGS) $(real_pthread_CFLAGS) $(glib_CFLAGS)
cairo_sphinx_LDADD = \
$(real_pthread_LIBS) \
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la \
$(top_builddir)/boilerplate/libcairoboilerplate.la \
$(top_builddir)/src/libcairo.la \
$(glib_LIBS) \
$(CAIRO_LDADD) \
$(shm_LIBS)
cairo_sphinx_DEPENDENCIES = \
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la \
$(top_builddir)/boilerplate/libcairoboilerplate.la \
$(top_builddir)/src/libcairo.la
# Install rules to rebuild the libraries and add explicit dependencies
$(top_builddir)/boilerplate/libcairoboilerplate.la: $(top_builddir)/src/libcairo.la
cd $(top_builddir)/boilerplate && $(MAKE) $(AM_MAKEFLAGS) libcairoboilerplate.la
$(top_builddir)/src/libcairo.la:
cd $(top_builddir)/src && $(MAKE) $(AM_MAKEFLAGS) libcairo.la
$(top_builddir)/util/cairo-script/libcairo-script-interpreter.la: $(top_builddir)/src/libcairo.la
cd $(top_builddir)/util/cairo-script && $(MAKE) $(AM_MAKEFLAGS) libcairo-script-interpreter.la

40
util/cairo-trace/Makefile.am
View file

@ -1,40 +0,0 @@
cairolibdir = $(libdir)/cairo
cairooutdir = $(localstatedir)/lib/cairo-trace
bin_SCRIPTS = cairo-trace
cairolib_LTLIBRARIES = libcairo-trace.la
AM_CPPFLAGS = -I$(top_srcdir)/src \
-I$(top_builddir)/src
libcairo_trace_la_SOURCES = trace.c
libcairo_trace_la_CPPFLAGS = -DCAIRO_TRACE_OUTDIR="\"$(cairooutdir)\"" \
$(AM_CPPFLAGS)
libcairo_trace_la_CFLAGS = $(CAIRO_CFLAGS) $(real_pthread_CFLAGS)
libcairo_trace_la_LDFLAGS = -module -no-undefined -avoid-version
libcairo_trace_la_LIBADD = $(real_pthread_LIBS) -lz
if CAIRO_HAS_DL
libcairo_trace_la_LIBADD += -ldl
endif
if CAIRO_HAS_SYMBOL_LOOKUP
libcairo_trace_la_SOURCES += \
lookup-symbol.c \
lookup-symbol.h
libcairo_trace_la_LIBADD += $(BFD_LIBS)
endif
system-install: install
-mkdir -p $(cairooutdir)
-chmod 01777 $(cairooutdir)
grep -sq $(cairolibdir)/libcairo-trace.so /etc/ld.so.preload || echo $(cairolibdir)/libcairo-trace.so >> /etc/ld.so.preload
system-uninstall: uninstall
sed -e '/libcairo-trace.so/d' < /etc/ld.so.preload > /tmp/ld.so.preload && mv /tmp/ld.so.preload /etc/ld.so.preload;
EXTRA_DIST = \
COPYING \
COPYING-GPL-3 \
cairo-trace.in