ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/Unix/config.guess
(Generate patch)

Comparing BasiliskII/src/Unix/config.guess (file contents):
Revision 1.1 by gbeauche, 2000-09-22T17:12:59Z vs.
Revision 1.2 by gbeauche, 2001-06-19T08:29:07Z

# 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-06-05'
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, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
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_targets=`cd /; ld --help 2>&1 \
887 >                         | sed -ne '/supported targets:/!d
888 >                                    s/[         ][      ]*/ /g
889 >                                    s/.*supported targets: *//
890 >                                    s/ .*//
891 >                                    p'`
892 >        case "$ld_supported_targets" in
893 >          elf32-i386)
894 >                TENTATIVE="${UNAME_MACHINE}-pc-linux-gnu"
895 >                ;;
896 >          a.out-i386-linux)
897 >                echo "${UNAME_MACHINE}-pc-linux-gnuaout"
898 >                exit 0 ;;              
899 >          coff-i386)
900 >                echo "${UNAME_MACHINE}-pc-linux-gnucoff"
901 >                exit 0 ;;
902 >          "")
903 >                # Either a pre-BFD a.out linker (linux-gnuoldld) or
904 >                # one that does not give us useful --help.
905 >                echo "${UNAME_MACHINE}-pc-linux-gnuoldld"
906 >                exit 0 ;;
907 >        esac
908 >        # Determine whether the default compiler is a.out or elf
909 >        cat >$dummy.c <<EOF
910   #include <features.h>
911   #ifdef __cplusplus
912 + #include <stdio.h>  /* for printf() prototype */
913          int main (int argc, char *argv[]) {
914   #else
915          int main (argc, argv) int argc; char *argv[]; {
# Line 767 | Line 917 | EOF
917   #ifdef __ELF__
918   # ifdef __GLIBC__
919   #  if __GLIBC__ >= 2
920 <    printf ("%s-${VENDOR}-linux-gnu\n", argv[1]);
920 >    printf ("%s-pc-linux-gnu\n", argv[1]);
921   #  else
922 <    printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]);
922 >    printf ("%s-pc-linux-gnulibc1\n", argv[1]);
923   #  endif
924   # else
925 <   printf ("%s-${VENDOR}-linux-gnulibc1\n", argv[1]);
925 >   printf ("%s-pc-linux-gnulibc1\n", argv[1]);
926   # endif
927   #else
928 <  printf ("%s-${VENDOR}-linux-gnuaout\n", argv[1]);
928 >  printf ("%s-pc-linux-gnuaout\n", argv[1]);
929   #endif
930    return 0;
931   }
932   EOF
933 <          $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm $dummy.c $dummy && exit 0
934 <          rm -f $dummy.c $dummy
935 <        fi ;;
933 >        $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy "${UNAME_MACHINE}" && rm -f $dummy.c $dummy && exit 0
934 >        rm -f $dummy.c $dummy
935 >        test x"${TENTATIVE}" != x && echo "${TENTATIVE}" && exit 0
936 >        ;;
937   # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.  earlier versions
938   # are messed up and put the nodename in both sysname and nodename.
939 <    i?86:DYNIX/ptx:4*:*)
939 >    i*86:DYNIX/ptx:4*:*)
940          echo i386-sequent-sysv4
941          exit 0 ;;
942 <    i?86:UNIX_SV:4.2MP:2.*)
942 >    i*86:UNIX_SV:4.2MP:2.*)
943          # Unixware is an offshoot of SVR4, but it has its own version
944          # number series starting with 2...
945          # I am not positive that other SVR4 systems won't match this,
# Line 796 | Line 947 | EOF
947          # Use sysv4.2uw... so that sysv4* matches it.
948          echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
949          exit 0 ;;
950 <    i?86:*:4.*:* | i?86:SYSTEM_V:4.*:*)
950 >    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
951 >        UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
952          if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
953 <                echo ${UNAME_MACHINE}-univel-sysv${UNAME_RELEASE}
953 >                echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
954          else
955 <                echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE}
955 >                echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
956          fi
957          exit 0 ;;
958 <    i?86:*:5:7*)
959 <        UNAME_REL=`(/bin/uname -X|egrep Release|sed -e 's/.*= //')`
960 <        (/bin/uname -X|egrep i80486 >/dev/null) && UNAME_MACHINE=i486
961 <        (/bin/uname -X|egrep '^Machine.*Pentium' >/dev/null) && UNAME_MACHINE=i586
962 <        (/bin/uname -X|egrep '^Machine.*Pent.*II' >/dev/null) && UNAME_MACHINE=i686
963 <        (/bin/uname -X|egrep '^Machine.*Pentium Pro' >/dev/null) && UNAME_MACHINE=i585
964 <        echo ${UNAME_MACHINE}-${UNAME_SYSTEM}${UNAME_VERSION}-sysv${UNAME_RELEASE}
958 >    i*86:*:5:7*)
959 >        # Fixed at (any) Pentium or better
960 >        UNAME_MACHINE=i586
961 >        if [ ${UNAME_SYSTEM} = "UnixWare" ] ; then
962 >            echo ${UNAME_MACHINE}-sco-sysv${UNAME_RELEASE}uw${UNAME_VERSION}
963 >        else
964 >            echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE}
965 >        fi
966          exit 0 ;;
967 <    i?86:*:3.2:*)
967 >    i*86:*:3.2:*)
968          if test -f /usr/options/cb.name; then
969                  UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
970                  echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
# Line 829 | Line 982 | EOF
982                  echo ${UNAME_MACHINE}-pc-sysv32
983          fi
984          exit 0 ;;
985 +    i*86:*DOS:*:*)
986 +        echo ${UNAME_MACHINE}-pc-msdosdjgpp
987 +        exit 0 ;;
988      pc:*:*:*)
989 +        # Left here for compatibility:
990          # uname -m prints for DJGPP always 'pc', but it prints nothing about
991          # the processor, so we play safe by assuming i386.
992          echo i386-pc-msdosdjgpp
# Line 853 | Line 1010 | EOF
1010          exit 0 ;;
1011      M68*:*:R3V[567]*:*)
1012          test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
1013 <    3[34]??:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 4850:*:4.0:3.0)
1013 >    3[34]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 4850:*:4.0:3.0)
1014          OS_REL=''
1015          test -r /etc/.relid \
1016          && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
# Line 864 | Line 1021 | EOF
1021      3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
1022          /bin/uname -p 2>/dev/null | grep 86 >/dev/null \
1023            && echo i486-ncr-sysv4 && exit 0 ;;
1024 <    m68*:LynxOS:2.*:*)
1024 >    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
1025          echo m68k-unknown-lynxos${UNAME_RELEASE}
1026          exit 0 ;;
1027      mc68030:UNIX_System_V:4.*:*)
1028          echo m68k-atari-sysv4
1029          exit 0 ;;
1030 <    i?86:LynxOS:2.*:* | i?86:LynxOS:3.[01]*:*)
1030 >    i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.0*:*)
1031          echo i386-unknown-lynxos${UNAME_RELEASE}
1032          exit 0 ;;
1033      TSUNAMI:LynxOS:2.*:*)
1034          echo sparc-unknown-lynxos${UNAME_RELEASE}
1035          exit 0 ;;
1036 <    rs6000:LynxOS:2.*:* | PowerPC:LynxOS:2.*:*)
1036 >    rs6000:LynxOS:2.*:*)
1037          echo rs6000-unknown-lynxos${UNAME_RELEASE}
1038          exit 0 ;;
1039 +    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.0*:*)
1040 +        echo powerpc-unknown-lynxos${UNAME_RELEASE}
1041 +        exit 0 ;;
1042      SM[BE]S:UNIX_SV:*:*)
1043          echo mips-dde-sysv${UNAME_RELEASE}
1044          exit 0 ;;
# Line 912 | Line 1072 | EOF
1072      mc68*:A/UX:*:*)
1073          echo m68k-apple-aux${UNAME_RELEASE}
1074          exit 0 ;;
1075 <    news*:NEWS-OS:*:6*)
1075 >    news*:NEWS-OS:6*:*)
1076          echo mips-sony-newsos6
1077          exit 0 ;;
1078      R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
# Line 943 | Line 1103 | EOF
1103      *:Rhapsody:*:*)
1104          echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
1105          exit 0 ;;
1106 +    *:Darwin:*:*)
1107 +        echo `uname -p`-apple-darwin${UNAME_RELEASE}
1108 +        exit 0 ;;
1109 +    *:procnto*:*:* | *:QNX:[0123456789]*:*)
1110 +        if test "${UNAME_MACHINE}" = "x86pc"; then
1111 +                UNAME_MACHINE=pc
1112 +        fi
1113 +        echo `uname -p`-${UNAME_MACHINE}-nto-qnx
1114 +        exit 0 ;;
1115 +    *:QNX:*:4*)
1116 +        echo i386-pc-qnx
1117 +        exit 0 ;;
1118 +    NSR-[KW]:NONSTOP_KERNEL:*:*)
1119 +        echo nsr-tandem-nsk${UNAME_RELEASE}
1120 +        exit 0 ;;
1121 +    *:NonStop-UX:*:*)
1122 +        echo mips-compaq-nonstopux
1123 +        exit 0 ;;
1124 +    BS2000:POSIX*:*:*)
1125 +        echo bs2000-siemens-sysv
1126 +        exit 0 ;;
1127 +    DS/*:UNIX_System_V:*:*)
1128 +        echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
1129 +        exit 0 ;;
1130 +    *:Plan9:*:*)
1131 +        # "uname -m" is not consistent, so use $cputype instead. 386
1132 +        # is converted to i386 for consistency with other x86
1133 +        # operating systems.
1134 +        if test "$cputype" = "386"; then
1135 +            UNAME_MACHINE=i386
1136 +        else
1137 +            UNAME_MACHINE="$cputype"
1138 +        fi
1139 +        echo ${UNAME_MACHINE}-unknown-plan9
1140 +        exit 0 ;;
1141 +    i*86:OS/2:*:*)
1142 +        # If we were able to find `uname', then EMX Unix compatibility
1143 +        # is probably installed.
1144 +        echo ${UNAME_MACHINE}-pc-os2-emx
1145 +        exit 0 ;;
1146 +    *:TOPS-10:*:*)
1147 +        echo pdp10-unknown-tops10
1148 +        exit 0 ;;
1149 +    *:TENEX:*:*)
1150 +        echo pdp10-unknown-tenex
1151 +        exit 0 ;;
1152 +    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
1153 +        echo pdp10-dec-tops20
1154 +        exit 0 ;;
1155 +    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
1156 +        echo pdp10-xkl-tops20
1157 +        exit 0 ;;
1158 +    *:TOPS-20:*:*)
1159 +        echo pdp10-unknown-tops20
1160 +        exit 0 ;;
1161 +    *:ITS:*:*)
1162 +        echo pdp10-unknown-its
1163 +        exit 0 ;;
1164   esac
1165  
1166   #echo '(No uname command or uname output not recognized.)' 1>&2
# Line 1034 | Line 1252 | main ()
1252   #endif
1253  
1254   #if defined (vax)
1255 < #if !defined (ultrix)
1256 <  printf ("vax-dec-bsd\n"); exit (0);
1257 < #else
1258 <  printf ("vax-dec-ultrix\n"); exit (0);
1259 < #endif
1255 > # if !defined (ultrix)
1256 > #  include <sys/param.h>
1257 > #  if defined (BSD)
1258 > #   if BSD == 43
1259 >      printf ("vax-dec-bsd4.3\n"); exit (0);
1260 > #   else
1261 > #    if BSD == 199006
1262 >      printf ("vax-dec-bsd4.3reno\n"); exit (0);
1263 > #    else
1264 >      printf ("vax-dec-bsd\n"); exit (0);
1265 > #    endif
1266 > #   endif
1267 > #  else
1268 >    printf ("vax-dec-bsd\n"); exit (0);
1269 > #  endif
1270 > # else
1271 >    printf ("vax-dec-ultrix\n"); exit (0);
1272 > # endif
1273   #endif
1274  
1275   #if defined (alliant) && defined (i860)
# Line 1049 | Line 1280 | main ()
1280   }
1281   EOF
1282  
1283 < $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy && rm $dummy.c $dummy && exit 0
1283 > $CC_FOR_BUILD $dummy.c -o $dummy 2>/dev/null && ./$dummy && rm -f $dummy.c $dummy && exit 0
1284   rm -f $dummy.c $dummy
1285  
1286   # Apollos put the system type in the environment.
# Line 1082 | Line 1313 | then
1313      esac
1314   fi
1315  
1316 < #echo '(Unable to guess system type)' 1>&2
1316 > cat >&2 <<EOF
1317 > $0: unable to guess system type
1318 >
1319 > This script, last modified $timestamp, has failed to recognize
1320 > the operating system you are using. It is advised that you
1321 > download the most up to date version of the config scripts from
1322 >
1323 >    ftp://ftp.gnu.org/pub/gnu/config/
1324 >
1325 > If the version you run ($0) is already up to date, please
1326 > send the following data and any information you think might be
1327 > pertinent to <config-patches@gnu.org> in order to provide the needed
1328 > information to handle your system.
1329 >
1330 > config.guess timestamp = $timestamp
1331 >
1332 > uname -m = `(uname -m) 2>/dev/null || echo unknown`
1333 > uname -r = `(uname -r) 2>/dev/null || echo unknown`
1334 > uname -s = `(uname -s) 2>/dev/null || echo unknown`
1335 > uname -v = `(uname -v) 2>/dev/null || echo unknown`
1336 >
1337 > /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
1338 > /bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
1339 >
1340 > hostinfo               = `(hostinfo) 2>/dev/null`
1341 > /bin/universe          = `(/bin/universe) 2>/dev/null`
1342 > /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
1343 > /bin/arch              = `(/bin/arch) 2>/dev/null`
1344 > /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
1345 > /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
1346 >
1347 > UNAME_MACHINE = ${UNAME_MACHINE}
1348 > UNAME_RELEASE = ${UNAME_RELEASE}
1349 > UNAME_SYSTEM  = ${UNAME_SYSTEM}
1350 > UNAME_VERSION = ${UNAME_VERSION}
1351 > EOF
1352  
1353   exit 1
1354 +
1355 + # Local variables:
1356 + # eval: (add-hook 'write-file-hooks 'time-stamp)
1357 + # time-stamp-start: "timestamp='"
1358 + # time-stamp-format: "%:y-%02m-%02d"
1359 + # time-stamp-end: "'"
1360 + # End:

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines