ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/Unix/config.guess

Comparing BasiliskII/src/Unix/config.guess (file contents):
Revision 1.1 by gbeauche, 2000-09-22T17:12:59Z vs.
Revision 1.3 by cebix, 2001-09-18T17:16:47Z

#	Line 1 | Line 1
1		#! /bin/sh
2		# Attempt to guess a canonical system name.
3	<	#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999
3	>	#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
4		#   Free Software Foundation, Inc.
5	<	#
5	>
6	>	timestamp='2001-04-20'
7	>
8		# This file is free software; you can redistribute it and/or modify it
9		# under the terms of the GNU General Public License as published by
10		# the Free Software Foundation; either version 2 of the License, or
#	Line 23 | Line 25
25		# the same distribution terms that you use for the rest of that program.
26
27		# Written by Per Bothner <bothner@cygnus.com>.
28	<	# The master version of this file is at the FSF in /home/gd/gnu/lib.
27	<	# Please send patches to the Autoconf mailing list <autoconf@gnu.org>.
28	>	# Please send patches to <config-patches@gnu.org>.
29		#
30		# This script attempts to guess a canonical system name similar to
31		# config.sub.  If it succeeds, it prints the system name on stdout, and
32		# exits with 0.  Otherwise, it exits with 1.
33		#
34		# The plan is that this can be called by configure scripts if you
35	<	# don't specify an explicit system type (host/target name).
35	<	#
36	<	# Only a few systems have been added to this list; please add others
37	<	# (but try to keep the structure clean).
38	<	#
35	>	# don't specify an explicit build system type.
36
37	<	# Use $HOST_CC if defined. $CC may point to a cross-compiler
38	<	if test x"$CC_FOR_BUILD" = x; then
39	<	if test x"$HOST_CC" != x; then
40	<	CC_FOR_BUILD="$HOST_CC"
41	<	else
42	<	if test x"$CC" != x; then
43	<	CC_FOR_BUILD="$CC"
44	<	else
45	<	CC_FOR_BUILD=cc
46	<	fi
47	<	fi
37	>	me=`echo "$0" | sed -e 's,.*/,,'`
38	>
39	>	usage="\
40	>	Usage: $0 [OPTION]
41	>
42	>	Output the configuration name of the system \`$me' is run on.
43	>
44	>	Operation modes:
45	>	-h, --help         print this help, then exit
46	>	-t, --time-stamp   print date of last modification, then exit
47	>	-v, --version      print version number, then exit
48	>
49	>	Report bugs and patches to <config-patches@gnu.org>."
50	>
51	>	version="\
52	>	GNU config.guess ($timestamp)
53	>
54	>	Originally written by Per Bothner.
55	>	Copyright (C) 1992, 93, 94, 95, 96, 97, 98, 99, 2000
56	>	Free Software Foundation, Inc.
57	>
58	>	This is free software; see the source for copying conditions.  There is NO
59	>	warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
60	>
61	>	help="
62	>	Try \`$me --help' for more information."
63	>
64	>	# Parse command line
65	>	while test $# -gt 0 ; do
66	>	case $1 in
67	>	--time-stamp | --time* | -t )
68	>	echo "$timestamp" ; exit 0 ;;
69	>	--version | -v )
70	>	echo "$version" ; exit 0 ;;
71	>	--help | --h* | -h )
72	>	echo "$usage"; exit 0 ;;
73	>	-- )     # Stop option processing
74	>	shift; break ;;
75	>	- ) # Use stdin as input.
76	>	break ;;
77	>	-* )
78	>	echo "$me: invalid option $1$help" >&2
79	>	exit 1 ;;
80	>	* )
81	>	break ;;
82	>	esac
83	>	done
84	>
85	>	if test $# != 0; then
86	>	echo "$me: too many arguments$help" >&2
87	>	exit 1
88		fi
89
90
91	+	dummy=dummy-$$
92	+	trap 'rm -f $dummy.c $dummy.o $dummy.rel $dummy; exit 1' 1 2 15
93	+
94	+	# CC_FOR_BUILD -- compiler used by this script.
95	+	# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
96	+	# use `HOST_CC' if defined, but it is deprecated.
97	+
98	+	case $CC_FOR_BUILD,$HOST_CC,$CC in
99	+	,,)    echo "int dummy(){}" > $dummy.c
100	+	for c in cc gcc c89 ; do
101	+	($c $dummy.c -c -o $dummy.o) >/dev/null 2>&1
102	+	if test $? = 0 ; then
103	+	CC_FOR_BUILD="$c"; break
104	+	fi
105	+	done
106	+	rm -f $dummy.c $dummy.o $dummy.rel
107	+	if test x"$CC_FOR_BUILD" = x ; then
108	+	CC_FOR_BUILD=no_compiler_found
109	+	fi
110	+	;;
111	+	,,*)   CC_FOR_BUILD=$CC ;;
112	+	,*,*)  CC_FOR_BUILD=$HOST_CC ;;
113	+	esac
114	+
115		# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
116		# (ghazi@noc.rutgers.edu 8/24/94.)
117		if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
#	Line 59 | Line 120 | fi
120
121		UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
122		UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
123	<	UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
123	>	UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
124		UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
125
65	–	dummy=dummy-$$
66	–	trap 'rm -f $dummy.c $dummy.o $dummy; exit 1' 1 2 15
67	–
126		# Note: order is significant - the case branches are not exclusive.
127
128		case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
129	+	*:NetBSD:*:*)
130	+	# Netbsd (nbsd) targets should (where applicable) match one or
131	+	# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
132	+	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
133	+	# switched to ELF, *-*-netbsd* would select the old
134	+	# object file format.  This provides both forward
135	+	# compatibility and a consistent mechanism for selecting the
136	+	# object file format.
137	+	# Determine the machine/vendor (is the vendor relevant).
138	+	case "${UNAME_MACHINE}" in
139	+	amiga) machine=m68k-unknown ;;
140	+	arm32) machine=arm-unknown ;;
141	+	atari*) machine=m68k-atari ;;
142	+	sun3*) machine=m68k-sun ;;
143	+	mac68k) machine=m68k-apple ;;
144	+	macppc) machine=powerpc-apple ;;
145	+	hp3[0-9][05]) machine=m68k-hp ;;
146	+	ibmrt|romp-ibm) machine=romp-ibm ;;
147	+	*) machine=${UNAME_MACHINE}-unknown ;;
148	+	esac
149	+	# The Operating System including object format, if it has switched
150	+	# to ELF recently, or will in the future.
151	+	case "${UNAME_MACHINE}" in
152	+	i386|sparc|amiga|arm*|hp300|mvme68k|vax|atari|luna68k|mac68k|news68k|next68k|pc532|sun3*|x68k)
153	+	if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
154	+	| grep __ELF__ >/dev/null
155	+	then
156	+	# Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
157	+	# Return netbsd for either.  FIX?
158	+	os=netbsd
159	+	else
160	+	os=netbsdelf
161	+	fi
162	+	;;
163	+	*)
164	+	os=netbsd
165	+	;;
166	+	esac
167	+	# The OS release
168	+	release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
169	+	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
170	+	# contains redundant information, the shorter form:
171	+	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
172	+	echo "${machine}-${os}${release}"
173	+	exit 0 ;;
174		alpha:OSF1:*:*)
175		if test $UNAME_RELEASE = "V4.0"; then
176		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
#	Line 77 | Line 180 | case "${UNAME_MACHINE}:${UNAME_SYSTEM}:$
180		# A Xn.n version is an unreleased experimental baselevel.
181		# 1.2 uses "1.2" for uname -r.
182		cat <<EOF >$dummy.s
183	+	.data
184	+	\$Lformat:
185	+	.byte 37,100,45,37,120,10,0     # "%d-%x\n"
186	+
187	+	.text
188		.globl main
189	+	.align 4
190		.ent main
191		main:
192	<	.frame \$30,0,\$26,0
193	<	.prologue 0
194	<	.long 0x47e03d80 # implver $0
195	<	lda \$2,259
196	<	.long 0x47e20c21 # amask $2,$1
197	<	srl \$1,8,\$2
198	<	sll \$2,2,\$2
199	<	sll \$0,3,\$0
200	<	addl \$1,\$0,\$0
201	<	addl \$2,\$0,\$0
202	<	ret \$31,(\$26),1
192	>	.frame \$30,16,\$26,0
193	>	ldgp \$29,0(\$27)
194	>	.prologue 1
195	>	.long 0x47e03d80 # implver \$0
196	>	lda \$2,-1
197	>	.long 0x47e20c21 # amask \$2,\$1
198	>	lda \$16,\$Lformat
199	>	mov \$0,\$17
200	>	not \$1,\$18
201	>	jsr \$26,printf
202	>	ldgp \$29,0(\$26)
203	>	mov 0,\$16
204	>	jsr \$26,exit
205		.end main
206		EOF
207		$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
208		if test "$?" = 0 ; then
209	<	./$dummy
210	<	case "$?" in
100	<	7)
209	>	case `./$dummy` in
210	>	0-0)
211		UNAME_MACHINE="alpha"
212		;;
213	<	15)
213	>	1-0)
214		UNAME_MACHINE="alphaev5"
215		;;
216	<	14)
216	>	1-1)
217		UNAME_MACHINE="alphaev56"
218		;;
219	<	10)
219	>	1-101)
220		UNAME_MACHINE="alphapca56"
221		;;
222	<	16)
222	>	2-303)
223		UNAME_MACHINE="alphaev6"
224		;;
225	+	2-307)
226	+	UNAME_MACHINE="alphaev67"
227	+	;;
228		esac
229		fi
230		rm -f $dummy.s $dummy
#	Line 127 | Line 240 | EOF
240		echo alpha-dec-winnt3.5
241		exit 0 ;;
242		Amiga*:UNIX_System_V:4.0:*)
243	<	echo m68k-cbm-sysv4
243	>	echo m68k-unknown-sysv4
244		exit 0;;
132	–	amiga:NetBSD:*:*)
133	–	echo m68k-cbm-netbsd${UNAME_RELEASE}
134	–	exit 0 ;;
245		amiga:OpenBSD:*:*)
246		echo m68k-unknown-openbsd${UNAME_RELEASE}
247		exit 0 ;;
#	Line 156 | Line 266 | EOF
266		wgrisc:OpenBSD:*:*)
267		echo mipsel-unknown-openbsd${UNAME_RELEASE}
268		exit 0 ;;
269	+	*:OS/390:*:*)
270	+	echo i370-ibm-openedition
271	+	exit 0 ;;
272		arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
273		echo arm-acorn-riscix${UNAME_RELEASE}
274		exit 0;;
275	<	arm32:NetBSD:*:*)
163	<	echo arm-unknown-netbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
164	<	exit 0 ;;
165	<	SR2?01:HI-UX/MPP:*:*)
275	>	SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
276		echo hppa1.1-hitachi-hiuxmpp
277		exit 0;;
278		Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
#	Line 218 | Line 328 | EOF
328		aushp:SunOS:*:*)
329		echo sparc-auspex-sunos${UNAME_RELEASE}
330		exit 0 ;;
221	–	atari*:NetBSD:*:*)
222	–	echo m68k-atari-netbsd${UNAME_RELEASE}
223	–	exit 0 ;;
331		atari*:OpenBSD:*:*)
332		echo m68k-unknown-openbsd${UNAME_RELEASE}
333		exit 0 ;;
334		# The situation for MiNT is a little confusing.  The machine name
335		# can be virtually everything (everything which is not
336	<	# "atarist" or "atariste" at least should have a processor
336	>	# "atarist" or "atariste" at least should have a processor
337		# > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
338		# to the lowercase version "mint" (or "freemint").  Finally
339		# the system name "TOS" denotes a system which is actually not
#	Line 250 | Line 357 | EOF
357		*:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
358		echo m68k-unknown-mint${UNAME_RELEASE}
359		exit 0 ;;
253	–	sun3*:NetBSD:*:*)
254	–	echo m68k-sun-netbsd${UNAME_RELEASE}
255	–	exit 0 ;;
360		sun3*:OpenBSD:*:*)
361		echo m68k-unknown-openbsd${UNAME_RELEASE}
362		exit 0 ;;
259	–	mac68k:NetBSD:*:*)
260	–	echo m68k-apple-netbsd${UNAME_RELEASE}
261	–	exit 0 ;;
363		mac68k:OpenBSD:*:*)
364		echo m68k-unknown-openbsd${UNAME_RELEASE}
365		exit 0 ;;
#	Line 271 | Line 372 | EOF
372		powerpc:machten:*:*)
373		echo powerpc-apple-machten${UNAME_RELEASE}
374		exit 0 ;;
274	–	macppc:NetBSD:*:*)
275	–	echo powerpc-apple-netbsd${UNAME_RELEASE}
276	–	exit 0 ;;
375		RISC*:Mach:*:*)
376		echo mips-dec-mach_bsd4.3
377		exit 0 ;;
#	Line 289 | Line 387 | EOF
387		mips:*:*:UMIPS | mips:*:*:RISCos)
388		sed 's/^        //' << EOF >$dummy.c
389		#ifdef __cplusplus
390	+	#include <stdio.h>  /* for printf() prototype */
391		int main (int argc, char *argv[]) {
392		#else
393		int main (argc, argv) int argc; char *argv[]; {
#	Line 309 | Line 408 | EOF
408		EOF
409		$CC_FOR_BUILD $dummy.c -o $dummy \
410		&& ./$dummy `echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` \
411	<	&& rm $dummy.c $dummy && exit 0
411	>	&& rm -f $dummy.c $dummy && exit 0
412		rm -f $dummy.c $dummy
413		echo mips-mips-riscos${UNAME_RELEASE}
414		exit 0 ;;
415	+	Motorola:PowerMAX_OS:*:*)
416	+	echo powerpc-motorola-powermax
417	+	exit 0 ;;
418		Night_Hawk:Power_UNIX:*:*)
419		echo powerpc-harris-powerunix
420		exit 0 ;;
#	Line 328 | Line 430 | EOF
430		AViiON:dgux:*:*)
431		# DG/UX returns AViiON for all architectures
432		UNAME_PROCESSOR=`/usr/bin/uname -p`
433	<	if [ $UNAME_PROCESSOR = mc88100 -o $UNAME_PROCESSOR = mc88110 ] ; then
434	<	if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx \
435	<	-o ${TARGET_BINARY_INTERFACE}x = x ] ; then
433	>	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
434	>	then
435	>	if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
436	>	[ ${TARGET_BINARY_INTERFACE}x = x ]
437	>	then
438		echo m88k-dg-dgux${UNAME_RELEASE}
439	<	else
439	>	else
440		echo m88k-dg-dguxbcs${UNAME_RELEASE}
441	+	fi
442	+	else
443	+	echo i586-dg-dgux${UNAME_RELEASE}
444		fi
338	–	else echo i586-dg-dgux${UNAME_RELEASE}
339	–	fi
445		exit 0 ;;
446		M88*:DolphinOS:*:*) # DolphinOS (SVR3)
447		echo m88k-dolphin-sysv3
#	Line 357 | Line 462 | EOF
462		????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
463		echo romp-ibm-aix      # uname -m gives an 8 hex-code CPU id
464		exit 0 ;;              # Note that: echo "'`uname -s`'" gives 'AIX '
465	<	i?86:AIX:*:*)
465	>	i*86:AIX:*:*)
466		echo i386-ibm-aix
467		exit 0 ;;
468	+	ia64:AIX:*:*)
469	+	if [ -x /usr/bin/oslevel ] ; then
470	+	IBM_REV=`/usr/bin/oslevel`
471	+	else
472	+	IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
473	+	fi
474	+	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
475	+	exit 0 ;;
476		*:AIX:2:3)
477		if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
478		sed 's/^                //' << EOF >$dummy.c
#	Line 373 | Line 486 | EOF
486		exit(0);
487		}
488		EOF
489	<	$CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm $dummy.c $dummy && exit 0
489	>	$CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm -f $dummy.c $dummy && exit 0
490		rm -f $dummy.c $dummy
491		echo rs6000-ibm-aix3.2.5
492		elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
#	Line 382 | Line 495 | EOF
495		echo rs6000-ibm-aix3.2
496		fi
497		exit 0 ;;
498	<	*:AIX:*:4)
498	>	*:AIX:*:[45])
499		IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | head -1 | awk '{ print $1 }'`
500	<	if /usr/sbin/lsattr -EHl ${IBM_CPU_ID} | grep POWER >/dev/null 2>&1; then
500	>	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
501		IBM_ARCH=rs6000
502		else
503		IBM_ARCH=powerpc
#	Line 392 | Line 505 | EOF
505		if [ -x /usr/bin/oslevel ] ; then
506		IBM_REV=`/usr/bin/oslevel`
507		else
508	<	IBM_REV=4.${UNAME_RELEASE}
508	>	IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
509		fi
510		echo ${IBM_ARCH}-ibm-aix${IBM_REV}
511		exit 0 ;;
#	Line 402 | Line 515 | EOF
515		ibmrt:4.4BSD:*|romp-ibm:BSD:*)
516		echo romp-ibm-bsd4.4
517		exit 0 ;;
518	<	ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC NetBSD and
518	>	ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
519		echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
520		exit 0 ;;                           # report: romp-ibm BSD 4.3
521		*:BOSX:*:*)
#	Line 418 | Line 531 | EOF
531		echo m68k-hp-bsd4.4
532		exit 0 ;;
533		9000/[34678]??:HP-UX:*:*)
534	+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
535		case "${UNAME_MACHINE}" in
536		9000/31? )            HP_ARCH=m68000 ;;
537		9000/[34]?? )         HP_ARCH=m68k ;;
538		9000/[678][0-9][0-9])
539	+	case "${HPUX_REV}" in
540	+	11.[0-9][0-9])
541	+	if [ -x /usr/bin/getconf ]; then
542	+	sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
543	+	sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
544	+	case "${sc_cpu_version}" in
545	+	523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
546	+	528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
547	+	532)                      # CPU_PA_RISC2_0
548	+	case "${sc_kernel_bits}" in
549	+	32) HP_ARCH="hppa2.0n" ;;
550	+	64) HP_ARCH="hppa2.0w" ;;
551	+	esac ;;
552	+	esac
553	+	fi ;;
554	+	esac
555	+	if [ "${HP_ARCH}" = "" ]; then
556		sed 's/^              //' << EOF >$dummy.c
557	+
558	+	#define _HPUX_SOURCE
559		#include <stdlib.h>
560		#include <unistd.h>
561
#	Line 453 | Line 586 | EOF
586		exit (0);
587		}
588		EOF
589	<	($CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null ) && HP_ARCH=`./$dummy`
589	>	(CCOPTS= $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null ) && HP_ARCH=`./$dummy`
590	>	if test -z "$HP_ARCH"; then HP_ARCH=hppa; fi
591		rm -f $dummy.c $dummy
592	+	fi ;;
593		esac
459	–	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
594		echo ${HP_ARCH}-hp-hpux${HPUX_REV}
595		exit 0 ;;
596	+	ia64:HP-UX:*:*)
597	+	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
598	+	echo ia64-hp-hpux${HPUX_REV}
599	+	exit 0 ;;
600		3050*:HI-UX:*:*)
601		sed 's/^        //' << EOF >$dummy.c
602		#include <unistd.h>
#	Line 485 | Line 623 | EOF
623		exit (0);
624		}
625		EOF
626	<	$CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm $dummy.c $dummy && exit 0
626	>	$CC_FOR_BUILD $dummy.c -o $dummy && ./$dummy && rm -f $dummy.c $dummy && exit 0
627		rm -f $dummy.c $dummy
628		echo unknown-hitachi-hiuxwe2
629		exit 0 ;;
#	Line 504 | Line 642 | EOF
642		hp8??:OSF1:*:*)
643		echo hppa1.0-hp-osf
644		exit 0 ;;
645	<	i?86:OSF1:*:*)
645	>	i*86:OSF1:*:*)
646		if [ -x /usr/sbin/sysversion ] ; then
647		echo ${UNAME_MACHINE}-unknown-osf1mk
648		else
#	Line 547 | Line 685 | EOF
685		-e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/
686		exit 0 ;;
687		CRAY*TS:*:*:*)
688	<	echo t90-cray-unicos${UNAME_RELEASE}
688	>	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
689	>	exit 0 ;;
690	>	CRAY*T3D:*:*:*)
691	>	echo alpha-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
692		exit 0 ;;
693		CRAY*T3E:*:*:*)
694	<	echo t3e-cray-unicosmk${UNAME_RELEASE}
694	>	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
695	>	exit 0 ;;
696	>	CRAY*SV1:*:*:*)
697	>	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
698		exit 0 ;;
699		CRAY-2:*:*:*)
700		echo cray2-cray-unicos
701		exit 0 ;;
702	<	F300:UNIX_System_V:*:*)
702	>	F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
703	>	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
704		FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
705		FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
706	<	echo "f300-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
706	>	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
707		exit 0 ;;
563	–	F301:UNIX_System_V:*:*)
564	–	echo f301-fujitsu-uxpv`echo $UNAME_RELEASE | sed 's/ .*//'`
565	–	exit 0 ;;
566	–	hp3[0-9][05]:NetBSD:*:*)
567	–	echo m68k-hp-netbsd${UNAME_RELEASE}
568	–	exit 0 ;;
708		hp300:OpenBSD:*:*)
709		echo m68k-unknown-openbsd${UNAME_RELEASE}
710		exit 0 ;;
711	<	i?86:BSD/386:*:* | i?86:BSD/OS:*:*)
711	>	i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
712		echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
713		exit 0 ;;
714		sparc*:BSD/OS:*:*)
#	Line 579 | Line 718 | EOF
718		echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
719		exit 0 ;;
720		*:FreeBSD:*:*)
582	–	if test -x /usr/bin/objformat; then
583	–	if test "elf" = "`/usr/bin/objformat`"; then
584	–	echo ${UNAME_MACHINE}-unknown-freebsdelf`echo ${UNAME_RELEASE}|sed -e 's/[-_].*//'`
585	–	exit 0
586	–	fi
587	–	fi
721		echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
722		exit 0 ;;
590	–	*:NetBSD:*:*)
591	–	echo ${UNAME_MACHINE}-unknown-netbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
592	–	exit 0 ;;
723		*:OpenBSD:*:*)
724		echo ${UNAME_MACHINE}-unknown-openbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
725		exit 0 ;;
#	Line 599 | Line 729 | EOF
729		i*:MINGW*:*)
730		echo ${UNAME_MACHINE}-pc-mingw32
731		exit 0 ;;
732	+	i*:PW*:*)
733	+	echo ${UNAME_MACHINE}-pc-pw32
734	+	exit 0 ;;
735		i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
736		# How do we know it's Interix rather than the generic POSIX subsystem?
737		# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
#	Line 617 | Line 750 | EOF
750		*:GNU:*:*)
751		echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
752		exit 0 ;;
753	<	*:Linux:*:*)
754	<	# uname on the ARM produces all sorts of strangeness, and we need to
755	<	# filter it out.
756	<	case "$UNAME_MACHINE" in
757	<	armv*)                      UNAME_MACHINE=$UNAME_MACHINE ;;
758	<	arm* | sa110*)              UNAME_MACHINE="arm" ;;
759	<	esac
760	<
761	<	# The BFD linker knows what the default object file format is, so
762	<	# first see if it will tell us. cd to the root directory to prevent
763	<	# problems with other programs or directories called `ld' in the path.
764	<	ld_help_string=`cd /; ld --help 2>&1`
765	<	ld_supported_emulations=`echo $ld_help_string \
766	<	| sed -ne '/supported emulations:/!d
767	<	s/[         ][      ]*/ /g
768	<	s/.*supported emulations: *//
769	<	s/ .*//
770	<	p'`
771	<	case "$ld_supported_emulations" in
772	<	i?86linux)  echo "${UNAME_MACHINE}-pc-linux-gnuaout"      ; exit 0 ;;
773	<	i?86coff)   echo "${UNAME_MACHINE}-pc-linux-gnucoff"      ; exit 0 ;;
774	<	sparclinux) echo "${UNAME_MACHINE}-unknown-linux-gnuaout" ; exit 0 ;;
775	<	armlinux)   echo "${UNAME_MACHINE}-unknown-linux-gnuaout" ; exit 0 ;;
776	<	m68klinux)  echo "${UNAME_MACHINE}-unknown-linux-gnuaout" ; exit 0 ;;
777	<	elf32ppc)
778	<	# Determine Lib Version
779	<	cat >$dummy.c <<EOF
753	>	i*86:Minix:*:*)
754	>	echo ${UNAME_MACHINE}-pc-minix
755	>	exit 0 ;;
756	>	arm*:Linux:*:*)
757	>	echo ${UNAME_MACHINE}-unknown-linux-gnu
758	>	exit 0 ;;
759	>	ia64:Linux:*:*)
760	>	echo ${UNAME_MACHINE}-unknown-linux
761	>	exit 0 ;;
762	>	m68*:Linux:*:*)
763	>	echo ${UNAME_MACHINE}-unknown-linux-gnu
764	>	exit 0 ;;
765	>	mips:Linux:*:*)
766	>	cat >$dummy.c <<EOF
767	>	#ifdef __cplusplus
768	>	#include <stdio.h>  /* for printf() prototype */
769	>	int main (int argc, char *argv[]) {
770	>	#else
771	>	int main (argc, argv) int argc; char *argv[]; {
772	>	#endif
773	>	#ifdef __MIPSEB__
774	>	printf ("%s-unknown-linux-gnu\n", argv[1]);
775	>	#endif
776	>	#ifdef __MIPSEL__
777	>	printf ("%sel-unknown-linux-gnu\n", argv[1]);
778	>	#endif
779	>	return 0;
780	>	}
781	>	EOF
782	>	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm -f $dummy.c $dummy && exit 0
783	>	rm -f $dummy.c $dummy
784	>	;;
785	>	ppc:Linux:*:*)
786	>	# Determine Lib Version
787	>	cat >$dummy.c <<EOF
788		#include <features.h>
789		#if defined(__GLIBC__)
790		extern char __libc_version[];
#	Line 656 | Line 797 | main(argc, argv)
797		#if defined(__GLIBC__)
798		printf("%s %s\n", __libc_version, __libc_release);
799		#else
800	<	printf("unkown\n");
800	>	printf("unknown\n");
801		#endif
802		return 0;
803		}
804		EOF
805	<	LIBC=""
806	<	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null
807	<	if test "$?" = 0 ; then
808	<	./$dummy | grep 1\.99 > /dev/null
809	<	if test "$?" = 0 ; then
810	<	LIBC="libc1"
811	<	fi
812	<	fi
813	<	rm -f $dummy.c $dummy
814	<	echo powerpc-unknown-linux-gnu${LIBC} ; exit 0 ;;
815	<	esac
816	<
817	<	if test "${UNAME_MACHINE}" = "alpha" ; then
818	<	sed 's/^        //'  <<EOF >$dummy.s
805	>	LIBC=""
806	>	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null
807	>	if test "$?" = 0 ; then
808	>	./$dummy | grep 1\.99 > /dev/null
809	>	if test "$?" = 0 ; then LIBC="libc1" ; fi
810	>	fi
811	>	rm -f $dummy.c $dummy
812	>	echo powerpc-unknown-linux-gnu${LIBC}
813	>	exit 0 ;;
814	>	alpha:Linux:*:*)
815	>	cat <<EOF >$dummy.s
816	>	.data
817	>	\$Lformat:
818	>	.byte 37,100,45,37,120,10,0     # "%d-%x\n"
819	>	.text
820		.globl main
821	+	.align 4
822		.ent main
823	<	main:
824	<	.frame \$30,0,\$26,0
825	<	.prologue 0
826	<	.long 0x47e03d80 # implver $0
827	<	lda \$2,259
828	<	.long 0x47e20c21 # amask $2,$1
829	<	srl \$1,8,\$2
830	<	sll \$2,2,\$2
831	<	sll \$0,3,\$0
832	<	addl \$1,\$0,\$0
833	<	addl \$2,\$0,\$0
834	<	ret \$31,(\$26),1
823	>	main:
824	>	.frame \$30,16,\$26,0
825	>	ldgp \$29,0(\$27)
826	>	.prologue 1
827	>	.long 0x47e03d80 # implver \$0
828	>	lda \$2,-1
829	>	.long 0x47e20c21 # amask \$2,\$1
830	>	lda \$16,\$Lformat
831	>	mov \$0,\$17
832	>	not \$1,\$18
833	>	jsr \$26,printf
834	>	ldgp \$29,0(\$26)
835	>	mov 0,\$16
836	>	jsr \$26,exit
837		.end main
838		EOF
839	<	LIBC=""
840	<	$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
839	>	LIBC=""
840	>	$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
841	>	if test "$?" = 0 ; then
842	>	case `./$dummy` in
843	>	0-0)    UNAME_MACHINE="alpha" ;;
844	>	1-0)    UNAME_MACHINE="alphaev5" ;;
845	>	1-1)    UNAME_MACHINE="alphaev56" ;;
846	>	1-101)  UNAME_MACHINE="alphapca56" ;;
847	>	2-303)  UNAME_MACHINE="alphaev6" ;;
848	>	2-307)  UNAME_MACHINE="alphaev67" ;;
849	>	esac
850	>	objdump --private-headers $dummy | \
851	>	grep ld.so.1 > /dev/null
852		if test "$?" = 0 ; then
853	<	./$dummy
698	<	case "$?" in
699	<	7)
700	<	UNAME_MACHINE="alpha"
701	<	;;
702	<	15)
703	<	UNAME_MACHINE="alphaev5"
704	<	;;
705	<	14)
706	<	UNAME_MACHINE="alphaev56"
707	<	;;
708	<	10)
709	<	UNAME_MACHINE="alphapca56"
710	<	;;
711	<	16)
712	<	UNAME_MACHINE="alphaev6"
713	<	;;
714	<	esac
715	<
716	<	objdump --private-headers $dummy | \
717	<	grep ld.so.1 > /dev/null
718	<	if test "$?" = 0 ; then
719	<	LIBC="libc1"
720	<	fi
853	>	LIBC="libc1"
854		fi
855	<	rm -f $dummy.s $dummy
856	<	echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} ; exit 0
857	<	elif test "${UNAME_MACHINE}" = "mips" ; then
858	<	cat >$dummy.c <<EOF
859	<	#ifdef __cplusplus
860	<	int main (int argc, char *argv[]) {
861	<	#else
862	<	int main (argc, argv) int argc; char *argv[]; {
863	<	#endif
864	<	#ifdef __MIPSEB__
865	<	printf ("%s-unknown-linux-gnu\n", argv[1]);
866	<	#endif
867	<	#ifdef __MIPSEL__
868	<	printf ("%sel-unknown-linux-gnu\n", argv[1]);
869	<	#endif
870	<	return 0;
871	<	}
872	<	EOF
873	<	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm $dummy.c $dummy && exit 0
874	<	rm -f $dummy.c $dummy
875	<	else
876	<	# Either a pre-BFD a.out linker (linux-gnuoldld)
877	<	# or one that does not give us useful --help.
878	<	# GCC wants to distinguish between linux-gnuoldld and linux-gnuaout.
879	<	# If ld does not provide *any* "supported emulations:"
880	<	# that means it is gnuoldld.
881	<	echo "$ld_help_string" | grep >/dev/null 2>&1 "supported emulations:"
882	<	test $? != 0 && echo "${UNAME_MACHINE}-pc-linux-gnuoldld" && exit 0
883	<
884	<	case "${UNAME_MACHINE}" in
885	<	i?86)
886	<	VENDOR=pc;
887	<	;;
888	<	*)
889	<	VENDOR=unknown;
890	<	;;
891	<	esac
892	<	# Determine whether the default compiler is a.out or elf
893	<	cat >$dummy.c <<EOF
855	>	fi
856	>	rm -f $dummy.s $dummy
857	>	echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
858	>	exit 0 ;;
859	>	parisc:Linux:*:* | hppa:Linux:*:*)
860	>	# Look for CPU level
861	>	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
862	>	PA7*) echo hppa1.1-unknown-linux-gnu ;;
863	>	PA8*) echo hppa2.0-unknown-linux-gnu ;;
864	>	*)    echo hppa-unknown-linux-gnu ;;
865	>	esac
866	>	exit 0 ;;
867	>	parisc64:Linux:*:* | hppa64:Linux:*:*)
868	>	echo hppa64-unknown-linux-gnu
869	>	exit 0 ;;
870	>	s390:Linux:*:* | s390x:Linux:*:*)
871	>	echo ${UNAME_MACHINE}-ibm-linux
872	>	exit 0 ;;
873	>	sh*:Linux:*:*)
874	>	echo ${UNAME_MACHINE}-unknown-linux-gnu
875	>	exit 0 ;;
876	>	sparc:Linux:*:* | sparc64:Linux:*:*)
877	>	echo ${UNAME_MACHINE}-unknown-linux-gnu
878	>	exit 0 ;;
879	>	x86_64:Linux:*:*)
880	>	echo x86_64-unknown-linux-gnu
881	>	exit 0 ;;
882	>	i*86:Linux:*:*)
883	>	# The BFD linker knows what the default object file format is, so
884	>	# first see if it will tell us. cd to the root directory to prevent
885	>	# problems with other programs or directories called `ld' in the path.
886	>	ld_supported_emulations=`cd /; ld --help 2>&1 \
887	>	| sed -ne '/supported emulations:/!d
888	>	s/[         ][      ]*/ /g
889	>	s/.*supported emulations: *//
890	>	s/ .*//
891	>	p'`
892	>	case "$ld_supported_emulations" in
893	>	i*86linux)
894	>	echo "${UNAME_MACHINE}-pc-linux-gnuaout"
895	>	exit 0
896	>	;;
897	>	elf_i*86)
898	>	TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
899	>	;;
900	>	i*86coff)
901	>	echo "${UNAME_MACHINE}-pc-linux-gnucoff"
902	>	exit 0
903	>	;;
904	>	esac
905	>	# Either a pre-BFD a.out linker (linux-gnuoldld)
906	>	# or one that does not give us useful --help.
907	>	# GCC wants to distinguish between linux-gnuoldld and linux-gnuaout.
908	>	# If ld does not provide *any* "supported emulations:"
909	>	# that means it is gnuoldld.
910	>	test -z "$ld_supported_emulations" && echo "${UNAME_MACHINE}-pc-linux-gnuoldld" && exit 0
911	>	case "${UNAME_MACHINE}" in
912	>	i*86)
913	>	VENDOR=pc;
914	>	;;
915	>	*)
916	>	VENDOR=unknown;
917	>	;;
918	>	esac
919	>	# Determine whether the default compiler is a.out or elf
920	>	cat >$dummy.c <<EOF
921		#include <features.h>
922		#ifdef __cplusplus
923	+	#include <stdio.h>  /* for printf() prototype */
924		int main (int argc, char *argv[]) {
925		#else
926		int main (argc, argv) int argc; char *argv[]; {
#	Line 780 | Line 941 | EOF
941		return 0;
942		}
943		EOF
944	<	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm $dummy.c $dummy && exit 0
945	<	rm -f $dummy.c $dummy
946	<	fi ;;
944	>	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm -f $dummy.c $dummy && exit 0
945	>	rm -f $dummy.c $dummy
946	>	test x"${TENTATIVE}" != x && echo "${TENTATIVE}" && exit 0
947	>	;;
948		# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.  earlier versions
949		# are messed up and put the nodename in both sysname and nodename.
950	<	i?86:DYNIX/ptx:4*:*)
950	>	i*86:DYNIX/ptx:4*:*)
951		echo i386-sequent-sysv4
952		exit 0 ;;
953	<	i?86:UNIX_SV:4.2MP:2.*)
953	>	i*86:UNIX_SV:4.2MP:2.*)
954		# Unixware is an offshoot of SVR4, but it has its own version
955		# number series starting with 2...
956		# I am not positive that other SVR4 systems won't match this,
#	Line 796 | Line 958 | EOF
958		# Use sysv4.2uw... so that sysv4* matches it.
959		echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
960		exit 0 ;;
961	<	i?86:*:4.*:* | i?86:SYSTEM_V:4.*:*)
961	>	i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
962	>	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
963		if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
964	<	echo ${UNAME_MACHINE}-univel-sysv${UNAME_RELEASE}
964	>	echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
965		else
966	<	echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE}
966	>	echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
967		fi
968		exit 0 ;;
969	<	i?86:*:5:7*)
970	<	UNAME_REL=`(/bin/uname -X|egrep Release|sed -e 's/.*= //')`
971	<	(/bin/uname -X|egrep i80486 >/dev/null) && UNAME_MACHINE=i486
972	<	(/bin/uname -X|egrep '^Machine.*Pentium' >/dev/null) && UNAME_MACHINE=i586
973	<	(/bin/uname -X|egrep '^Machine.*Pent.*II' >/dev/null) && UNAME_MACHINE=i686
974	<	(/bin/uname -X|egrep '^Machine.*Pentium Pro' >/dev/null) && UNAME_MACHINE=i585
975	<	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}${UNAME_VERSION}-sysv${UNAME_RELEASE}
969	>	i*86:*:5:7*)
970	>	# Fixed at (any) Pentium or better
971	>	UNAME_MACHINE=i586
972	>	if [ ${UNAME_SYSTEM} = "UnixWare" ] ; then
973	>	echo ${UNAME_MACHINE}-sco-sysv${UNAME_RELEASE}uw${UNAME_VERSION}
974	>	else
975	>	echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE}
976	>	fi
977		exit 0 ;;
978	<	i?86:*:3.2:*)
978	>	i*86:*:3.2:*)
979		if test -f /usr/options/cb.name; then
980		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
981		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
#	Line 829 | Line 993 | EOF
993		echo ${UNAME_MACHINE}-pc-sysv32
994		fi
995		exit 0 ;;
996	+	i*86:*DOS:*:*)
997	+	echo ${UNAME_MACHINE}-pc-msdosdjgpp
998	+	exit 0 ;;
999		pc:*:*:*)
1000	+	# Left here for compatibility:
1001		# uname -m prints for DJGPP always 'pc', but it prints nothing about
1002		# the processor, so we play safe by assuming i386.
1003		echo i386-pc-msdosdjgpp
#	Line 853 | Line 1021 | EOF
1021		exit 0 ;;
1022		M68*:*:R3V[567]*:*)
1023		test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
1024	<	3[34]??:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 4850:*:4.0:3.0)
1024	>	3[34]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 4850:*:4.0:3.0)
1025		OS_REL=''
1026		test -r /etc/.relid \
1027		&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
#	Line 864 | Line 1032 | EOF
1032		3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
1033		/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
1034		&& echo i486-ncr-sysv4 && exit 0 ;;
1035	<	m68*:LynxOS:2.*:*)
1035	>	m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
1036		echo m68k-unknown-lynxos${UNAME_RELEASE}
1037		exit 0 ;;
1038		mc68030:UNIX_System_V:4.*:*)
1039		echo m68k-atari-sysv4
1040		exit 0 ;;
1041	<	i?86:LynxOS:2.*:* | i?86:LynxOS:3.[01]*:*)
1041	>	i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)
1042		echo i386-unknown-lynxos${UNAME_RELEASE}
1043		exit 0 ;;
1044		TSUNAMI:LynxOS:2.*:*)
1045		echo sparc-unknown-lynxos${UNAME_RELEASE}
1046		exit 0 ;;
1047	<	rs6000:LynxOS:2.*:* | PowerPC:LynxOS:2.*:*)
1047	>	rs6000:LynxOS:2.*:*)
1048		echo rs6000-unknown-lynxos${UNAME_RELEASE}
1049		exit 0 ;;
1050	+	PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)
1051	+	echo powerpc-unknown-lynxos${UNAME_RELEASE}
1052	+	exit 0 ;;
1053		SM[BE]S:UNIX_SV:*:*)
1054		echo mips-dde-sysv${UNAME_RELEASE}
1055		exit 0 ;;
#	Line 912 | Line 1083 | EOF
1083		mc68*:A/UX:*:*)
1084		echo m68k-apple-aux${UNAME_RELEASE}
1085		exit 0 ;;
1086	<	news*:NEWS-OS:*:6*)
1086	>	news*:NEWS-OS:6*:*)
1087		echo mips-sony-newsos6
1088		exit 0 ;;
1089		R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
#	Line 943 | Line 1114 | EOF
1114		*:Rhapsody:*:*)
1115		echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
1116		exit 0 ;;
1117	+	*:Darwin:*:*)
1118	+	echo `uname -p`-apple-darwin${UNAME_RELEASE}
1119	+	exit 0 ;;
1120	+	*:procnto*:*:* | *:QNX:[0123456789]*:*)
1121	+	if test "${UNAME_MACHINE}" = "x86pc"; then
1122	+	UNAME_MACHINE=pc
1123	+	fi
1124	+	echo `uname -p`-${UNAME_MACHINE}-nto-qnx
1125	+	exit 0 ;;
1126	+	*:QNX:*:4*)
1127	+	echo i386-pc-qnx
1128	+	exit 0 ;;
1129	+	NSR-[KW]:NONSTOP_KERNEL:*:*)
1130	+	echo nsr-tandem-nsk${UNAME_RELEASE}
1131	+	exit 0 ;;
1132	+	*:NonStop-UX:*:*)
1133	+	echo mips-compaq-nonstopux
1134	+	exit 0 ;;
1135	+	BS2000:POSIX*:*:*)
1136	+	echo bs2000-siemens-sysv
1137	+	exit 0 ;;
1138	+	DS/*:UNIX_System_V:*:*)
1139	+	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
1140	+	exit 0 ;;
1141	+	*:Plan9:*:*)
1142	+	# "uname -m" is not consistent, so use $cputype instead. 386
1143	+	# is converted to i386 for consistency with other x86
1144	+	# operating systems.
1145	+	if test "$cputype" = "386"; then
1146	+	UNAME_MACHINE=i386
1147	+	else
1148	+	UNAME_MACHINE="$cputype"
1149	+	fi
1150	+	echo ${UNAME_MACHINE}-unknown-plan9
1151	+	exit 0 ;;
1152	+	i*86:OS/2:*:*)
1153	+	# If we were able to find `uname', then EMX Unix compatibility
1154	+	# is probably installed.
1155	+	echo ${UNAME_MACHINE}-pc-os2-emx
1156	+	exit 0 ;;
1157	+	*:TOPS-10:*:*)
1158	+	echo pdp10-unknown-tops10
1159	+	exit 0 ;;
1160	+	*:TENEX:*:*)
1161	+	echo pdp10-unknown-tenex
1162	+	exit 0 ;;
1163	+	KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
1164	+	echo pdp10-dec-tops20
1165	+	exit 0 ;;
1166	+	XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
1167	+	echo pdp10-xkl-tops20
1168	+	exit 0 ;;
1169	+	*:TOPS-20:*:*)
1170	+	echo pdp10-unknown-tops20
1171	+	exit 0 ;;
1172	+	*:ITS:*:*)
1173	+	echo pdp10-unknown-its
1174	+	exit 0 ;;
1175		esac
1176
1177		#echo '(No uname command or uname output not recognized.)' 1>&2
#	Line 1034 | Line 1263 | main ()
1263		#endif
1264
1265		#if defined (vax)
1266	<	#if !defined (ultrix)
1267	<	printf ("vax-dec-bsd\n"); exit (0);
1268	<	#else
1269	<	printf ("vax-dec-ultrix\n"); exit (0);
1270	<	#endif
1266	>	# if !defined (ultrix)
1267	>	#  include <sys/param.h>
1268	>	#  if defined (BSD)
1269	>	#   if BSD == 43
1270	>	printf ("vax-dec-bsd4.3\n"); exit (0);
1271	>	#   else
1272	>	#    if BSD == 199006
1273	>	printf ("vax-dec-bsd4.3reno\n"); exit (0);
1274	>	#    else
1275	>	printf ("vax-dec-bsd\n"); exit (0);
1276	>	#    endif
1277	>	#   endif
1278	>	#  else
1279	>	printf ("vax-dec-bsd\n"); exit (0);
1280	>	#  endif
1281	>	# else
1282	>	printf ("vax-dec-ultrix\n"); exit (0);
1283	>	# endif
1284		#endif
1285
1286		#if defined (alliant) && defined (i860)
#	Line 1049 | Line 1291 | main ()
1291		}
1292		EOF
1293
1294	<	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy && rm $dummy.c $dummy && exit 0
1294	>	$CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy && rm -f $dummy.c $dummy && exit 0
1295		rm -f $dummy.c $dummy
1296
1297		# Apollos put the system type in the environment.
#	Line 1082 | Line 1324 | then
1324		esac
1325		fi
1326
1327	<	#echo '(Unable to guess system type)' 1>&2
1327	>	cat >&2 <<EOF
1328	>	$0: unable to guess system type
1329	>
1330	>	This script, last modified $timestamp, has failed to recognize
1331	>	the operating system you are using. It is advised that you
1332	>	download the most up to date version of the config scripts from
1333	>
1334	>	ftp://ftp.gnu.org/pub/gnu/config/
1335	>
1336	>	If the version you run ($0) is already up to date, please
1337	>	send the following data and any information you think might be
1338	>	pertinent to <config-patches@gnu.org> in order to provide the needed
1339	>	information to handle your system.
1340	>
1341	>	config.guess timestamp = $timestamp
1342	>
1343	>	uname -m = `(uname -m) 2>/dev/null || echo unknown`
1344	>	uname -r = `(uname -r) 2>/dev/null || echo unknown`
1345	>	uname -s = `(uname -s) 2>/dev/null || echo unknown`
1346	>	uname -v = `(uname -v) 2>/dev/null || echo unknown`
1347	>
1348	>	/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
1349	>	/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
1350	>
1351	>	hostinfo               = `(hostinfo) 2>/dev/null`
1352	>	/bin/universe          = `(/bin/universe) 2>/dev/null`
1353	>	/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
1354	>	/bin/arch              = `(/bin/arch) 2>/dev/null`
1355	>	/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
1356	>	/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
1357	>
1358	>	UNAME_MACHINE = ${UNAME_MACHINE}
1359	>	UNAME_RELEASE = ${UNAME_RELEASE}
1360	>	UNAME_SYSTEM  = ${UNAME_SYSTEM}
1361	>	UNAME_VERSION = ${UNAME_VERSION}
1362	>	EOF
1363
1364		exit 1
1365	+
1366	+	# Local variables:
1367	+	# eval: (add-hook 'write-file-hooks 'time-stamp)
1368	+	# time-stamp-start: "timestamp='"
1369	+	# time-stamp-format: "%:y-%02m-%02d"
1370	+	# time-stamp-end: "'"
1371	+	# End:

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines