OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [config/] [acx.m4] - Blame information for rev 83

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 26 khays
# Autoconf M4 include file defining utility macros for complex Canadian
2
# cross builds.
3
 
4
dnl ####
5
dnl # _GCC_TOPLEV_NONCANONICAL_BUILD
6
dnl # $build_alias or canonical $build if blank.
7
dnl # Used when we would use $build_alias, but empty is not OK.
8
AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_BUILD],
9
[AC_REQUIRE([AC_CANONICAL_BUILD]) []dnl
10
case ${build_alias} in
11
  "") build_noncanonical=${build} ;;
12
  *) build_noncanonical=${build_alias} ;;
13
esac
14
]) []dnl # _GCC_TOPLEV_NONCANONICAL_BUILD
15
 
16
dnl ####
17
dnl # _GCC_TOPLEV_NONCANONICAL_HOST
18
dnl # $host_alias, or $build_noncanonical if blank.
19
dnl # Used when we would use $host_alias, but empty is not OK.
20
AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_HOST],
21
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl
22
case ${host_alias} in
23
  "") host_noncanonical=${build_noncanonical} ;;
24
  *) host_noncanonical=${host_alias} ;;
25
esac
26
]) []dnl # _GCC_TOPLEV_NONCANONICAL_HOST
27
 
28
dnl ####
29
dnl # _GCC_TOPLEV_NONCANONICAL_TARGET
30
dnl # $target_alias or $host_noncanonical if blank.
31
dnl # Used when we would use $target_alias, but empty is not OK.
32
AC_DEFUN([_GCC_TOPLEV_NONCANONICAL_TARGET],
33
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl
34
case ${target_alias} in
35
  "") target_noncanonical=${host_noncanonical} ;;
36
  *) target_noncanonical=${target_alias} ;;
37
esac
38
]) []dnl # _GCC_TOPLEV_NONCANONICAL_TARGET
39
 
40
dnl ####
41
dnl # ACX_NONCANONICAL_BUILD
42
dnl # Like underscored version, but AC_SUBST's.
43
AC_DEFUN([ACX_NONCANONICAL_BUILD],
44
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl
45
AC_SUBST(build_noncanonical)
46
]) []dnl # ACX_NONCANONICAL_BUILD
47
 
48
dnl ####
49
dnl # ACX_NONCANONICAL_HOST
50
dnl # Like underscored version, but AC_SUBST's.
51
AC_DEFUN([ACX_NONCANONICAL_HOST],
52
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_HOST]) []dnl
53
AC_SUBST(host_noncanonical)
54
]) []dnl # ACX_NONCANONICAL_HOST
55
 
56
dnl ####
57
dnl # ACX_NONCANONICAL_TARGET
58
dnl # Like underscored version, but AC_SUBST's.
59
AC_DEFUN([ACX_NONCANONICAL_TARGET],
60
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl
61
AC_SUBST(target_noncanonical)
62
]) []dnl # ACX_NONCANONICAL_TARGET
63
 
64
dnl ####
65
dnl # GCC_TOPLEV_SUBDIRS
66
dnl # GCC & friends build 'build', 'host', and 'target' tools.  These must
67
dnl # be separated into three well-known subdirectories of the build directory:
68
dnl # build_subdir, host_subdir, and target_subdir.  The values are determined
69
dnl # here so that they can (theoretically) be changed in the future.  They
70
dnl # were previously reproduced across many different files.
71
dnl #
72
dnl # This logic really amounts to very little with autoconf 2.13; it will
73
dnl # amount to a lot more with autoconf 2.5x.
74
AC_DEFUN([GCC_TOPLEV_SUBDIRS],
75
[AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_TARGET]) []dnl
76
AC_REQUIRE([_GCC_TOPLEV_NONCANONICAL_BUILD]) []dnl
77
 
78
# post-stage1 host modules use a different CC_FOR_BUILD so, in order to
79
# have matching libraries, they should use host libraries: Makefile.tpl
80
# arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
81
# However, they still use the build modules, because the corresponding
82
# host modules (e.g. bison) are only built for the host when bootstrap
83
# finishes. So:
84
# - build_subdir is where we find build modules, and never changes.
85
# - build_libsubdir is where we find build libraries, and can be overridden.
86
 
87
# Prefix 'build-' so this never conflicts with target_subdir.
88
build_subdir="build-${build_noncanonical}"
89
AC_ARG_WITH(build-libsubdir,
90
[  --with-build-libsubdir=[DIR]  Directory where to find libraries for build system],
91
build_libsubdir="$withval",
92
build_libsubdir="$build_subdir")
93
# --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
94
if ( test $srcdir = . && test -d gcc ) \
95
   || test -d $srcdir/../host-${host_noncanonical}; then
