PageRenderTime 46ms CodeModel.GetById 19ms RepoModel.GetById 1ms app.codeStats 0ms

/js/lib/Socket.IO-node/support/expresso/deps/jscoverage/js/build/autoconf/config.guess

http://github.com/onedayitwillmake/RealtimeMultiplayerNodeJs
Shell | 1481 lines | 1245 code | 26 blank | 210 comment | 70 complexity | 7d929138cf871ab07b961c63059ef022 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, MPL-2.0-no-copyleft-exception, BSD-3-Clause 
    

  1. #! /bin/sh
    2. 

  2. # Attempt to guess a canonical system name.
    3. 

  3. #   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
    4. 

  4. #   2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
    5. 

  5. 

  6. timestamp='2005-10-13'
    7. 

  7. 

  8. # This file is free software; you can redistribute it and/or modify it
    9. 

  9. # under the terms of the GNU General Public License as published by
    10. 

  10. # the Free Software Foundation; either version 2 of the License, or
    11. 

  11. # (at your option) any later version.
    12. 

  12. #
    13. 

  13. # This program is distributed in the hope that it will be useful, but
    14. 

  14. # WITHOUT ANY WARRANTY; without even the implied warranty of
    15. 

  15. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    16. 

  16. # General Public License for more details.
    17. 

  17. #
    18. 

  18. # You should have received a copy of the GNU General Public License
    19. 

  19. # along with this program; if not, write to the Free Software
    20. 

  20. # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
    21. 

  21. # 02110-1301, USA.
    22. 

  22. #
    23. 

  23. # As a special exception to the GNU General Public License, if you
    24. 

  24. # distribute this file as part of a program that contains a
    25. 

  25. # configuration script generated by Autoconf, you may include it under
    26. 

  26. # the same distribution terms that you use for the rest of that program.
    27. 

  27. 

  28. 

  29. # Originally written by Per Bothner <per@bothner.com>.
    30. 

  30. # Please send patches to <config-patches@gnu.org>.  Submit a context
    31. 

  31. # diff and a properly formatted ChangeLog entry.
    32. 

  32. #
    33. 

  33. # This script attempts to guess a canonical system name similar to
    34. 

  34. # config.sub.  If it succeeds, it prints the system name on stdout, and
    35. 

  35. # exits with 0.  Otherwise, it exits with 1.
    36. 

  36. #
    37. 

  37. # The plan is that this can be called by configure scripts if you
    38. 

  38. # don't specify an explicit build system type.
    39. 

    40. 

  40. me=`echo "$0" | sed -e 's,.*/,,'`
    41. 

  41. 

  42. usage="\
    43. 

  43. Usage: $0 [OPTION]
    44. 

  44. 

  45. Output the configuration name of the system \`$me' is run on.
    46. 

    47. 

  47. Operation modes:
    48. 

  48.   -h, --help         print this help, then exit
    49. 

  49.   -t, --time-stamp   print date of last modification, then exit
    50. 

  50.   -v, --version      print version number, then exit
    51. 

    52. 

  52. Report bugs and patches to <config-patches@gnu.org>."
    53. 

    54. 

  54. version="\
    55. 

  55. GNU config.guess ($timestamp)
    56. 

    57. 

  57. Originally written by Per Bothner.
    58. 

  58. Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
    59. 

  59. Free Software Foundation, Inc.
    60. 

    61. 

  61. This is free software; see the source for copying conditions.  There is NO
    62. 

  62. warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
    63. 

    64. 

  64. help="
    65. 

  65. Try \`$me --help' for more information."
    66. 

    67. 

  67. # Parse command line
    68. 

  68. while test $# -gt 0 ; do
    69. 

  69.   case $1 in
    70. 

  70.     --time-stamp | --time* | -t )
    71. 

  71.        echo "$timestamp" ; exit ;;
    72. 

  72.     --version | -v )
    73. 

  73.        echo "$version" ; exit ;;
    74. 

  74.     --help | --h* | -h )
    75. 

  75.        echo "$usage"; exit ;;
    76. 

  76.     -- )     # Stop option processing
    77. 

  77.        shift; break ;;
    78. 

  78.     - )	# Use stdin as input.
    79. 

  79.        break ;;
    80. 

  80.     -* )
    81. 

  81.        echo "$me: invalid option $1$help" >&2
    82. 

  82.        exit 1 ;;
    83. 

  83.     * )
    84. 

  84.        break ;;
    85. 

  85.   esac
    86. 

  86. done
    87. 

  87. 

  88. if test $# != 0; then
    89. 

  89.   echo "$me: too many arguments$help" >&2
    90. 

  90.   exit 1
    91. 

  91. fi
    92. 

  92. 

  93. trap 'exit 1' 1 2 15
    94. 

  94. 

  95. # CC_FOR_BUILD -- compiler used by this script. Note that the use of a
    96. 

  96. # compiler to aid in system detection is discouraged as it requires
    97. 

  97. # temporary files to be created and, as you can see below, it is a
    98. 

  98. # headache to deal with in a portable fashion.
    99. 

  99. 

  100. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
    101. 

  101. # use `HOST_CC' if defined, but it is deprecated.
    102. 

    103. 

  103. # Portable tmp directory creation inspired by the Autoconf team.
    104. 

    105. 

  105. set_cc_for_build='
    106. 

  106. trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
    107. 

  107. trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
    108. 

  108. : ${TMPDIR=/tmp} ;
    109. 

  109.  { tmp=`(umask 077 && mktemp -d -q "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
    110. 

  110.  { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
    111. 

  111.  { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
    112. 

  112.  { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
    113. 

  113. dummy=$tmp/dummy ;
    114. 

  114. tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
    115. 

  115. case $CC_FOR_BUILD,$HOST_CC,$CC in
    116. 

  116.  ,,)    echo "int x;" > $dummy.c ;
    117. 

  117. 	for c in cc gcc c89 c99 ; do
    118. 

  118. 	  if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
    119. 

  119. 	     CC_FOR_BUILD="$c"; break ;
    120. 

  120. 	  fi ;
    121. 

  121. 	done ;
    122. 

  122. 	if test x"$CC_FOR_BUILD" = x ; then
    123. 

  123. 	  CC_FOR_BUILD=no_compiler_found ;
    124. 

  124. 	fi
    125. 

  125. 	;;
    126. 

  126.  ,,*)   CC_FOR_BUILD=$CC ;;
    127. 

  127.  ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
    128. 

  128. esac ; set_cc_for_build= ;'
    129. 

    130. 

  130. # This is needed to find uname on a Pyramid OSx when run in the BSD universe.
    131. 

  131. # (ghazi@noc.rutgers.edu 1994-08-24)
    132. 

  132. if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
    133. 

  133. 	PATH=$PATH:/.attbin ; export PATH
    134. 

  134. fi
    135. 

    136. 

  136. UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
    137. 

  137. UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
    138. 

  138. UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
    139. 

  139. UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
    140. 

    141. 

  141. # Note: order is significant - the case branches are not exclusive.
    142. 

    143. 

  143. case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
    144. 

  144.     *:NetBSD:*:*)
    145. 

  145. 	# NetBSD (nbsd) targets should (where applicable) match one or
    146. 

  146. 	# more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*,
    147. 

  147. 	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
    148. 

  148. 	# switched to ELF, *-*-netbsd* would select the old
    149. 

  149. 	# object file format.  This provides both forward
    150. 

  150. 	# compatibility and a consistent mechanism for selecting the
    151. 

  151. 	# object file format.
    152. 

  152. 	#
    153. 

  153. 	# Note: NetBSD doesn't particularly care about the vendor
    154. 

  154. 	# portion of the name.  We always set it to "unknown".
    155. 

  155. 	sysctl="sysctl -n hw.machine_arch"
    156. 

  156. 	UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
    157. 

  157. 	    /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
    158. 

  158. 	case "${UNAME_MACHINE_ARCH}" in
    159. 

  159. 	    armeb) machine=armeb-unknown ;;
    160. 

  160. 	    arm*) machine=arm-unknown ;;
    161. 

  161. 	    sh3el) machine=shl-unknown ;;
    162. 

  162. 	    sh3eb) machine=sh-unknown ;;
    163. 

  163. 	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
    164. 

  164. 	esac
    165. 

  165. 	# The Operating System including object format, if it has switched
    166. 

  166. 	# to ELF recently, or will in the future.
    167. 

  167. 	case "${UNAME_MACHINE_ARCH}" in
    168. 

  168. 	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
    169. 

  169. 		eval $set_cc_for_build
    170. 

  170. 		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
    171. 

  171. 			| grep __ELF__ >/dev/null
    172. 

  172. 		then
    173. 

  173. 		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
    174. 

  174. 		    # Return netbsd for either.  FIX?
    175. 

  175. 		    os=netbsd
    176. 

  176. 		else
    177. 

  177. 		    os=netbsdelf
    178. 

  178. 		fi
    179. 

  179. 		;;
    180. 

  180. 	    *)
    181. 

  181. 	        os=netbsd
    182. 

  182. 		;;
    183. 

  183. 	esac
    184. 

  184. 	# The OS release
    185. 

  185. 	# Debian GNU/NetBSD machines have a different userland, and
    186. 

  186. 	# thus, need a distinct triplet. However, they do not need
    187. 

  187. 	# kernel version information, so it can be replaced with a
    188. 

  188. 	# suitable tag, in the style of linux-gnu.
    189. 

  189. 	case "${UNAME_VERSION}" in
    190. 

  190. 	    Debian*)
    191. 

  191. 		release='-gnu'
    192. 

  192. 		;;
    193. 

  193. 	    *)
    194. 

  194. 		release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
    195. 

  195. 		;;
    196. 

  196. 	esac
    197. 

  197. 	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
    198. 

  198. 	# contains redundant information, the shorter form:
    199. 

  199. 	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
    200. 

  200. 	echo "${machine}-${os}${release}"
    201. 

  201. 	exit ;;
    202. 

  202.     *:OpenBSD:*:*)
    203. 

  203. 	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
    204. 

  204. 	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
    205. 

  205. 	exit ;;
    206. 

  206.     *:ekkoBSD:*:*)
    207. 

  207. 	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
    208. 

  208. 	exit ;;
    209. 

  209.     macppc:MirBSD:*:*)
    210. 

  210. 	echo powerppc-unknown-mirbsd${UNAME_RELEASE}
    211. 

  211. 	exit ;;
    212. 

  212.     *:MirBSD:*:*)
    213. 

  213. 	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
    214. 

  214. 	exit ;;
    215. 

  215.     alpha:OSF1:*:*)
    216. 

  216. 	case $UNAME_RELEASE in
    217. 

  217. 	*4.0)
    218. 

  218. 		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
    219. 

  219. 		;;
    220. 

  220. 	*5.*)
    221. 

  221. 	        UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
    222. 

  222. 		;;
    223. 

  223. 	esac
    224. 

  224. 	# According to Compaq, /usr/sbin/psrinfo has been available on
    225. 

  225. 	# OSF/1 and Tru64 systems produced since 1995.  I hope that
    226. 

  226. 	# covers most systems running today.  This code pipes the CPU
    227. 

  227. 	# types through head -n 1, so we only detect the type of CPU 0.
    228. 

  228. 	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha \(.*\) processor.*$/\1/p' | head -n 1`
    229. 

  229. 	case "$ALPHA_CPU_TYPE" in
    230. 

  230. 	    "EV4 (21064)")
    231. 

  231. 		UNAME_MACHINE="alpha" ;;
    232. 

  232. 	    "EV4.5 (21064)")
    233. 

  233. 		UNAME_MACHINE="alpha" ;;
    234. 

  234. 	    "LCA4 (21066/21068)")
    235. 

  235. 		UNAME_MACHINE="alpha" ;;
    236. 

  236. 	    "EV5 (21164)")
    237. 

  237. 		UNAME_MACHINE="alphaev5" ;;
    238. 

  238. 	    "EV5.6 (21164A)")
    239. 

  239. 		UNAME_MACHINE="alphaev56" ;;
    240. 

  240. 	    "EV5.6 (21164PC)")
    241. 

  241. 		UNAME_MACHINE="alphapca56" ;;
    242. 

  242. 	    "EV5.7 (21164PC)")
    243. 

  243. 		UNAME_MACHINE="alphapca57" ;;
    244. 

  244. 	    "EV6 (21264)")
    245. 

  245. 		UNAME_MACHINE="alphaev6" ;;
    246. 

  246. 	    "EV6.7 (21264A)")
    247. 

  247. 		UNAME_MACHINE="alphaev67" ;;
    248. 

  248. 	    "EV6.8CB (21264C)")
    249. 

  249. 		UNAME_MACHINE="alphaev68" ;;
    250. 

  250. 	    "EV6.8AL (21264B)")
    251. 

  251. 		UNAME_MACHINE="alphaev68" ;;
    252. 

  252. 	    "EV6.8CX (21264D)")
    253. 

  253. 		UNAME_MACHINE="alphaev68" ;;
    254. 

  254. 	    "EV6.9A (21264/EV69A)")
    255. 

  255. 		UNAME_MACHINE="alphaev69" ;;
    256. 

  256. 	    "EV7 (21364)")
    257. 

  257. 		UNAME_MACHINE="alphaev7" ;;
    258. 

  258. 	    "EV7.9 (21364A)")
    259. 

  259. 		UNAME_MACHINE="alphaev79" ;;
    260. 

  260. 	esac
    261. 

  261. 	# A Pn.n version is a patched version.
    262. 

  262. 	# A Vn.n version is a released version.
    263. 

  263. 	# A Tn.n version is a released field test version.
    264. 

  264. 	# A Xn.n version is an unreleased experimental baselevel.
    265. 

  265. 	# 1.2 uses "1.2" for uname -r.
    266. 

  266. 	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
    267. 

  267. 	exit ;;
    268. 

  268.     Alpha\ *:Windows_NT*:*)
    269. 

  269. 	# How do we know it's Interix rather than the generic POSIX subsystem?
    270. 

  270. 	# Should we change UNAME_MACHINE based on the output of uname instead
    271. 

  271. 	# of the specific Alpha model?
    272. 

  272. 	echo alpha-pc-interix
    273. 

  273. 	exit ;;
    274. 

  274.     21064:Windows_NT:50:3)
    275. 

  275. 	echo alpha-dec-winnt3.5
    276. 

  276. 	exit ;;
    277. 

  277.     Amiga*:UNIX_System_V:4.0:*)
    278. 

  278. 	echo m68k-unknown-sysv4
    279. 

  279. 	exit ;;
    280. 

  280.     *:[Aa]miga[Oo][Ss]:*:*)
    281. 

  281. 	echo ${UNAME_MACHINE}-unknown-amigaos
    282. 

  282. 	exit ;;
    283. 

  283.     *:[Mm]orph[Oo][Ss]:*:*)
    284. 

  284. 	echo ${UNAME_MACHINE}-unknown-morphos
    285. 

  285. 	exit ;;
    286. 

  286.     *:OS/390:*:*)
    287. 

  287. 	echo i370-ibm-openedition
    288. 

  288. 	exit ;;
    289. 

  289.     *:z/VM:*:*)
    290. 

  290. 	echo s390-ibm-zvmoe
    291. 

  291. 	exit ;;
    292. 

  292.     *:OS400:*:*)
    293. 

  293.         echo powerpc-ibm-os400
    294. 

  294. 	exit ;;
    295. 

  295.     arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
    296. 

  296. 	echo arm-acorn-riscix${UNAME_RELEASE}
    297. 

  297. 	exit ;;
    298. 

  298.     arm:riscos:*:*|arm:RISCOS:*:*)
    299. 

  299. 	echo arm-unknown-riscos
    300. 

  300. 	exit ;;
    301. 

  301.     SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
    302. 

  302. 	echo hppa1.1-hitachi-hiuxmpp
    303. 

  303. 	exit ;;
    304. 

  304.     Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
    305. 

  305. 	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
    306. 

  306. 	if test "`(/bin/universe) 2>/dev/null`" = att ; then
    307. 

  307. 		echo pyramid-pyramid-sysv3
    308. 

  308. 	else
    309. 

  309. 		echo pyramid-pyramid-bsd
    310. 

  310. 	fi
    311. 

  311. 	exit ;;
    312. 

  312.     NILE*:*:*:dcosx)
    313. 

  313. 	echo pyramid-pyramid-svr4
    314. 

  314. 	exit ;;
    315. 

  315.     DRS?6000:unix:4.0:6*)
    316. 

  316. 	echo sparc-icl-nx6
    317. 

  317. 	exit ;;
    318. 

  318.     DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
    319. 

  319. 	case `/usr/bin/uname -p` in
    320. 

  320. 	    sparc) echo sparc-icl-nx7; exit ;;
    321. 

  321. 	esac ;;
    322. 

  322.     sun4H:SunOS:5.*:*)
    323. 

  323. 	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
    324. 

  324. 	exit ;;
    325. 

  325.     sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
    326. 

  326. 	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
    327. 

  327. 	exit ;;
    328. 

  328.     i86pc:SunOS:5.*:*)
    329. 

  329. 	echo i386-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
    330. 

  330. 	exit ;;
    331. 

  331.     sun4*:SunOS:6*:*)
    332. 

  332. 	# According to config.sub, this is the proper way to canonicalize
    333. 

  333. 	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
    334. 

  334. 	# it's likely to be more like Solaris than SunOS4.
    335. 

  335. 	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
    336. 

  336. 	exit ;;
    337. 

  337.     sun4*:SunOS:*:*)
    338. 

  338. 	case "`/usr/bin/arch -k`" in
    339. 

  339. 	    Series*|S4*)
    340. 

  340. 		UNAME_RELEASE=`uname -v`
    341. 

  341. 		;;
    342. 

  342. 	esac
    343. 

  343. 	# Japanese Language versions have a version number like `4.1.3-JL'.
    344. 

  344. 	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
    345. 

  345. 	exit ;;
    346. 

  346.     sun3*:SunOS:*:*)
    347. 

  347. 	echo m68k-sun-sunos${UNAME_RELEASE}
    348. 

  348. 	exit ;;
    349. 

  349.     sun*:*:4.2BSD:*)
    350. 

  350. 	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
    351. 

  351. 	test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
    352. 

  352. 	case "`/bin/arch`" in
    353. 

  353. 	    sun3)
    354. 

  354. 		echo m68k-sun-sunos${UNAME_RELEASE}
    355. 

  355. 		;;
    356. 

  356. 	    sun4)
    357. 

  357. 		echo sparc-sun-sunos${UNAME_RELEASE}
    358. 

  358. 		;;
    359. 

  359. 	esac
    360. 

  360. 	exit ;;
    361. 

  361.     aushp:SunOS:*:*)
    362. 

  362. 	echo sparc-auspex-sunos${UNAME_RELEASE}
    363. 

  363. 	exit ;;
    364. 

  364.     # The situation for MiNT is a little confusing.  The machine name
    365. 

  365.     # can be virtually everything (everything which is not
    366. 

  366.     # "atarist" or "atariste" at least should have a processor
    367. 

  367.     # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
    368. 

  368.     # to the lowercase version "mint" (or "freemint").  Finally
    369. 

  369.     # the system name "TOS" denotes a system which is actually not
    370. 

  370.     # MiNT.  But MiNT is downward compatible to TOS, so this should
    371. 

  371.     # be no problem.
    372. 

  372.     atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
    373. 

  373.         echo m68k-atari-mint${UNAME_RELEASE}
    374. 

  374. 	exit ;;
    375. 

  375.     atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
    376. 

  376. 	echo m68k-atari-mint${UNAME_RELEASE}
    377. 

  377.         exit ;;
    378. 

  378.     *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
    379. 

  379.         echo m68k-atari-mint${UNAME_RELEASE}
    380. 

  380. 	exit ;;
    381. 

  381.     milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
    382. 

  382.         echo m68k-milan-mint${UNAME_RELEASE}
    383. 

  383.         exit ;;
    384. 

  384.     hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
    385. 

  385.         echo m68k-hades-mint${UNAME_RELEASE}
    386. 

  386.         exit ;;
    387. 

  387.     *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
    388. 

  388.         echo m68k-unknown-mint${UNAME_RELEASE}
    389. 

  389.         exit ;;
    390. 

  390.     m68k:machten:*:*)
    391. 

  391. 	echo m68k-apple-machten${UNAME_RELEASE}
    392. 

  392. 	exit ;;
    393. 

  393.     powerpc:machten:*:*)
    394. 

  394. 	echo powerpc-apple-machten${UNAME_RELEASE}
    395. 

  395. 	exit ;;
    396. 

  396.     RISC*:Mach:*:*)
    397. 

  397. 	echo mips-dec-mach_bsd4.3
    398. 

  398. 	exit ;;
    399. 

  399.     RISC*:ULTRIX:*:*)
    400. 

  400. 	echo mips-dec-ultrix${UNAME_RELEASE}
    401. 

  401. 	exit ;;
    402. 

  402.     VAX*:ULTRIX*:*:*)
    403. 

  403. 	echo vax-dec-ultrix${UNAME_RELEASE}
    404. 

  404. 	exit ;;
    405. 

  405.     2020:CLIX:*:* | 2430:CLIX:*:*)
    406. 

  406. 	echo clipper-intergraph-clix${UNAME_RELEASE}
    407. 

  407. 	exit ;;
    408. 

  408.     mips:*:*:UMIPS | mips:*:*:RISCos)
    409. 

  409. 	eval $set_cc_for_build
    410. 

  410. 	sed 's/^	//' << EOF >$dummy.c
    411. 

  411. #ifdef __cplusplus
    412. 

  412. #include <stdio.h>  /* for printf() prototype */
    413. 

  413. 	int main (int argc, char *argv[]) {
    414. 

  414. #else
    415. 

  415. 	int main (argc, argv) int argc; char *argv[]; {
    416. 

  416. #endif
    417. 

  417. 	#if defined (host_mips) && defined (MIPSEB)
    418. 

  418. 	#if defined (SYSTYPE_SYSV)
    419. 

  419. 	  printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
    420. 

  420. 	#endif
    421. 

  421. 	#if defined (SYSTYPE_SVR4)
    422. 

  422. 	  printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
    423. 

  423. 	#endif
    424. 

  424. 	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
    425. 

  425. 	  printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
    426. 

  426. 	#endif
    427. 

  427. 	#endif
    428. 

  428. 	  exit (-1);
    429. 

  429. 	}
    430. 

  430. EOF
    431. 

  431. 	$CC_FOR_BUILD -o $dummy $dummy.c &&
    432. 

  432. 	  dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
    433. 

  433. 	  SYSTEM_NAME=`$dummy $dummyarg` &&
    434. 

  434. 	    { echo "$SYSTEM_NAME"; exit; }
    435. 

  435. 	echo mips-mips-riscos${UNAME_RELEASE}
    436. 

  436. 	exit ;;
    437. 

  437.     Motorola:PowerMAX_OS:*:*)
    438. 

  438. 	echo powerpc-motorola-powermax
    439. 

  439. 	exit ;;
    440. 

  440.     Motorola:*:4.3:PL8-*)
    441. 

  441. 	echo powerpc-harris-powermax
    442. 

  442. 	exit ;;
    443. 

  443.     Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
    444. 

  444. 	echo powerpc-harris-powermax
    445. 

  445. 	exit ;;
    446. 

  446.     Night_Hawk:Power_UNIX:*:*)
    447. 

  447. 	echo powerpc-harris-powerunix
    448. 

  448. 	exit ;;
    449. 

  449.     m88k:CX/UX:7*:*)
    450. 

  450. 	echo m88k-harris-cxux7
    451. 

  451. 	exit ;;
    452. 

  452.     m88k:*:4*:R4*)
    453. 

  453. 	echo m88k-motorola-sysv4
    454. 

  454. 	exit ;;
    455. 

  455.     m88k:*:3*:R3*)
    456. 

  456. 	echo m88k-motorola-sysv3
    457. 

  457. 	exit ;;
    458. 

  458.     AViiON:dgux:*:*)
    459. 

  459.         # DG/UX returns AViiON for all architectures
    460. 

  460.         UNAME_PROCESSOR=`/usr/bin/uname -p`
    461. 

  461. 	if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
    462. 

  462. 	then
    463. 

  463. 	    if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
    464. 

  464. 	       [ ${TARGET_BINARY_INTERFACE}x = x ]
    465. 

  465. 	    then
    466. 

  466. 		echo m88k-dg-dgux${UNAME_RELEASE}
    467. 

  467. 	    else
    468. 

  468. 		echo m88k-dg-dguxbcs${UNAME_RELEASE}
    469. 

  469. 	    fi
    470. 

  470. 	else
    471. 

  471. 	    echo i586-dg-dgux${UNAME_RELEASE}
    472. 

  472. 	fi
    473. 

  473.  	exit ;;
    474. 

  474.     M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
    475. 

  475. 	echo m88k-dolphin-sysv3
    476. 

  476. 	exit ;;
    477. 

  477.     M88*:*:R3*:*)
    478. 

  478. 	# Delta 88k system running SVR3
    479. 

  479. 	echo m88k-motorola-sysv3
    480. 

  480. 	exit ;;
    481. 

  481.     XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
    482. 

  482. 	echo m88k-tektronix-sysv3
    483. 

  483. 	exit ;;
    484. 

  484.     Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
    485. 

  485. 	echo m68k-tektronix-bsd
    486. 

  486. 	exit ;;
    487. 

  487.     *:IRIX*:*:*)
    488. 

  488. 	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
    489. 

  489. 	exit ;;
    490. 

  490.     ????????:AIX?:[12].1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
    491. 

  491. 	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
    492. 

  492. 	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
    493. 

  493.     i*86:AIX:*:*)
    494. 

  494. 	echo i386-ibm-aix
    495. 

  495. 	exit ;;
    496. 

  496.     ia64:AIX:*:*)
    497. 

  497. 	if [ -x /usr/bin/oslevel ] ; then
    498. 

  498. 		IBM_REV=`/usr/bin/oslevel`
    499. 

  499. 	else
    500. 

  500. 		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
    501. 

  501. 	fi
    502. 

  502. 	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
    503. 

  503. 	exit ;;
    504. 

  504.     *:AIX:2:3)
    505. 

  505. 	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
    506. 

  506. 		eval $set_cc_for_build
    507. 

  507. 		sed 's/^		//' << EOF >$dummy.c
    508. 

  508. 		#include <sys/systemcfg.h>
    509. 

  509. 

  510. 		main()
    511. 

  511. 			{
    512. 

  512. 			if (!__power_pc())
    513. 

  513. 				exit(1);
    514. 

  514. 			puts("powerpc-ibm-aix3.2.5");
    515. 

  515. 			exit(0);
    516. 

  516. 			}
    517. 

  517. EOF
    518. 

  518. 		if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
    519. 

  519. 		then
    520. 

  520. 			echo "$SYSTEM_NAME"
    521. 

  521. 		else
    522. 

  522. 			echo rs6000-ibm-aix3.2.5
    523. 

  523. 		fi
    524. 

  524. 	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
    525. 

  525. 		echo rs6000-ibm-aix3.2.4
    526. 

  526. 	else
    527. 

  527. 		echo rs6000-ibm-aix3.2
    528. 

  528. 	fi
    529. 

  529. 	exit ;;
    530. 

  530.     *:AIX:*:[45])
    531. 

  531. 	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
    532. 

  532. 	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
    533. 

  533. 		IBM_ARCH=rs6000
    534. 

  534. 	else
    535. 

  535. 		IBM_ARCH=powerpc
    536. 

  536. 	fi
    537. 

  537. 	if [ -x /usr/bin/oslevel ] ; then
    538. 

  538. 		IBM_REV=`/usr/bin/oslevel`
    539. 

  539. 	else
    540. 

  540. 		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
    541. 

  541. 	fi
    542. 

  542. 	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
    543. 

  543. 	exit ;;
    544. 

  544.     *:AIX:*:*)
    545. 

  545. 	echo rs6000-ibm-aix
    546. 

  546. 	exit ;;
    547. 

  547.     ibmrt:4.4BSD:*|romp-ibm:BSD:*)
    548. 

  548. 	echo romp-ibm-bsd4.4
    549. 

  549. 	exit ;;
    550. 

  550.     ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
    551. 

  551. 	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
    552. 

  552. 	exit ;;                             # report: romp-ibm BSD 4.3
    553. 

  553.     *:BOSX:*:*)
    554. 

  554. 	echo rs6000-bull-bosx
    555. 

  555. 	exit ;;
    556. 

  556.     DPX/2?00:B.O.S.:*:*)
    557. 

  557. 	echo m68k-bull-sysv3
    558. 

  558. 	exit ;;
    559. 

  559.     9000/[34]??:4.3bsd:1.*:*)
    560. 

  560. 	echo m68k-hp-bsd
    561. 

  561. 	exit ;;
    562. 

  562.     hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
    563. 

  563. 	echo m68k-hp-bsd4.4
    564. 

  564. 	exit ;;
    565. 

  565.     9000/[34678]??:HP-UX:*:*)
    566. 

  566. 	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
    567. 

  567. 	case "${UNAME_MACHINE}" in
    568. 

  568. 	    9000/31? )            HP_ARCH=m68000 ;;
    569. 

  569. 	    9000/[34]?? )         HP_ARCH=m68k ;;
    570. 

  570. 	    9000/[678][0-9][0-9])
    571. 

  571. 		if [ -x /usr/bin/getconf ]; then
    572. 

  572. 		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
    573. 

  573.                     sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
    574. 

  574.                     case "${sc_cpu_version}" in
    575. 

  575.                       523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
    576. 

  576.                       528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
    577. 

  577.                       532)                      # CPU_PA_RISC2_0
    578. 

  578.                         case "${sc_kernel_bits}" in
    579. 

  579.                           32) HP_ARCH="hppa2.0n" ;;
    580. 

  580.                           64) HP_ARCH="hppa2.0w" ;;
    581. 

  581. 			  '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20
    582. 

  582.                         esac ;;
    583. 

  583.                     esac
    584. 

  584. 		fi
    585. 

  585. 		if [ "${HP_ARCH}" = "" ]; then
    586. 

  586. 		    eval $set_cc_for_build
    587. 

  587. 		    sed 's/^              //' << EOF >$dummy.c
    588. 

  588. 

  589.               #define _HPUX_SOURCE
    590. 

  590.               #include <stdlib.h>
    591. 

  591.               #include <unistd.h>
    592. 

  592. 

  593.               int main ()
    594. 

  594.               {
    595. 

  595.               #if defined(_SC_KERNEL_BITS)
    596. 

  596.                   long bits = sysconf(_SC_KERNEL_BITS);
    597. 

  597.               #endif
    598. 

  598.                   long cpu  = sysconf (_SC_CPU_VERSION);
    599. 

  599. 

  600.                   switch (cpu)
    601. 

  601.               	{
    602. 

  602.               	case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
    603. 

  603.               	case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
    604. 

  604.               	case CPU_PA_RISC2_0:
    605. 

  605.               #if defined(_SC_KERNEL_BITS)
    606. 

  606.               	    switch (bits)
    607. 

  607.               		{
    608. 

  608.               		case 64: puts ("hppa2.0w"); break;
    609. 

  609.               		case 32: puts ("hppa2.0n"); break;
    610. 

  610.               		default: puts ("hppa2.0"); break;
    611. 

  611.               		} break;
    612. 

  612.               #else  /* !defined(_SC_KERNEL_BITS) */
    613. 

  613.               	    puts ("hppa2.0"); break;
    614. 

  614.               #endif
    615. 

  615.               	default: puts ("hppa1.0"); break;
    616. 

  616.               	}
    617. 

  617.                   exit (0);
    618. 

  618.               }
    619. 

  619. EOF
    620. 

  620. 		    (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
    621. 

  621. 		    test -z "$HP_ARCH" && HP_ARCH=hppa
    622. 

  622. 		fi ;;
    623. 

  623. 	esac
    624. 

  624. 	if [ ${HP_ARCH} = "hppa2.0w" ]
    625. 

  625. 	then
    626. 

  626. 	    eval $set_cc_for_build
    627. 

  627. 

  628. 	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
    629. 

  629. 	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
    630. 

  630. 	    # generating 64-bit code.  GNU and HP use different nomenclature:
    631. 

  631. 	    #
    632. 

  632. 	    # $ CC_FOR_BUILD=cc ./config.guess
    633. 

  633. 	    # => hppa2.0w-hp-hpux11.23
    634. 

  634. 	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
    635. 

  635. 	    # => hppa64-hp-hpux11.23
    636. 

  636. 

  637. 	    if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
    638. 

  638. 		grep __LP64__ >/dev/null
    639. 

  639. 	    then
    640. 

  640. 		HP_ARCH="hppa2.0w"
    641. 

  641. 	    else
    642. 

  642. 		HP_ARCH="hppa64"
    643. 

  643. 	    fi
    644. 

  644. 	fi
    645. 

  645. 	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
    646. 

  646. 	exit ;;
    647. 

  647.     ia64:HP-UX:*:*)
    648. 

  648. 	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
    649. 

  649. 	echo ia64-hp-hpux${HPUX_REV}
    650. 

  650. 	exit ;;
    651. 

  651.     3050*:HI-UX:*:*)
    652. 

  652. 	eval $set_cc_for_build
    653. 

  653. 	sed 's/^	//' << EOF >$dummy.c
    654. 

  654. 	#include <unistd.h>
    655. 

  655. 	int
    656. 

  656. 	main ()
    657. 

  657. 	{
    658. 

  658. 	  long cpu = sysconf (_SC_CPU_VERSION);
    659. 

  659. 	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
    660. 

  660. 	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
    661. 

  661. 	     results, however.  */
    662. 

  662. 	  if (CPU_IS_PA_RISC (cpu))
    663. 

  663. 	    {
    664. 

  664. 	      switch (cpu)
    665. 

  665. 		{
    666. 

  666. 		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
    667. 

  667. 		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
    668. 

  668. 		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
    669. 

  669. 		  default: puts ("hppa-hitachi-hiuxwe2"); break;
    670. 

  670. 		}
    671. 

  671. 	    }
    672. 

  672. 	  else if (CPU_IS_HP_MC68K (cpu))
    673. 

  673. 	    puts ("m68k-hitachi-hiuxwe2");
    674. 

  674. 	  else puts ("unknown-hitachi-hiuxwe2");
    675. 

  675. 	  exit (0);
    676. 

  676. 	}
    677. 

  677. EOF
    678. 

  678. 	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
    679. 

  679. 		{ echo "$SYSTEM_NAME"; exit; }
    680. 

  680. 	echo unknown-hitachi-hiuxwe2
    681. 

  681. 	exit ;;
    682. 

  682.     9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
    683. 

  683. 	echo hppa1.1-hp-bsd
    684. 

  684. 	exit ;;
    685. 

  685.     9000/8??:4.3bsd:*:*)
    686. 

  686. 	echo hppa1.0-hp-bsd
    687. 

  687. 	exit ;;
    688. 

  688.     *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
    689. 

  689. 	echo hppa1.0-hp-mpeix
    690. 

  690. 	exit ;;
    691. 

  691.     hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
    692. 

  692. 	echo hppa1.1-hp-osf
    693. 

  693. 	exit ;;
    694. 

  694.     hp8??:OSF1:*:*)
    695. 

  695. 	echo hppa1.0-hp-osf
    696. 

  696. 	exit ;;
    697. 

  697.     i*86:OSF1:*:*)
    698. 

  698. 	if [ -x /usr/sbin/sysversion ] ; then
    699. 

  699. 	    echo ${UNAME_MACHINE}-unknown-osf1mk
    700. 

  700. 	else
    701. 

  701. 	    echo ${UNAME_MACHINE}-unknown-osf1
    702. 

  702. 	fi
    703. 

  703. 	exit ;;
    704. 

  704.     parisc*:Lites*:*:*)
    705. 

  705. 	echo hppa1.1-hp-lites
    706. 

  706. 	exit ;;
    707. 

  707.     C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
    708. 

  708. 	echo c1-convex-bsd
    709. 

  709.         exit ;;
    710. 

  710.     C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
    711. 

  711. 	if getsysinfo -f scalar_acc
    712. 

  712. 	then echo c32-convex-bsd
    713. 

  713. 	else echo c2-convex-bsd
    714. 

  714. 	fi
    715. 

  715.         exit ;;
    716. 

  716.     C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
    717. 

  717. 	echo c34-convex-bsd
    718. 

  718.         exit ;;
    719. 

  719.     C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
    720. 

  720. 	echo c38-convex-bsd
    721. 

  721.         exit ;;
    722. 

  722.     C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
    723. 

  723. 	echo c4-convex-bsd
    724. 

  724.         exit ;;
    725. 

  725.     CRAY*Y-MP:*:*:*)
    726. 

  726. 	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
    727. 

  727. 	exit ;;
    728. 

  728.     CRAY*[A-Z]90:*:*:*)
    729. 

  729. 	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
    730. 

  730. 	| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
    731. 

  731. 	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
    732. 

  732. 	      -e 's/\.[^.]*$/.X/'
    733. 

  733. 	exit ;;
    734. 

  734.     CRAY*TS:*:*:*)
    735. 

  735. 	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
    736. 

  736. 	exit ;;
    737. 

  737.     CRAY*T3E:*:*:*)
    738. 

  738. 	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
    739. 

  739. 	exit ;;
    740. 

  740.     CRAY*SV1:*:*:*)
    741. 

  741. 	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
    742. 

  742. 	exit ;;
    743. 

  743.     *:UNICOS/mp:*:*)
    744. 

  744. 	echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
    745. 

  745. 	exit ;;
    746. 

  746.     F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
    747. 

  747. 	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
    748. 

  748.         FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
    749. 

  749.         FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
    750. 

  750.         echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
    751. 

  751.         exit ;;
    752. 

  752.     5000:UNIX_System_V:4.*:*)
    753. 

  753.         FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
    754. 

  754.         FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
    755. 

  755.         echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
    756. 

  756. 	exit ;;
    757. 

  757.     i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
    758. 

  758. 	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
    759. 

  759. 	exit ;;
    760. 

  760.     sparc*:BSD/OS:*:*)
    761. 

  761. 	echo sparc-unknown-bsdi${UNAME_RELEASE}
    762. 

  762. 	exit ;;
    763. 

  763.     *:BSD/OS:*:*)
    764. 

  764. 	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
    765. 

  765. 	exit ;;
    766. 

  766.     *:FreeBSD:*:*)
    767. 

  767. 	echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
    768. 

  768. 	exit ;;
    769. 

  769.     i*:CYGWIN*:*)
    770. 

  770. 	echo ${UNAME_MACHINE}-pc-cygwin
    771. 

  771. 	exit ;;
    772. 

  772.     i*:MINGW*:*)
    773. 

  773. 	echo ${UNAME_MACHINE}-pc-mingw32
    774. 

  774. 	exit ;;
    775. 

  775. #### MozillaHack 
    776. 

  776. # Netscape's hacked uname
    777. 

  777.     xx:WINNT:* | xx:WIN95:*)
    778. 

  778. 	echo i586-pc-msvc
    779. 

  779. 	exit ;;
    780. 

  780. ###  End MozillaHack
    781. 

  781.     i*:windows32*:*)
    782. 

  782.     	# uname -m includes "-pc" on this system.
    783. 

  783.     	echo ${UNAME_MACHINE}-mingw32
    784. 

  784. 	exit ;;
    785. 

  785.     i*:PW*:*)
    786. 

  786. 	echo ${UNAME_MACHINE}-pc-pw32
    787. 

  787. 	exit ;;
    788. 

  788.     x86:Interix*:[34]*)
    789. 

  789. 	echo i586-pc-interix${UNAME_RELEASE}|sed -e 's/\..*//'
    790. 

  790. 	exit ;;
    791. 

  791.     [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
    792. 

  792. 	echo i${UNAME_MACHINE}-pc-mks
    793. 

  793. 	exit ;;
    794. 

  794.     i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
    795. 

  795. 	# How do we know it's Interix rather than the generic POSIX subsystem?
    796. 

  796. 	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
    797. 

  797. 	# UNAME_MACHINE based on the output of uname instead of i386?
    798. 

  798. 	echo i586-pc-interix
    799. 

  799. 	exit ;;
    800. 

  800.     i*:UWIN*:*)
    801. 

  801. 	echo ${UNAME_MACHINE}-pc-uwin
    802. 

  802. 	exit ;;
    803. 

  803.     amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
    804. 

  804. 	echo x86_64-unknown-cygwin
    805. 

  805. 	exit ;;
    806. 

  806.     p*:CYGWIN*:*)
    807. 

  807. 	echo powerpcle-unknown-cygwin
    808. 

  808. 	exit ;;
    809. 

  809.     prep*:SunOS:5.*:*)
    810. 

  810. 	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
    811. 

  811. 	exit ;;
    812. 

  812.     *:GNU:*:*)
    813. 

  813. 	# the GNU system
    814. 

  814. 	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
    815. 

  815. 	exit ;;
    816. 

  816.     *:GNU/*:*:*)
    817. 

  817. 	# other systems with GNU libc and userland
    818. 

  818. 	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu
    819. 

  819. 	exit ;;
    820. 

  820.     i*86:Minix:*:*)
    821. 

  821. 	echo ${UNAME_MACHINE}-pc-minix
    822. 

  822. 	exit ;;
    823. 

  823.     arm*:Linux:*:*)
    824. 

  824. 	echo ${UNAME_MACHINE}-unknown-linux-gnu
    825. 

  825. 	exit ;;
    826. 

  826.     cris:Linux:*:*)
    827. 

  827. 	echo cris-axis-linux-gnu
    828. 

  828. 	exit ;;
    829. 

  829.     crisv32:Linux:*:*)
    830. 

  830. 	echo crisv32-axis-linux-gnu
    831. 

  831. 	exit ;;
    832. 

  832.     frv:Linux:*:*)
    833. 

  833.     	echo frv-unknown-linux-gnu
    834. 

  834. 	exit ;;
    835. 

  835.     ia64:Linux:*:*)
    836. 

  836. 	echo ${UNAME_MACHINE}-unknown-linux-gnu
    837. 

  837. 	exit ;;
    838. 

  838.     m32r*:Linux:*:*)
    839. 

  839. 	echo ${UNAME_MACHINE}-unknown-linux-gnu
    840. 

  840. 	exit ;;
    841. 

  841.     m68*:Linux:*:*)
    842. 

  842. 	echo ${UNAME_MACHINE}-unknown-linux-gnu
    843. 

  843. 	exit ;;
    844. 

  844.     mips:Linux:*:*)
    845. 

  845. 	eval $set_cc_for_build
    846. 

  846. 	sed 's/^	//' << EOF >$dummy.c
    847. 

  847. 	#undef CPU
    848. 

  848. 	#undef mips
    849. 

  849. 	#undef mipsel
    850. 

  850. 	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
    851. 

  851. 	CPU=mipsel
    852. 

  852. 	#else
    853. 

  853. 	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
    854. 

  854. 	CPU=mips
    855. 

  855. 	#else
    856. 

  856. 	CPU=
    857. 

  857. 	#endif
    858. 

  858. 	#endif
    859. 

  859. EOF
    860. 

  860. 	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=`
    861. 

  861. 	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
    862. 

  862. 	;;
    863. 

  863.     mips64:Linux:*:*)
    864. 

  864. 	eval $set_cc_for_build
    865. 

  865. 	sed 's/^	//' << EOF >$dummy.c
    866. 

  866. 	#undef CPU
    867. 

  867. 	#undef mips64
    868. 

  868. 	#undef mips64el
    869. 

  869. 	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
    870. 

  870. 	CPU=mips64el
    871. 

  871. 	#else
    872. 

  872. 	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
    873. 

  873. 	CPU=mips64
    874. 

  874. 	#else
    875. 

  875. 	CPU=
    876. 

  876. 	#endif
    877. 

  877. 	#endif
    878. 

  878. EOF
    879. 

  879. 	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^CPU=`
    880. 

  880. 	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; }
    881. 

  881. 	;;
    882. 

  882.     or32:Linux:*:*)
    883. 

  883. 	echo or32-unknown-linux-gnu
    884. 

  884. 	exit ;;
    885. 

  885.     ppc:Linux:*:*)
    886. 

  886. 	echo powerpc-unknown-linux-gnu
    887. 

  887. 	exit ;;
    888. 

  888.     ppc64:Linux:*:*)
    889. 

  889. 	echo powerpc64-unknown-linux-gnu
    890. 

  890. 	exit ;;
    891. 

  891.     alpha:Linux:*:*)
    892. 

  892. 	case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
    893. 

  893. 	  EV5)   UNAME_MACHINE=alphaev5 ;;
    894. 

  894. 	  EV56)  UNAME_MACHINE=alphaev56 ;;
    895. 

  895. 	  PCA56) UNAME_MACHINE=alphapca56 ;;
    896. 

  896. 	  PCA57) UNAME_MACHINE=alphapca56 ;;
    897. 

  897. 	  EV6)   UNAME_MACHINE=alphaev6 ;;
    898. 

  898. 	  EV67)  UNAME_MACHINE=alphaev67 ;;
    899. 

  899. 	  EV68*) UNAME_MACHINE=alphaev68 ;;
    900. 

  900.         esac
    901. 

  901. 	objdump --private-headers /bin/sh | grep ld.so.1 >/dev/null
    902. 

  902. 	if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi
    903. 

  903. 	echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC}
    904. 

  904. 	exit ;;
    905. 

  905.     parisc:Linux:*:* | hppa:Linux:*:*)
    906. 

  906. 	# Look for CPU level
    907. 

  907. 	case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
    908. 

  908. 	  PA7*) echo hppa1.1-unknown-linux-gnu ;;
    909. 

  909. 	  PA8*) echo hppa2.0-unknown-linux-gnu ;;
    910. 

  910. 	  *)    echo hppa-unknown-linux-gnu ;;
    911. 

  911. 	esac
    912. 

  912. 	exit ;;
    913. 

  913.     parisc64:Linux:*:* | hppa64:Linux:*:*)
    914. 

  914. 	echo hppa64-unknown-linux-gnu
    915. 

  915. 	exit ;;
    916. 

  916.     s390:Linux:*:* | s390x:Linux:*:*)
    917. 

  917. 	echo ${UNAME_MACHINE}-ibm-linux
    918. 

  918. 	exit ;;
    919. 

  919.     sh64*:Linux:*:*)
    920. 

  920.     	echo ${UNAME_MACHINE}-unknown-linux-gnu
    921. 

  921. 	exit ;;
    922. 

  922.     sh*:Linux:*:*)
    923. 

  923. 	echo ${UNAME_MACHINE}-unknown-linux-gnu
    924. 

  924. 	exit ;;
    925. 

  925.     sparc:Linux:*:* | sparc64:Linux:*:*)
    926. 

  926. 	echo ${UNAME_MACHINE}-unknown-linux-gnu
    927. 

  927. 	exit ;;
    928. 

  928.     x86_64:Linux:*:*)
    929. 

  929. 	echo x86_64-unknown-linux-gnu
    930. 

  930. 	exit ;;
    931. 

  931.     i*86:Linux:*:*)
    932. 

  932. 	# The BFD linker knows what the default object file format is, so
    933. 

  933. 	# first see if it will tell us. cd to the root directory to prevent
    934. 

  934. 	# problems with other programs or directories called `ld' in the path.
    935. 

  935. 	# Set LC_ALL=C to ensure ld outputs messages in English.
    936. 

  936. 	ld_supported_targets=`cd /; LC_ALL=C ld --help 2>&1 \
    937. 

  937. 			 | sed -ne '/supported targets:/!d
    938. 

  938. 				    s/[ 	][ 	]*/ /g
    939. 

  939. 				    s/.*supported targets: *//
    940. 

  940. 				    s/ .*//
    941. 

  941. 				    p'`
    942. 

  942.         case "$ld_supported_targets" in
    943. 

  943. 	  elf32-i386)
    944. 

  944. 		TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
    945. 

  945. 		;;
    946. 

  946. 	  a.out-i386-linux)
    947. 

  947. 		echo "${UNAME_MACHINE}-pc-linux-gnuaout"
    948. 

  948. 		exit ;;
    949. 

  949. 	  coff-i386)
    950. 

  950. 		echo "${UNAME_MACHINE}-pc-linux-gnucoff"
    951. 

  951. 		exit ;;
    952. 

  952. 	  "")
    953. 

  953. 		# Either a pre-BFD a.out linker (linux-gnuoldld) or
    954. 

  954. 		# one that does not give us useful --help.
    955. 

  955. 		echo "${UNAME_MACHINE}-pc-linux-gnuoldld"
    956. 

  956. 		exit ;;
    957. 

  957. 	esac
    958. 

  958. 	# Determine whether the default compiler is a.out or elf
    959. 

  959. 	eval $set_cc_for_build
    960. 

  960. 	sed 's/^	//' << EOF >$dummy.c
    961. 

  961. 	#include <features.h>
    962. 

  962. 	#ifdef __ELF__
    963. 

  963. 	# ifdef __GLIBC__
    964. 

  964. 	#  if __GLIBC__ >= 2
    965. 

  965. 	LIBC=gnu
    966. 

  966. 	#  else
    967. 

  967. 	LIBC=gnulibc1
    968. 

  968. 	#  endif
    969. 

  969. 	# else
    970. 

  970. 	LIBC=gnulibc1
    971. 

  971. 	# endif
    972. 

  972. 	#else
    973. 

  973. 	#ifdef __INTEL_COMPILER
    974. 

  974. 	LIBC=gnu
    975. 

  975. 	#else
    976. 

  976. 	LIBC=gnuaout
    977. 

  977. 	#endif
    978. 

  978. 	#endif
    979. 

  979. 	#ifdef __dietlibc__
    980. 

  980. 	LIBC=dietlibc
    981. 

  981. 	#endif
    982. 

  982. EOF
    983. 

  983. 	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep ^LIBC=`
    984. 

  984. 	test x"${LIBC}" != x && {
    985. 

  985. 		echo "${UNAME_MACHINE}-pc-linux-${LIBC}"
    986. 

  986. 		exit
    987. 

  987. 	}
    988. 

  988. 	test x"${TENTATIVE}" != x && { echo "${TENTATIVE}"; exit; }
    989. 

  989. 	;;
    990. 

  990.     i*86:DYNIX/ptx:4*:*)
    991. 

  991. 	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
    992. 

  992. 	# earlier versions are messed up and put the nodename in both
    993. 

  993. 	# sysname and nodename.
    994. 

  994. 	echo i386-sequent-sysv4
    995. 

  995. 	exit ;;
    996. 

  996.     i*86:UNIX_SV:4.2MP:2.*)
    997. 

  997.         # Unixware is an offshoot of SVR4, but it has its own version
    998. 

  998.         # number series starting with 2...
    999. 

  999.         # I am not positive that other SVR4 systems won't match this,
    1000. 

  1000. 	# I just have to hope.  -- rms.
    1001. 

  1001.         # Use sysv4.2uw... so that sysv4* matches it.
    1002. 

  1002. 	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
    1003. 

  1003. 	exit ;;
    1004. 

  1004.     i*86:OS/2:*:*)
    1005. 

  1005. 	# If we were able to find `uname', then EMX Unix compatibility
    1006. 

  1006. 	# is probably installed.
    1007. 

  1007. 	echo ${UNAME_MACHINE}-pc-os2-emx
    1008. 

  1008. 	exit ;;
    1009. 

  1009.     i*86:XTS-300:*:STOP)
    1010. 

  1010. 	echo ${UNAME_MACHINE}-unknown-stop
    1011. 

  1011. 	exit ;;
    1012. 

  1012.     i*86:atheos:*:*)
    1013. 

  1013. 	echo ${UNAME_MACHINE}-unknown-atheos
    1014. 

  1014. 	exit ;;
    1015. 

  1015.     i*86:syllable:*:*)
    1016. 

  1016. 	echo ${UNAME_MACHINE}-pc-syllable
    1017. 

  1017. 	exit ;;
    1018. 

  1018.     i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)
    1019. 

  1019. 	echo i386-unknown-lynxos${UNAME_RELEASE}
    1020. 

  1020. 	exit ;;
    1021. 

  1021.     i*86:*DOS:*:*)
    1022. 

  1022. 	echo ${UNAME_MACHINE}-pc-msdosdjgpp
    1023. 

  1023. 	exit ;;
    1024. 

  1024.     i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
    1025. 

  1025. 	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
    1026. 

  1026. 	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
    1027. 

  1027. 		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
    1028. 

  1028. 	else
    1029. 

  1029. 		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
    1030. 

  1030. 	fi
    1031. 

  1031. 	exit ;;
    1032. 

  1032.     i*86:*:5:[678]*)
    1033. 

  1033.     	# UnixWare 7.x, OpenUNIX and OpenServer 6.
    1034. 

  1034. 	case `/bin/uname -X | grep "^Machine"` in
    1035. 

  1035. 	    *486*)	     UNAME_MACHINE=i486 ;;
    1036. 

  1036. 	    *Pentium)	     UNAME_MACHINE=i586 ;;
    1037. 

  1037. 	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
    1038. 

  1038. 	esac
    1039. 

  1039. 	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
    1040. 

  1040. 	exit ;;
    1041. 

  1041.     i*86:*:3.2:*)
    1042. 

  1042. 	if test -f /usr/options/cb.name; then
    1043. 

  1043. 		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
    1044. 

  1044. 		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
    1045. 

  1045. 	elif /bin/uname -X 2>/dev/null >/dev/null ; then
    1046. 

  1046. 		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
    1047. 

  1047. 		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
    1048. 

  1048. 		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
    1049. 

  1049. 			&& UNAME_MACHINE=i586
    1050. 

  1050. 		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
    1051. 

  1051. 			&& UNAME_MACHINE=i686
    1052. 

  1052. 		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
    1053. 

  1053. 			&& UNAME_MACHINE=i686
    1054. 

  1054. 		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
    1055. 

  1055. 	else
    1056. 

  1056. 		echo ${UNAME_MACHINE}-pc-sysv32
    1057. 

  1057. 	fi
    1058. 

  1058. 	exit ;;
    1059. 

  1059.     pc:*:*:*)
    1060. 

  1060. 	# Left here for compatibility:
    1061. 

  1061.         # uname -m prints for DJGPP always 'pc', but it prints nothing about
    1062. 

  1062.         # the processor, so we play safe by assuming i386.
    1063. 

  1063. 	echo i386-pc-msdosdjgpp
    1064. 

  1064.         exit ;;
    1065. 

  1065.     Intel:Mach:3*:*)
    1066. 

  1066. 	echo i386-pc-mach3
    1067. 

  1067. 	exit ;;
    1068. 

  1068.     paragon:*:*:*)
    1069. 

  1069. 	echo i860-intel-osf1
    1070. 

  1070. 	exit ;;
    1071. 

  1071.     i860:*:4.*:*) # i860-SVR4
    1072. 

  1072. 	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
    1073. 

  1073. 	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
    1074. 

  1074. 	else # Add other i860-SVR4 vendors below as they are discovered.
    1075. 

  1075. 	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
    1076. 

  1076. 	fi
    1077. 

  1077. 	exit ;;
    1078. 

  1078.     mini*:CTIX:SYS*5:*)
    1079. 

  1079. 	# "miniframe"
    1080. 

  1080. 	echo m68010-convergent-sysv
    1081. 

  1081. 	exit ;;
    1082. 

  1082.     mc68k:UNIX:SYSTEM5:3.51m)
    1083. 

  1083. 	echo m68k-convergent-sysv
    1084. 

  1084. 	exit ;;
    1085. 

  1085.     M680?0:D-NIX:5.3:*)
    1086. 

  1086. 	echo m68k-diab-dnix
    1087. 

  1087. 	exit ;;
    1088. 

  1088.     M68*:*:R3V[5678]*:*)
    1089. 

  1089. 	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
    1090. 

  1090.     3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
    1091. 

  1091. 	OS_REL=''
    1092. 

  1092. 	test -r /etc/.relid \
    1093. 

  1093. 	&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
    1094. 

  1094. 	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
    1095. 

  1095. 	  && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
    1096. 

  1096. 	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
    1097. 

  1097. 	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
    1098. 

  1098.     3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
    1099. 

  1099.         /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
    1100. 

  1100.           && { echo i486-ncr-sysv4; exit; } ;;
    1101. 

  1101.     m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
    1102. 

  1102. 	echo m68k-unknown-lynxos${UNAME_RELEASE}
    1103. 

  1103. 	exit ;;
    1104. 

  1104.     mc68030:UNIX_System_V:4.*:*)
    1105. 

  1105. 	echo m68k-atari-sysv4
    1106. 

  1106. 	exit ;;
    1107. 

  1107.     TSUNAMI:LynxOS:2.*:*)
    1108. 

  1108. 	echo sparc-unknown-lynxos${UNAME_RELEASE}
    1109. 

  1109. 	exit ;;
    1110. 

  1110.     rs6000:LynxOS:2.*:*)
    1111. 

  1111. 	echo rs6000-unknown-lynxos${UNAME_RELEASE}
    1112. 

  1112. 	exit ;;
    1113. 

  1113.     PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)
    1114. 

  1114. 	echo powerpc-unknown-lynxos${UNAME_RELEASE}
    1115. 

  1115. 	exit ;;
    1116. 

  1116.     SM[BE]S:UNIX_SV:*:*)
    1117. 

  1117. 	echo mips-dde-sysv${UNAME_RELEASE}
    1118. 

  1118. 	exit ;;
    1119. 

  1119.     RM*:ReliantUNIX-*:*:*)
    1120. 

  1120. 	echo mips-sni-sysv4
    1121. 

  1121. 	exit ;;
    1122. 

  1122.     RM*:SINIX-*:*:*)
    1123. 

  1123. 	echo mips-sni-sysv4
    1124. 

  1124. 	exit ;;
    1125. 

  1125.     *:SINIX-*:*:*)
    1126. 

  1126. 	if uname -p 2>/dev/null >/dev/null ; then
    1127. 

  1127. 		UNAME_MACHINE=`(uname -p) 2>/dev/null`
    1128. 

  1128. 		echo ${UNAME_MACHINE}-sni-sysv4
    1129. 

  1129. 	else
    1130. 

  1130. 		echo ns32k-sni-sysv
    1131. 

  1131. 	fi
    1132. 

  1132. 	exit ;;
    1133. 

  1133.     PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
    1134. 

  1134.                       # says <Richard.M.Bartel@ccMail.Census.GOV>
    1135. 

  1135.         echo i586-unisys-sysv4
    1136. 

  1136.         exit ;;
    1137. 

  1137. #### MozillaHack 
    1138. 

  1138.     *:*OpenVMS*:*:*)
    1139. 

  1139.         case "${UNAME_SYSTEM}" in
    1140. 

  1140.             POSIX_for_OpenVMS_AXP) echo alpha-dec-openvmsposix ;;
    1141. 

  1141.             POSIX_for_OpenVMS_VAX) echo vax-dec-openvmsposix ;;
    1142. 

  1142.             OpenVMS) echo alpha-dec-openvms ;;
    1143. 

  1143.             *) echo unknown-dec-openvms ;;
    1144. 

  1144.         esac
    1145. 

  1145.         exit ;;
    1146. 

  1146. #### End MozillaHack 
    1147. 

  1147.     *:UNIX_System_V:4*:FTX*)
    1148. 

  1148. 	# From Gerald Hewes <hewes@openmarket.com>.
    1149. 

  1149. 	# How about differentiating between stratus architectures? -djm
    1150. 

  1150. 	echo hppa1.1-stratus-sysv4
    1151. 

  1151. 	exit ;;
    1152. 

  1152.     *:*:*:FTX*)
    1153. 

  1153. 	# From seanf@swdc.stratus.com.
    1154. 

  1154. 	echo i860-stratus-sysv4
    1155. 

  1155. 	exit ;;
    1156. 

  1156.     i*86:VOS:*:*)
    1157. 

  1157. 	# From Paul.Green@stratus.com.
    1158. 

  1158. 	echo ${UNAME_MACHINE}-stratus-vos
    1159. 

  1159. 	exit ;;
    1160. 

  1160.     *:VOS:*:*)
    1161. 

  1161. 	# From Paul.Green@stratus.com.
    1162. 

  1162. 	echo hppa1.1-stratus-vos
    1163. 

  1163. 	exit ;;
    1164. 

  1164.     mc68*:A/UX:*:*)
    1165. 

  1165. 	echo m68k-apple-aux${UNAME_RELEASE}
    1166. 

  1166. 	exit ;;
    1167. 

  1167.     news*:NEWS-OS:6*:*)
    1168. 

  1168. 	echo mips-sony-newsos6
    1169. 

  1169. 	exit ;;
    1170. 

  1170.     R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
    1171. 

  1171. 	if [ -d /usr/nec ]; then
    1172. 

  1172. 	        echo mips-nec-sysv${UNAME_RELEASE}
    1173. 

  1173. 	else
    1174. 

  1174. 	        echo mips-unknown-sysv${UNAME_RELEASE}
    1175. 

  1175. 	fi
    1176. 

  1176.         exit ;;
    1177. 

  1177.     BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
    1178. 

  1178. 	echo powerpc-be-beos
    1179. 

  1179. 	exit ;;
    1180. 

  1180.     BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
    1181. 

  1181. 	echo powerpc-apple-beos
    1182. 

  1182. 	exit ;;
    1183. 

  1183.     BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
    1184. 

  1184. 	echo i586-pc-beos
    1185. 

  1185. 	exit ;;
    1186. 

  1186.     SX-4:SUPER-UX:*:*)
    1187. 

  1187. 	echo sx4-nec-superux${UNAME_RELEASE}
    1188. 

  1188. 	exit ;;
    1189. 

  1189.     SX-5:SUPER-UX:*:*)
    1190. 

  1190. 	echo sx5-nec-superux${UNAME_RELEASE}
    1191. 

  1191. 	exit ;;
    1192. 

  1192.     SX-6:SUPER-UX:*:*)
    1193. 

  1193. 	echo sx6-nec-superux${UNAME_RELEASE}
    1194. 

  1194. 	exit ;;
    1195. 

  1195.     Power*:Rhapsody:*:*)
    1196. 

  1196. 	echo powerpc-apple-rhapsody${UNAME_RELEASE}
    1197. 

  1197. 	exit ;;
    1198. 

  1198.     *:Rhapsody:*:*)
    1199. 

  1199. 	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
    1200. 

  1200. 	exit ;;
    1201. 

  1201.     *:Darwin:*:*)
    1202. 

  1202. 	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
    1203. 

  1203. 	case $UNAME_PROCESSOR in
    1204. 

  1204. 	    unknown) UNAME_PROCESSOR=powerpc ;;
    1205. 

  1205. 	esac
    1206. 

  1206. 	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
    1207. 

  1207. 	exit ;;
    1208. 

  1208.     *:procnto*:*:* | *:QNX:[0123456789]*:*)
    1209. 

  1209. 	UNAME_PROCESSOR=`uname -p`
    1210. 

  1210. 	if test "$UNAME_PROCESSOR" = "x86"; then
    1211. 

  1211. 		UNAME_PROCESSOR=i386
    1212. 

  1212. 		UNAME_MACHINE=pc
    1213. 

  1213. 	fi
    1214. 

  1214. 	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
    1215. 

  1215. 	exit ;;
    1216. 

  1216.     *:QNX:*:4*)
    1217. 

  1217. 	echo i386-pc-qnx
    1218. 

  1218. 	exit ;;
    1219. 

  1219.     NSE-?:NONSTOP_KERNEL:*:*)
    1220. 

  1220. 	echo nse-tandem-nsk${UNAME_RELEASE}
    1221. 

  1221. 	exit ;;
    1222. 

  1222.     NSR-?:NONSTOP_KERNEL:*:*)
    1223. 

  1223. 	echo nsr-tandem-nsk${UNAME_RELEASE}
    1224. 

  1224. 	exit ;;
    1225. 

  1225.     *:NonStop-UX:*:*)
    1226. 

  1226. 	echo mips-compaq-nonstopux
    1227. 

  1227. 	exit ;;
    1228. 

  1228.     BS2000:POSIX*:*:*)
    1229. 

  1229. 	echo bs2000-siemens-sysv
    1230. 

  1230. 	exit ;;
    1231. 

  1231.     DS/*:UNIX_System_V:*:*)
    1232. 

  1232. 	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
    1233. 

  1233. 	exit ;;
    1234. 

  1234.     *:Plan9:*:*)
    1235. 

  1235. 	# "uname -m" is not consistent, so use $cputype instead. 386
    1236. 

  1236. 	# is converted to i386 for consistency with other x86
    1237. 

  1237. 	# operating systems.
    1238. 

  1238. 	if test "$cputype" = "386"; then
    1239. 

  1239. 	    UNAME_MACHINE=i386
    1240. 

  1240. 	else
    1241. 

  1241. 	    UNAME_MACHINE="$cputype"
    1242. 

  1242. 	fi
    1243. 

  1243. 	echo ${UNAME_MACHINE}-unknown-plan9
    1244. 

  1244. 	exit ;;
    1245. 

  1245.     *:TOPS-10:*:*)
    1246. 

  1246. 	echo pdp10-unknown-tops10
    1247. 

  1247. 	exit ;;
    1248. 

  1248.     *:TENEX:*:*)
    1249. 

  1249. 	echo pdp10-unknown-tenex
    1250. 

  1250. 	exit ;;
    1251. 

  1251.     KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
    1252. 

  1252. 	echo pdp10-dec-tops20
    1253. 

  1253. 	exit ;;
    1254. 

  1254.     XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
    1255. 

  1255. 	echo pdp10-xkl-tops20
    1256. 

  1256. 	exit ;;
    1257. 

  1257.     *:TOPS-20:*:*)
    1258. 

  1258. 	echo pdp10-unknown-tops20
    1259. 

  1259. 	exit ;;
    1260. 

  1260.     *:ITS:*:*)
    1261. 

  1261. 	echo pdp10-unknown-its
    1262. 

  1262. 	exit ;;
    1263. 

  1263.     SEI:*:*:SEIUX)
    1264. 

  1264.         echo mips-sei-seiux${UNAME_RELEASE}
    1265. 

  1265. 	exit ;;
    1266. 

  1266.     *:DragonFly:*:*)
    1267. 

  1267. 	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
    1268. 

  1268. 	exit ;;
    1269. 

  1269.     *:*VMS:*:*)
    1270. 

  1270.     	UNAME_MACHINE=`(uname -p) 2>/dev/null`
    1271. 

  1271. 	case "${UNAME_MACHINE}" in
    1272. 

  1272. 	    A*) echo alpha-dec-vms ; exit ;;
    1273. 

  1273. 	    I*) echo ia64-dec-vms ; exit ;;
    1274. 

  1274. 	    V*) echo vax-dec-vms ; exit ;;
    1275. 

  1275. 	esac ;;
    1276. 

  1276.     *:XENIX:*:SysV)
    1277. 

  1277. 	echo i386-pc-xenix
    1278. 

  1278. 	exit ;;
    1279. 

  1279.     i*86:skyos:*:*)
    1280. 

  1280. 	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
    1281. 

  1281. 	exit ;;
    1282. 

  1282. esac
    1283. 

  1283. 

  1284. #echo '(No uname command or uname output not recognized.)' 1>&2
    1285. 

  1285. #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2
    1286. 

  1286. 

  1287. eval $set_cc_for_build
    1288. 

  1288. cat >$dummy.c <<EOF
    1289. 

  1289. #ifdef _SEQUENT_
    1290. 

  1290. # include <sys/types.h>
    1291. 

  1291. # include <sys/utsname.h>
    1292. 

  1292. #endif
    1293. 

  1293. main ()
    1294. 

  1294. {
    1295. 

  1295. #if defined (sony)
    1296. 

  1296. #if defined (MIPSEB)
    1297. 

  1297.   /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
    1298. 

  1298.      I don't know....  */
    1299. 

  1299.   printf ("mips-sony-bsd\n"); exit (0);
    1300. 

  1300. #else
    1301. 

  1301. #include <sys/param.h>
    1302. 

  1302.   printf ("m68k-sony-newsos%s\n",
    1303. 

  1303. #ifdef NEWSOS4
    1304. 

  1304.           "4"
    1305. 

  1305. #else
    1306. 

  1306. 	  ""
    1307. 

  1307. #endif
    1308. 

  1308.          ); exit (0);
    1309. 

  1309. #endif
    1310. 

  1310. #endif
    1311. 

  1311. 

  1312. #if defined (__arm) && defined (__acorn) && defined (__unix)
    1313. 

  1313.   printf ("arm-acorn-riscix\n"); exit (0);
    1314. 

  1314. #endif
    1315. 

  1315. 

  1316. #if defined (hp300) && !defined (hpux)
    1317. 

  1317.   printf ("m68k-hp-bsd\n"); exit (0);
    1318. 

  1318. #endif
    1319. 

  1319. 

  1320. #if defined (NeXT)
    1321. 

  1321. #if !defined (__ARCHITECTURE__)
    1322. 

  1322. #define __ARCHITECTURE__ "m68k"
    1323. 

  1323. #endif
    1324. 

  1324.   int version;
    1325. 

  1325.   version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
    1326. 

  1326.   if (version < 4)
    1327. 

  1327.     printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
    1328. 

  1328.   else
    1329. 

  1329.     printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
    1330. 

  1330.   exit (0);
    1331. 

  1331. #endif
    1332. 

  1332. 

  1333. #if defined (MULTIMAX) || defined (n16)
    1334. 

  1334. #if defined (UMAXV)
    1335. 

  1335.   printf ("ns32k-encore-sysv\n"); exit (0);
    1336. 

  1336. #else
    1337. 

  1337. #if defined (CMU)
    1338. 

  1338.   printf ("ns32k-encore-mach\n"); exit (0);
    1339. 

  1339. #else
    1340. 

  1340.   printf ("ns32k-encore-bsd\n"); exit (0);
    1341. 

  1341. #endif
    1342. 

  1342. #endif
    1343. 

  1343. #endif
    1344. 

  1344. 

  1345. #if defined (__386BSD__)
    1346. 

  1346.   printf ("i386-pc-bsd\n"); exit (0);
    1347. 

  1347. #endif
    1348. 

  1348. 

  1349. #if defined (sequent)
    1350. 

  1350. #if defined (i386)
    1351. 

  1351.   printf ("i386-sequent-dynix\n"); exit (0);
    1352. 

  1352. #endif
    1353. 

  1353. #if defined (ns32000)
    1354. 

  1354.   printf ("ns32k-sequent-dynix\n"); exit (0);
    1355. 

  1355. #endif
    1356. 

  1356. #endif
    1357. 

  1357. 

  1358. #if defined (_SEQUENT_)
    1359. 

  1359.     struct utsname un;
    1360. 

  1360. 

  1361.     uname(&un);
    1362. 

  1362. 

  1363.     if (strncmp(un.version, "V2", 2) == 0) {
    1364. 

  1364. 	printf ("i386-sequent-ptx2\n"); exit (0);
    1365. 

  1365.     }
    1366. 

  1366.     if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
    1367. 

  1367. 	printf ("i386-sequent-ptx1\n"); exit (0);
    1368. 

  1368.     }
    1369. 

  1369.     printf ("i386-sequent-ptx\n"); exit (0);
    1370. 

  1370. 

  1371. #endif
    1372. 

  1372. 

  1373. #if defined (vax)
    1374. 

  1374. # if !defined (ultrix)
    1375. 

  1375. #  include <sys/param.h>
    1376. 

  1376. #  if defined (BSD)
    1377. 

  1377. #   if BSD == 43
    1378. 

  1378.       printf ("vax-dec-bsd4.3\n"); exit (0);
    1379. 

  1379. #   else
    1380. 

  1380. #    if BSD == 199006
    1381. 

  1381.       printf ("vax-dec-bsd4.3reno\n"); exit (0);
    1382. 

  1382. #    else
    1383. 

  1383.       printf ("vax-dec-bsd\n"); exit (0);
    1384. 

  1384. #    endif
    1385. 

  1385. #   endif
    1386. 

  1386. #  else
    1387. 

  1387.     printf ("vax-dec-bsd\n"); exit (0);
    1388. 

  1388. #  endif
    1389. 

  1389. # else
    1390. 

  1390.     printf ("vax-dec-ultrix\n"); exit (0);
    1391. 

  1391. # endif
    1392. 

  1392. #endif
    1393. 

  1393. 

  1394. #if defined (alliant) && defined (i860)
    1395. 

  1395.   printf ("i860-alliant-bsd\n"); exit (0);
    1396. 

  1396. #endif
    1397. 

  1397. 

  1398.   exit (1);
    1399. 

  1399. }
    1400. 

  1400. EOF
    1401. 

  1401. 

  1402. $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&
    1403. 

  1403. 	{ echo "$SYSTEM_NAME"; exit; }
    1404. 

  1404. 

  1405. # Apollos put the system type in the environment.
    1406. 

  1406. 

  1407. test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }
    1408. 

  1408. 

  1409. # Convex versions that predate uname can use getsysinfo(1)
    1410. 

  1410. 

  1411. if [ -x /usr/convex/getsysinfo ]
    1412. 

  1412. then
    1413. 

  1413.     case `getsysinfo -f cpu_type` in
    1414. 

  1414.     c1*)
    1415. 

  1415. 	echo c1-convex-bsd
    1416. 

  1416. 	exit ;;
    1417. 

  1417.     c2*)
    1418. 

  1418. 	if getsysinfo -f scalar_acc
    1419. 

  1419. 	then echo c32-convex-bsd
    1420. 

  1420. 	else echo c2-convex-bsd
    1421. 

  1421. 	fi
    1422. 

  1422. 	exit ;;
    1423. 

  1423.     c34*)
    1424. 

  1424. 	echo c34-convex-bsd
    1425. 

  1425. 	exit ;;
    1426. 

  1426.     c38*)
    1427. 

  1427. 	echo c38-convex-bsd
    1428. 

  1428. 	exit ;;
    1429. 

  1429.     c4*)
    1430. 

  1430. 	echo c4-convex-bsd
    1431. 

  1431. 	exit ;;
    1432. 

  1432.     esac
    1433. 

  1433. fi
    1434. 

  1434. 

  1435. cat >&2 <<EOF
    1436. 

  1436. $0: unable to guess system type
    1437. 

  1437. 

  1438. This script, last modified $timestamp, has failed to recognize
    1439. 

  1439. the operating system you are using. It is advised that you
    1440. 

  1440. download the most up to date version of the config scripts from
    1441. 

  1441. 

  1442.   http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.guess
    1443. 

  1443. and
    1444. 

  1444.   http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/config/config/config.sub
    1445. 

  1445. 

  1446. If the version you run ($0) is already up to date, please
    1447. 

  1447. send the following data and any information you think might be
    1448. 

  1448. pertinent to <config-patches@gnu.org> in order to provide the needed
    1449. 

  1449. information to handle your system.
    1450. 

  1450. 

  1451. config.guess timestamp = $timestamp
    1452. 

  1452. 

  1453. uname -m = `(uname -m) 2>/dev/null || echo unknown`
    1454. 

  1454. uname -r = `(uname -r) 2>/dev/null || echo unknown`
    1455. 

  1455. uname -s = `(uname -s) 2>/dev/null || echo unknown`
    1456. 

  1456. uname -v = `(uname -v) 2>/dev/null || echo unknown`
    1457. 

  1457. 

  1458. /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
    1459. 

  1459. /bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
    1460. 

  1460. 

  1461. hostinfo               = `(hostinfo) 2>/dev/null`
    1462. 

  1462. /bin/universe          = `(/bin/universe) 2>/dev/null`
    1463. 

  1463. /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
    1464. 

  1464. /bin/arch              = `(/bin/arch) 2>/dev/null`
    1465. 

  1465. /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
    1466. 

  1466. /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
    1467. 

  1467. 

  1468. UNAME_MACHINE = ${UNAME_MACHINE}
    1469. 

  1469. UNAME_RELEASE = ${UNAME_RELEASE}
    1470. 

  1470. UNAME_SYSTEM  = ${UNAME_SYSTEM}
    1471. 

  1471. UNAME_VERSION = ${UNAME_VERSION}
    1472. 

  1472. EOF
    1473. 

  1473. 

  1474. exit 1
    1475. 

  1475. 

  1476. # Local variables:
    1477. 

  1477. # eval: (add-hook 'write-file-hooks 'time-stamp)
    1478. 

  1478. # time-stamp-start: "timestamp='"
    1479. 

  1479. # time-stamp-format: "%:y-%02m-%02d"
    1480. 

  1480. # time-stamp-end: "'"
    1481. 

  1481. # End:
    1482. 

  1482.