1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
dnl --------------------------------------------------------------------------
dnl PA_SYM(prefix, string)
dnl
dnl Convert a (semi-) arbitrary string to a CPP symbol
dnl --------------------------------------------------------------------------
AC_DEFUN(PA_SYM,
[[$1]m4_bpatsubsts(m4_toupper([$2]),[[^ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789]+],[_],[^._?\(.*\)_.$],[[\1]])])
dnl --------------------------------------------------------------------------
dnl PA_ADD_CFLAGS(flag [,actual_flag])
dnl
dnl Attempt to add the given option to CFLAGS, if it doesn't break
dnl compilation. If the option to be tested is different than the
dnl option that should actually be added, add the option to be
dnl actually added as a second argument.
dnl --------------------------------------------------------------------------
AC_DEFUN(PA_ADD_CFLAGS,
[AC_MSG_CHECKING([if $CC accepts $1])
pa_add_cflags__old_cflags="$CFLAGS"
CFLAGS="$CFLAGS $1"
AC_TRY_LINK(AC_INCLUDES_DEFAULT,
[printf("Hello, World!\n");],
[AC_MSG_RESULT([yes])
CFLAGS="$pa_add_cflags__old_cflags ifelse([$2],[],[$1],[$2])"
AC_DEFINE(PA_SYM([CFLAG_],[$1]), 1,
[Define to 1 if compiled with the `$1' compiler flag])],
[AC_MSG_RESULT([no])
CFLAGS="$pa_add_cflags__old_cflags"])])
dnl --------------------------------------------------------------------------
dnl PA_ADD_CLDFLAGS(flag [,actual_flag])
dnl
dnl Attempt to add the given option to CFLAGS and LDFLAGS,
dnl if it doesn't break compilation
dnl --------------------------------------------------------------------------
AC_DEFUN(PA_ADD_CLDFLAGS,
[AC_MSG_CHECKING([if $CC accepts $1])
pa_add_cldflags__old_cflags="$CFLAGS"
CFLAGS="$CFLAGS $1"
pa_add_cldflags__old_ldflags="$LDFLAGS"
LDFLAGS="$LDFLAGS $1"
AC_TRY_LINK(AC_INCLUDES_DEFAULT,
[printf("Hello, World!\n");],
[AC_MSG_RESULT([yes])
CFLAGS="$pa_add_cldflags__old_cflags ifelse([$2],[],[$1],[$2])"
LDFLAGS="$pa_add_cldflags__old_ldflags ifelse([$2],[],[$1],[$2])"
AC_DEFINE(PA_SYM([CFLAG_],[$1]), 1,
[Define to 1 if compiled with the `$1' compiler flag])],
[AC_MSG_RESULT([no])
CFLAGS="$pa_add_cldflags__old_cflags"
LDFLAGS="$pa_add_cldflags__old_ldflags"])])
dnl --------------------------------------------------------------------------
dnl PA_HAVE_FUNC(func_name)
dnl
dnl Look for a function with the specified arguments which could be
dnl a builtin/intrinsic function.
dnl --------------------------------------------------------------------------
AC_DEFUN(PA_HAVE_FUNC,
[AC_MSG_CHECKING([for $1])
AC_LINK_IFELSE([AC_LANG_SOURCE([
AC_INCLUDES_DEFAULT
int main(void) {
(void)$1$2;
return 0;
}
])],
[AC_MSG_RESULT([yes])
AC_DEFINE(AS_TR_CPP([HAVE_$1]), 1,
[Define to 1 if you have the `$1' intrinsic function.])],
[AC_MSG_RESULT([no])])
])
dnl --------------------------------------------------------------------------
dnl PA_LIBEXT
dnl
dnl Guess the library extension based on the object extension
dnl --------------------------------------------------------------------------
AC_DEFUN(PA_LIBEXT,
[AC_MSG_CHECKING([for suffix of library files])
if test x"$LIBEXT" = x; then
case "$OBJEXT" in
obj )
LIBEXT=lib
;;
*)
LIBEXT=a
;;
esac
fi
AC_MSG_RESULT([$LIBEXT])
AC_SUBST([LIBEXT])])
dnl --------------------------------------------------------------------------
dnl PA_FUNC_ATTRIBUTE(attribute_name)
dnl
dnl See if this compiler supports the equivalent of a specific gcc
dnl attribute on a function, using the __attribute__(()) syntax.
dnl All arguments except the attribute name are optional.
dnl PA_FUNC_ATTRIBUTE(attribute, attribute_opts, return_type,
dnl prototype_args, call_args)
dnl --------------------------------------------------------------------------
AC_DEFUN(PA_FUNC_ATTRIBUTE,
[AC_MSG_CHECKING([if $CC supports the $1 function attribute])
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
AC_INCLUDES_DEFAULT
extern ifelse([$3],[],[void *],[$3]) __attribute__(($1$2))
bar(ifelse([$4],[],[int],[$4]));
ifelse([$3],[],[void *],[$3]) foo(void);
ifelse([$3],[],[void *],[$3]) foo(void)
{
ifelse([$3],[void],[],[return])
bar(ifelse([$5],[],[1],[$5]));
}
])],
[AC_MSG_RESULT([yes])
AC_DEFINE(PA_SYM([HAVE_FUNC_ATTRIBUTE_],[$1]), 1,
[Define to 1 if your compiler supports __attribute__(($1)) on functions])],
[AC_MSG_RESULT([no])])
])
dnl --------------------------------------------------------------------------
dnl PA_FUNC_ATTRIBUTE_ERROR
dnl
dnl See if this compiler supports __attribute__((error("foo")))
dnl The generic version of this doesn't work as it makes the compiler
dnl throw an error by design.
dnl --------------------------------------------------------------------------
AC_DEFUN(PA_FUNC_ATTRIBUTE_ERROR,
[AC_MSG_CHECKING([if $CC supports the error function attribute])
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
AC_INCLUDES_DEFAULT
extern void __attribute__((error("message"))) barf(void);
void foo(void);
void foo(void)
{
if (0)
barf();
}
])],
[AC_MSG_RESULT([yes])
AC_DEFINE([HAVE_FUNC_ATTRIBUTE_ERROR], 1,
[Define to 1 if your compiler supports __attribute__((error)) on functions])],
[AC_MSG_RESULT([no])])
])
dnl --------------------------------------------------------------------------
dnl PA_ARG_ENABLED(option, helptext [,enabled_action [,disabled_action]])
dnl PA_ARG_DISABLED(option, helptext [,disabled_action [,enabled_action]])
dnl
dnl Simpler-to-use versions of AC_ARG_ENABLED, that include the
dnl test for $enableval and the AS_HELP_STRING definition
dnl --------------------------------------------------------------------------
AC_DEFUN(PA_ARG_ENABLED,
[AC_ARG_ENABLE([$1], [AS_HELP_STRING([--enable-$1],[$2])], [], [enableval=no])
AS_IF([test x"$enableval" != xno], [$3], [$4])
])
AC_DEFUN(PA_ARG_DISABLED,
[AC_ARG_ENABLE([$1],[AS_HELP_STRING([--disable-$1],[$2])], [], [enableval=yes])
AS_IF([test x"$enableval" = xno], [$3], [$4])
])
dnl --------------------------------------------------------------------------
dnl PA_ADD_HEADERS(headers...)
dnl
dnl Call AC_CHECK_HEADERS(), and add to ac_includes_default if found
dnl --------------------------------------------------------------------------
AC_DEFUN(_PA_ADD_HEADER,
[AC_CHECK_HEADERS([$1],[ac_includes_default="$ac_includes_default
#include <$1>"
])])
AC_DEFUN(PA_ADD_HEADERS,
[m4_map_args_w([$1],[_PA_ADD_HEADER(],[)])])
dnl --------------------------------------------------------------------------
dnl PA_CHECK_BAD_STDC_INLINE
dnl
dnl Some versions of gcc seem to apply -Wmissing-prototypes to C99
dnl inline functions, which means we need to use GNU inline syntax
dnl --------------------------------------------------------------------------
AC_DEFUN(PA_CHECK_BAD_STDC_INLINE,
[AC_MSG_CHECKING([if $CC supports C99 external inlines])
AC_COMPILE_IFELSE([AC_LANG_SOURCE([
AC_INCLUDES_DEFAULT
/* Don't mistake GNU inlines for c99 */
#ifdef __GNUC_GNU_INLINE__
# error "Using gnu inline standard"
#endif
inline int foo(int x)
{
return x+1;
}
])],
[AC_MSG_RESULT([yes])
AC_DEFINE(HAVE_STDC_INLINE, 1,
[Define to 1 if your compiler supports C99 extern inline])],
[AC_MSG_RESULT([no])
PA_ADD_CFLAGS([-fgnu89-inline])])])
|