96
  host_subdir="host-${host_noncanonical}"
97
else
98
  host_subdir=.
99
fi
100
# No prefix.
101
target_subdir=${target_noncanonical}
102
AC_SUBST([build_libsubdir]) []dnl
103
AC_SUBST([build_subdir]) []dnl
104
AC_SUBST([host_subdir]) []dnl
105
AC_SUBST([target_subdir]) []dnl
106
]) []dnl # GCC_TOPLEV_SUBDIRS
107
 
108
 
109
####
110
# _NCN_TOOL_PREFIXES:  Some stuff that oughtta be done in AC_CANONICAL_SYSTEM
111
# or AC_INIT.
112
# These demand that AC_CANONICAL_SYSTEM be called beforehand.
113
AC_DEFUN([_NCN_TOOL_PREFIXES],
114
[ncn_tool_prefix=
115
test -n "$host_alias" && ncn_tool_prefix=$host_alias-
116
ncn_target_tool_prefix=
117
test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
118
]) []dnl # _NCN_TOOL_PREFIXES
119
 
120
####
121
# NCN_STRICT_CHECK_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path])
122
# Like plain AC_CHECK_TOOLS, but require prefix if build!=host.
123
 
124
AC_DEFUN([NCN_STRICT_CHECK_TOOLS],
125
[AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl
126
AC_ARG_VAR([$1], [$1 for the host])
127
 
128
if test -n "[$]$1"; then
129
  ac_cv_prog_$1=[$]$1
130
elif test -n "$ac_cv_prog_$1"; then
131
  $1=$ac_cv_prog_$1
132
fi
133
 
134
if test -n "$ac_cv_prog_$1"; then
135
  for ncn_progname in $2; do
136
    AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
137
  done
138
fi
139
 
140
for ncn_progname in $2; do
141
  if test -n "$ncn_tool_prefix"; then
142
    AC_CHECK_PROG([$1], [${ncn_tool_prefix}${ncn_progname}],
143
                  [${ncn_tool_prefix}${ncn_progname}], , [$4])
144
  fi
145
  if test -z "$ac_cv_prog_$1" && test $build = $host ; then
146
    AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
147
  fi
148
  test -n "$ac_cv_prog_$1" && break
149
done
150
 
151
if test -z "$ac_cv_prog_$1" ; then
152
  ifelse([$3],[], [set dummy $2
153
  if test $build = $host ; then
154
    $1="[$]2"
155
  else
156
    $1="${ncn_tool_prefix}[$]2"
157
  fi], [$1="$3"])
158
fi
159
]) []dnl # NCN_STRICT_CHECK_TOOLS
160
 
161
####
162
# NCN_STRICT_CHECK_TARGET_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path])
163
# Like CVS Autoconf AC_CHECK_TARGET_TOOLS, but require prefix if build!=target.
164
 
165
AC_DEFUN([NCN_STRICT_CHECK_TARGET_TOOLS],
166
[AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl
167
AC_ARG_VAR([$1], patsubst([$1], [_FOR_TARGET$], [])[ for the target])
168
 
169
if test -n "[$]$1"; then
170
  ac_cv_prog_$1=[$]$1
171
elif test -n "$ac_cv_prog_$1"; then
172
  $1=$ac_cv_prog_$1
173
fi
174
 
175
if test -n "$ac_cv_prog_$1"; then
176
  for ncn_progname in $2; do
177
    AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
178
  done
179
fi
180
 
181
if test -z "$ac_cv_prog_$1" && test -n "$with_build_time_tools"; then
182
  for ncn_progname in $2; do
183
    AC_MSG_CHECKING([for ${ncn_progname} in $with_build_time_tools])
184
    if test -x $with_build_time_tools/${ncn_progname}; then
185
      ac_cv_prog_$1=$with_build_time_tools/${ncn_progname}
186
      AC_MSG_RESULT(yes)
187
      break
188
    else
189
      AC_MSG_RESULT(no)
190
    fi
191
  done
192
fi
193
 
194
if test -z "$ac_cv_prog_$1"; then
195
  for ncn_progname in $2; do
196
    if test -n "$ncn_target_tool_prefix"; then
197
      AC_CHECK_PROG([$1], [${ncn_target_tool_prefix}${ncn_progname}],
198
                    [${ncn_target_tool_prefix}${ncn_progname}], , [$4])
199
    fi
200
    if test -z "$ac_cv_prog_$1" && test $build = $target ; then
201
      AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
202
    fi
203
    test -n "$ac_cv_prog_$1" && break
204
  done
205
fi
206
 
207
if test -z "$ac_cv_prog_$1" ; then
208
  ifelse([$3],[], [set dummy $2
209
  if test $build = $target ; then
210
    $1="[$]2"
211
  else
212
    $1="${ncn_target_tool_prefix}[$]2"
213
  fi], [$1="$3"])
214
else
215
  $1="$ac_cv_prog_$1"
216
fi
217
]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS
218
 
219
 
220
# Backported from Autoconf 2.5x; can go away when and if
221
# we switch.  Put the OS path separator in $PATH_SEPARATOR.
222
AC_DEFUN([ACX_PATH_SEP], [
223
# The user is always right.
224
if test "${PATH_SEPARATOR+set}" != set; then
225
  echo "#! /bin/sh" >conf$$.sh
226
  echo  "exit 0"   >>conf$$.sh
227
  chmod +x conf$$.sh
228
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
229
    PATH_SEPARATOR=';'
230
  else
231
    PATH_SEPARATOR=:
232
  fi
233
  rm -f conf$$.sh
234
fi
235
])
236
 
237
 
238
AC_DEFUN([ACX_TOOL_DIRS], [
239
AC_REQUIRE([ACX_PATH_SEP])
240
if test "x$exec_prefix" = xNONE; then
241
        if test "x$prefix" = xNONE; then
242
                gcc_cv_tool_prefix=$ac_default_prefix
243
        else
244
                gcc_cv_tool_prefix=$prefix
245
        fi
246
else
247
        gcc_cv_tool_prefix=$exec_prefix
248
fi
249
 
250
# If there is no compiler in the tree, use the PATH only.  In any
251
# case, if there is no compiler in the tree nobody should use
252
# AS_FOR_TARGET and LD_FOR_TARGET.
253
if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
254
    gcc_version=`cat $srcdir/gcc/BASE-VER`
255
    gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
256
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
257
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
258
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
259
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
260
    gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
261
else
262
    gcc_cv_tool_dirs=
263
fi
264
 
265
if test x$build = x$target && test -n "$md_exec_prefix"; then
266
        gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
267
fi
268
 
269
]) []dnl # ACX_TOOL_DIRS
270
 
271
# ACX_HAVE_GCC_FOR_TARGET
272
# Check if the variable GCC_FOR_TARGET really points to a GCC binary.
273
AC_DEFUN([ACX_HAVE_GCC_FOR_TARGET], [
274
cat > conftest.c << \EOF
275
#ifdef __GNUC__
276
  gcc_yay;
277
#endif
278
EOF
279
if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
280
  have_gcc_for_target=yes
281
else
282
  GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
283
  have_gcc_for_target=no
284
fi
285
rm conftest.c
286
])
287
 
288
# ACX_CHECK_INSTALLED_TARGET_TOOL(VAR, PROG)
289
# Searching for installed target binutils.  We need to take extra care,
290
# else we may find the wrong assembler, linker, etc., and lose.
291
#
292
# First try --with-build-time-tools, if specified.
293
#
294
# For build != host, we ask the installed GCC for the name of the tool it
295
# uses, and accept it if it is an absolute path.  This is because the
296
# only good choice for a compiler is the same GCC version that is being
297
# installed (or we couldn't make target libraries), and we assume that
298
# on the host system we'll have not only the same GCC version, but also
299
# the same binutils version.
300
#
301
# For build == host, search the same directories that the installed
302
# compiler will search.  We used to do this for the assembler, linker,
303
# and nm only; for simplicity of configuration, however, we extend this
304
# criterion to tools (such as ar and ranlib) that are never invoked by
305
# the compiler, to avoid mismatches.
306
#
307
# Also note we have to check MD_EXEC_PREFIX before checking the user's path
308
# if build == target.  This makes the most sense only when bootstrapping,
309
# but we also do so when build != host.  In this case, we hope that the
310
# build and host systems will have similar contents of MD_EXEC_PREFIX.
311
#
312
# If we do not find a suitable binary, then try the user's path.
313
 
314
AC_DEFUN([ACX_CHECK_INSTALLED_TARGET_TOOL], [
315
AC_REQUIRE([ACX_TOOL_DIRS])
316
AC_REQUIRE([ACX_HAVE_GCC_FOR_TARGET])
317
if test -z "$ac_cv_path_$1" ; then
318
  if test -n "$with_build_time_tools"; then
319
    AC_MSG_CHECKING([for $2 in $with_build_time_tools])
320
    if test -x $with_build_time_tools/$2; then
321
      $1=`cd $with_build_time_tools && pwd`/$2
322
      ac_cv_path_$1=[$]$1
323
      AC_MSG_RESULT([$ac_cv_path_$1])
324
    else
325
      AC_MSG_RESULT(no)
326
    fi
327
  elif test $build != $host && test $have_gcc_for_target = yes; then
328
    $1=`$GCC_FOR_TARGET --print-prog-name=$2`
329
    test [$]$1 = $2 && $1=
330
    test -n "[$]$1" && ac_cv_path_$1=[$]$1
331
  fi
332
fi
333
if test -z "$ac_cv_path_$1" && test -n "$gcc_cv_tool_dirs"; then
334
  AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs])
335
fi
336
if test -z "$ac_cv_path_$1" ; then
337
  NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2])
338
else
339
  $1=$ac_cv_path_$1
340
fi
341
]) []dnl # ACX_CHECK_INSTALLED_TARGET_TOOL
342
 
343
###
344
# AC_PROG_CPP_WERROR
345
# Used for autoconf 2.5x to force AC_PREPROC_IFELSE to reject code which
346
# triggers warnings from the preprocessor.  Will be in autoconf 2.58.
347
# For now, using this also overrides header checks to use only the
348
# preprocessor (matches 2.13 behavior; matching 2.58's behavior is a
349
# bit harder from here).
350
# Eventually autoconf will default to checking headers with the compiler
351
# instead, and we'll have to do this differently.
352
 
353
AC_DEFUN([AC_PROG_CPP_WERROR],
354
[AC_REQUIRE([AC_PROG_CPP])dnl
355
m4_define([AC_CHECK_HEADER],m4_defn([_AC_CHECK_HEADER_OLD]))
356
ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
357
 
358
# Test for GNAT.
359
# We require the gnatbind program, and a compiler driver that
360
# understands Ada.  We use the user's CC setting, already found,
361
# and possibly add $1 to the command-line parameters.
362
#
363
# Sets the shell variable have_gnat to yes or no as appropriate, and
364
# substitutes GNATBIND and GNATMAKE.
365
AC_DEFUN([ACX_PROG_GNAT],
366
[AC_REQUIRE([AC_CHECK_TOOL_PREFIX])
367
AC_REQUIRE([AC_PROG_CC])
368
AC_CHECK_TOOL(GNATBIND, gnatbind, no)
369
AC_CHECK_TOOL(GNATMAKE, gnatmake, no)
370
AC_CACHE_CHECK([whether compiler driver understands Ada],
371
                 acx_cv_cc_gcc_supports_ada,
372
[cat >conftest.adb <<EOF
373
procedure conftest is begin null; end conftest;
374
EOF
375
acx_cv_cc_gcc_supports_ada=no
376
# There is a bug in old released versions of GCC which causes the
377
# driver to exit successfully when the appropriate language module
378
# has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
379
# Therefore we must check for the error message as well as an
380
# unsuccessful exit.
381
# Other compilers, like HP Tru64 UNIX cc, exit successfully when
382
# given a .adb file, but produce no object file.  So we must check
383
# if an object file was really produced to guard against this.
384
errors=`(${CC} $1[]m4_ifval([$1], [ ])-c conftest.adb) 2>&1 || echo failure`
385
if test x"$errors" = x && test -f conftest.$ac_objext; then
386
  acx_cv_cc_gcc_supports_ada=yes
387
fi
388
rm -f conftest.*])
389
 
390
if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
391
  have_gnat=yes
392
else
393
  have_gnat=no
394
fi
395
])
396
 
397
dnl 'make compare' can be significantly faster, if cmp itself can
398
dnl skip bytes instead of using tail.  The test being performed is
399
dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
400
dnl but we need to sink errors and handle broken shells.  We also test
401
dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
402
dnl accepted by cmp on some systems.
403
AC_DEFUN([ACX_PROG_CMP_IGNORE_INITIAL],
404
[AC_CACHE_CHECK([how to compare bootstrapped objects], gcc_cv_prog_cmp_skip,
405
[ echo abfoo >t1
406
  echo cdfoo >t2
407
  gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
408
  if cmp t1 t2 2 2 > /dev/null 2>&1; then
409
    if cmp t1 t2 1 1 > /dev/null 2>&1; then
410
      :
411
    else
412
      gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
413
    fi
414
  fi
415
  if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
416
    if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
417
      :
418
    else
419
      gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
420
    fi
421
  fi
422
  rm t1 t2
423
])
424
do_compare="$gcc_cv_prog_cmp_skip"
425
AC_SUBST(do_compare)
426
])
427
 
428
dnl See whether we can include both string.h and strings.h.
429
AC_DEFUN([ACX_HEADER_STRING],
430
[AC_CACHE_CHECK([whether string.h and strings.h may both be included],
431
  gcc_cv_header_string,
432
[AC_TRY_COMPILE([#include <string.h>
433
#include <strings.h>], , gcc_cv_header_string=yes, gcc_cv_header_string=no)])
434
if test $gcc_cv_header_string = yes; then
435
  AC_DEFINE(STRING_WITH_STRINGS, 1, [Define if you can safely include both <string.h> and <strings.h>.])
436
fi
437
])
438
 
439
dnl See if stdbool.h properly defines bool and true/false.
440
dnl Check whether _Bool is built-in.
441
AC_DEFUN([ACX_HEADER_STDBOOL],
442
[AC_CACHE_CHECK([for working stdbool.h],
443
  ac_cv_header_stdbool_h,
444
[AC_TRY_COMPILE([#include <stdbool.h>],
445
[bool foo = false;],
446
ac_cv_header_stdbool_h=yes, ac_cv_header_stdbool_h=no)])
447
if test $ac_cv_header_stdbool_h = yes; then
448
  AC_DEFINE(HAVE_STDBOOL_H, 1,
449
  [Define if you have a working <stdbool.h> header file.])
450
fi
451
AC_CACHE_CHECK(for built-in _Bool, gcc_cv_c__bool,
452
[AC_TRY_COMPILE(,
453
[_Bool foo;],
454
gcc_cv_c__bool=yes, gcc_cv_c__bool=no)
455
])
456
if test $gcc_cv_c__bool = yes; then
457
  AC_DEFINE(HAVE__BOOL, 1, [Define if the \`_Bool' type is built-in.])
458
fi
459
])
460
 
461
dnl See if hard links work and if not, try to substitute $1 or simple copy.
462
AC_DEFUN([ACX_PROG_LN],
463
[AC_MSG_CHECKING(whether ln works)
464
AC_CACHE_VAL(acx_cv_prog_LN,
465
[rm -f conftestdata_t
466
echo >conftestdata_f
467
if ln conftestdata_f conftestdata_t 2>/dev/null
468
then
469
  acx_cv_prog_LN=ln
470
else
471
  acx_cv_prog_LN=no
472
fi
473
rm -f conftestdata_f conftestdata_t
474
])dnl
475
if test $acx_cv_prog_LN = no; then
476
  LN="ifelse([$1],,cp,[$1])"
477
  AC_MSG_RESULT([no, using $LN])
478
else
479
  LN="$acx_cv_prog_LN"
480
  AC_MSG_RESULT(yes)
481
fi
482
AC_SUBST(LN)dnl
483
])
484
 
485
dnl GCC_TARGET_TOOL(PROGRAM, TARGET-VAR, HOST-VAR, IN-TREE-TOOL, LANGUAGE)
486
AC_DEFUN([GCC_TARGET_TOOL],
487
[AC_MSG_CHECKING(where to find the target $1)
488
if test "x${build}" != "x${host}" ; then
489
  if expr "x[$]$2" : "x/" > /dev/null; then
490
    # We already found the complete path
491
    ac_dir=`dirname [$]$2`
492
    AC_MSG_RESULT(pre-installed in $ac_dir)
493
  else
494
    # Canadian cross, just use what we found
495
    AC_MSG_RESULT(pre-installed)
496
  fi
497
else
498
  ifelse([$4],,,
499
  [ok=yes
500
  case " ${configdirs} " in
501
    *" patsubst([$4], [/.*], []) "*) ;;
502
    *) ok=no ;;
503
  esac
504
  ifelse([$5],,,
505
  [case ,${enable_languages}, in
506
    *,$5,*) ;;
507
    *) ok=no ;;
508
  esac])
509
  if test $ok = yes; then
510
    # An in-tree tool is available and we can use it
511
    $2='$$r/$(HOST_SUBDIR)/$4'
512
    AC_MSG_RESULT(just compiled)
513
  el])if expr "x[$]$2" : "x/" > /dev/null; then
514
    # We already found the complete path
515
    ac_dir=`dirname [$]$2`
516
    AC_MSG_RESULT(pre-installed in $ac_dir)
517
  elif test "x$target" = "x$host"; then
518
    # We can use an host tool
519
    $2='$($3)'
520
    AC_MSG_RESULT(host tool)
521
  else
522
    # We need a cross tool
523
    AC_MSG_RESULT(pre-installed)
524
  fi
525
fi
526
AC_SUBST($2)])
527
 
528
 
529
dnl Locate a program and check that its version is acceptable.
530
dnl ACX_PROG_CHECK_VER(var, name, version-switch,
531
dnl                    version-extract-regexp, version-glob)
532
AC_DEFUN([ACX_CHECK_PROG_VER],[
533
  AC_CHECK_PROG([$1], [$2], [$2])
534
  if test -n "[$]$1"; then
535
    # Found it, now check the version.
536
    AC_CACHE_CHECK([for modern $2],
537
                   [gcc_cv_prog_$2_modern],
538
                   [ac_prog_version=`eval [$]$1 $3 2>&1 |
539
                                     sed -n 's/^.*patsubst([[$4]],/,\/).*$/\1/p'`
540
 
541
                    [case $ac_prog_version in
542
                      '')  gcc_cv_prog_$2_modern=no;;
543
                      $5)  gcc_cv_prog_$2_modern=yes;;
544
                      *)   gcc_cv_prog_$2_modern=no;;
545
                    esac]
546
                   ])
547
  else
548
    gcc_cv_prog_$2_modern=no
549
  fi
550
  if test $gcc_cv_prog_$2_modern = no; then
551
    $1="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing $2"
552
  fi
553
])
554
 
555
dnl Support the --with-pkgversion configure option.
556
dnl ACX_PKGVERSION(default-pkgversion)
557
AC_DEFUN([ACX_PKGVERSION],[
558
  AC_ARG_WITH(pkgversion,
559
    AS_HELP_STRING([--with-pkgversion=PKG],
560
                   [Use PKG in the version string in place of "$1"]),
561
    [case "$withval" in
562
      yes) AC_MSG_ERROR([package version not specified]) ;;
563
      no)  PKGVERSION= ;;
564
      *)   PKGVERSION="($withval) " ;;
565
     esac],
566
    PKGVERSION="($1) "
567
  )
568
  AC_SUBST(PKGVERSION)
569
])
570
 
571
dnl Support the --with-bugurl configure option.
572
dnl ACX_BUGURL(default-bugurl)
573
AC_DEFUN([ACX_BUGURL],[
574
  AC_ARG_WITH(bugurl,
575
    AS_HELP_STRING([--with-bugurl=URL],
576
                   [Direct users to URL to report a bug]),
577
    [case "$withval" in
578
      yes) AC_MSG_ERROR([bug URL not specified]) ;;
579
      no)  BUGURL=
580
           ;;
581
      *)   BUGURL="$withval"
582
           ;;
583
     esac],
584
     BUGURL="$1"
585
  )
586
  case ${BUGURL} in
587
  "")
588
    REPORT_BUGS_TO=
589
    REPORT_BUGS_TEXI=
590
    ;;
591
  *)
592
    REPORT_BUGS_TO="<$BUGURL>"
593
    REPORT_BUGS_TEXI=@uref{`echo "$BUGURL" | sed 's/@/@@/g'`}
594
    ;;
595
  esac;
596
  AC_SUBST(REPORT_BUGS_TO)
597
  AC_SUBST(REPORT_BUGS_TEXI)
598
])
599
 
600
dnl ####
601
dnl # ACX_CHECK_CYGWIN_CAT_WORKS
602
dnl # On Cygwin hosts, check that the cat command ignores
603
dnl # carriage returns as otherwise builds will not work.
604
dnl # See binutils PR 4334 for more details.
605
AC_DEFUN([ACX_CHECK_CYGWIN_CAT_WORKS],[
606
AC_MSG_CHECKING([to see if cat works as expected])
607
echo a >cygwin-cat-check
608
if test `cat cygwin-cat-check` = a ; then
609
  rm cygwin-cat-check
610
  AC_MSG_RESULT(yes)
611
else
612
  rm cygwin-cat-check
613
  AC_MSG_RESULT(no)
614
  AC_MSG_ERROR([The cat command does not ignore carriage return characters.
615
  Please either mount the build directory in binary mode or run the following
616
  commands before running any configure script:
617
set -o igncr
618
export SHELLOPTS
619
  ])
620
fi
621
])

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.