#! /bin/sh
# hosttype --- guess host type (cpu-vendor-os)

# Copyright (C) 1992-1998 Free Software Foundation, Inc.
# Copyright (C) 1991, 1994-1999 Noah S. Friedman

# Maintainer: Noah Friedman <friedman@splode.com>
# Created: 1993-03-08

# $Id: hosttype,v 1.41 1999/05/27 05:02:03 friedman Exp $

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, you can either send email to this
# program's maintainer or write to: The Free Software Foundation,
# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

# Commentary:

# Based mostly on GNU `config.guess' script, but with some variations.
# As of 1994-08-27, the canonical source is /gd/gnu/lib/config.guess
# on the gnu.org machines.

# Code:

# Use $HOST_CC if defined. $CC may point to a cross-compiler
if test x"$CC_FOR_BUILD" = x; then
  if test x"$HOST_CC" != x; then
    CC_FOR_BUILD="$HOST_CC"
  else
    if test x"$CC" != x; then
      CC_FOR_BUILD="$CC"
    else
      CC_FOR_BUILD=cc
    fi
  fi
fi

# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
# (ghazi@noc.rutgers.edu 1994-08-24)
if test -f /.attbin/uname ; then
  PATH=$PATH:/.attbin
  export PATH
fi

UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown

dummy=dummy$$
trap 'rm -f $dummy.c $dummy.o $dummy; exit 1' 1 2 15

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

case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
  alpha:OSF1:*:*)
    # A Vn.n version is a released version.
    # A Tn.n version is a released field test version.
    # A Xn.n version is an unreleased experimental baselevel.
    if test $UNAME_RELEASE = "V4.0"; then
      UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
    fi
    sed -e '/%%%/s/^[ 	]*%%%//' <<EOF >$dummy.s
	.globl main
	.ent main
	%%%main:
	.frame \$30,0,\$26,0
	.prologue 0
	.long 0x47e03d80 # implver $0
	lda \$2,259
	.long 0x47e20c21 # amask $2,$1
	srl \$1,8,\$2
	sll \$2,2,\$2
	sll \$0,3,\$0
	addl \$1,\$0,\$0
	addl \$2,\$0,\$0
	ret \$31,(\$26),1
	.end main
EOF
	$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
	if test "$?" = 0 ; then
	  ./$dummy
          result=$?
          case "$result" in
             7) UNAME_MACHINE="alpha"      ;;
            10) UNAME_MACHINE="alphapca56" ;;
            14) UNAME_MACHINE="alphaev56"  ;;
            15) UNAME_MACHINE="alphaev5"   ;;
            16) UNAME_MACHINE="alphaev6"   ;;
          esac
	fi
	rm -f $dummy.s $dummy
	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} \
         | sed -e 's/^[VTX]//' \
               -e 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'`
	exit 0 ;;
  Alpha\ *:Windows_NT*:*)
    # How do we know it's Interix rather than the generic POSIX subsystem?
    # Should we change UNAME_MACHINE based on the output of uname instead
    # of the specific Alpha model?
    echo alpha-pc-interix
    exit 0 ;;
  21064:Windows_NT:50:3)
    echo alpha-dec-winnt3.5
    exit 0 ;;
  Amiga*:UNIX_System_V:4.0:*)
    echo m68k-cbm-sysv4
    exit 0;;
  amiga:NetBSD:*:*)
    echo m68k-cbm-netbsd${UNAME_RELEASE}
    exit 0 ;;
  amiga:OpenBSD:*:*)
    echo m68k-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  *:[Aa]miga[Oo][Ss]:*:*)
    echo ${UNAME_MACHINE}-unknown-amigaos
    exit 0 ;;
  arc64:OpenBSD:*:*)
    echo mips64el-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  arc:OpenBSD:*:*)
    echo mipsel-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  hkmips:OpenBSD:*:*)
    echo mips-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  pmax:OpenBSD:*:*)
    echo mipsel-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  sgi:OpenBSD:*:*)
    echo mips-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  wgrisc:OpenBSD:*:*)
    echo mipsel-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
    echo arm-acorn-riscix$UNAME_RELEASE
    exit 0 ;;
  arm32:NetBSD:*:*)
    echo arm-unknown-netbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
    exit 0 ;;
  SR2?01:HI-UX/MPP:*:*)
    echo hppa1.1-hitachi-hiuxmpp
    exit 0 ;;
  Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
    # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
    if test "`(/bin/universe) 2>/dev/null`" = att ; then
      echo pyramid-pyramid-sysv3
    else
      echo pyramid-pyramid-bsd
    fi
    exit 0 ;;
  NILE*:*:*:dcosx)
    echo pyramid-pyramid-svr4
    exit 0 ;;
  sun4H:SunOS:5.*:*)
    echo sparc-hal-solaris2`echo $UNAME_RELEASE | sed -e 's/[^.]*//'`
    exit 0 ;;
  sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
    echo sparc-sun-solaris2`echo $UNAME_RELEASE | sed -e 's/[^.]*//'`
    exit 0 ;;
  i86pc:SunOS:5.*:*)
    echo i386-pc-solaris2`echo $UNAME_RELEASE | sed -e 's/[^.]*//'`
    exit 0 ;;
  sun4*:SunOS:6*:*)
    # According to config.sub, this is the proper way to canonicalize
    # SunOS6.  Hard to guess exactly what SunOS6 will be like, but
    # it's likely to be more like Solaris than SunOS4.
    echo sparc-sun-solaris3`echo $UNAME_RELEASE | sed -e 's/[^.]*//'`
    exit 0 ;;
  sun4*:SunOS:*:*)
    case "`/usr/bin/arch -k`" in
      Series*|S4*) UNAME_RELEASE=`uname -v` ;;
    esac
    # Japanese Language versions have a version number like `4.1.3-JL'.
    echo sparc-sun-sunos`echo $UNAME_RELEASE | sed -e 's/-/_/'`
    exit 0 ;;
  sun3*:SunOS:*:*)
    echo m68k-sun-sunos$UNAME_RELEASE
    exit 0 ;;
  aushp:SunOS:*:*)
    echo sparc-auspex-sunos${UNAME_RELEASE}
    exit 0 ;;
  atari*:NetBSD:*:*)
    echo m68k-atari-netbsd${UNAME_RELEASE}
    exit 0 ;;
  atari*:OpenBSD:*:*)
    echo m68k-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  # The situation for MiNT is a little confusing.  The machine name
  # can be virtually everything (everything which is not
  # "atarist" or "atariste" at least should have a processor
  # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
  # to the lowercase version "mint" (or "freemint").  Finally
  # the system name "TOS" denotes a system which is actually not
  # MiNT.  But MiNT is downward compatible to TOS, so this should
  # be no problem.
  atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
    echo m68k-atari-mint${UNAME_RELEASE}
    exit 0 ;;
  atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
    echo m68k-atari-mint${UNAME_RELEASE}
    exit 0 ;;
  *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
    echo m68k-atari-mint${UNAME_RELEASE}
    exit 0 ;;
  milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
    echo m68k-milan-mint${UNAME_RELEASE}
    exit 0 ;;
  hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
    echo m68k-hades-mint${UNAME_RELEASE}
    exit 0 ;;
  *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
    echo m68k-unknown-mint${UNAME_RELEASE}
    exit 0 ;;
  sun3*:NetBSD:*:*)
    echo m68k-sun-netbsd${UNAME_RELEASE}
    exit 0 ;;
  sun3*:OpenBSD:*:*)
    echo m68k-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  mac68k:NetBSD:*:*)
    echo m68k-apple-netbsd${UNAME_RELEASE}
    exit 0 ;;
  mac68k:OpenBSD:*:*)
    echo m68k-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  mvme68k:OpenBSD:*:*)
    echo m68k-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  mvme88k:OpenBSD:*:*)
    echo m88k-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  powerpc:machten:*:*)
    echo powerpc-apple-machten${UNAME_RELEASE}
    exit 0 ;;
  macppc:NetBSD:*:*)
    echo powerpc-apple-netbsd${UNAME_RELEASE}
    exit 0 ;;
  RISC*:Mach:*:*)
    echo mips-dec-mach_bsd4.3
    exit 0 ;;
  RISC*:ULTRIX:*:*)
    echo mips-dec-ultrix$UNAME_RELEASE
    exit 0 ;;
  VAX*:ULTRIX*:*:*)
    echo vax-dec-ultrix$UNAME_RELEASE
    exit 0 ;;
  2020:CLIX:*:* | 2430:CLIX:*:*)
    echo clipper-intergraph-clix${UNAME_RELEASE}
    exit 0 ;;
  mips:*:*:UMIPS | mips:*:*:RISCos)
    f=$dummy
    trap 'rm -f $f.c $f.o $f; exit 1' 1 2 15
    sed -e 's/^[ 	]*//g' > "$f.c" <<EOF
      #ifdef __cplusplus
      int main (int argc, char *argv[]) {
      #else
      int main (argc, argv) int argc; char *argv[]; {
      #endif
      #if defined (host_mips) && defined (MIPSEB)
      #if defined (SYSTYPE_SYSV)
        printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
      #endif
      #if defined (SYSTYPE_SVR4)
        printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
      #endif
      #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
        printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
      #endif
      #endif
        exit (-1);
      }
EOF
    $CC_FOR_BUILD $f.c -o $f 2> /dev/null \
      && ./$f `echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` \
      && rm -f $f.c $f \
      && exit 0
    rm -f $f.c $f

    echo mips-mips-riscos{UNAME_RELEASE}
    exit 0 ;;
  Night_Hawk:Power_UNIX:*:*)
    echo powerpc-harris-powerunix
    exit 0 ;;
  m88k:CX/UX:7*:*)
    echo m88k-harris-cxux7
    exit 0 ;;
  m88k:*:4*:R4*)
    echo m88k-motorola-sysv4
    exit 0 ;;
  m88k:*:3*:R3*)
    echo m88k-motorola-sysv3
    exit 0 ;;
  AViiON:dgux:*:*)
    # DG/UX returns AViiON for all architectures
    UNAME_PROCESSOR=`uname -p`
    if [ $UNAME_PROCESSOR = mc88100 -o $UNAME_PROCESSOR = mc88110 ] ; then
      if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] \
      || [ ${TARGET_BINARY_INTERFACE}x = x ]
      then
        echo m88k-dg-dgux${UNAME_RELEASE}
      else
        echo m88k-dg-dguxbcs${UNAME_RELEASE}
      fi
    else
      echo i586-dg-dgux${UNAME_RELEASE}
    fi
    exit 0 ;;
  M88*:DolphinOS:*:*) # DolphinOS (SVR3)
    echo m88k-dolphin-sysv3
    exit 0 ;;
  M88*:*:R3*:*)
    # Delta 88k system running SVR3
    echo m88k-motorola-sysv3
    exit 0 ;;
  D88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
    echo m88k-tektronix-sysv3
    exit 0 ;;
  Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
    echo m68k-tektronix-bsd
    exit 0 ;;
  *:IRIX:*:*)
    echo mips-sgi-irix`echo $UNAME_RELEASE | sed -e 's/-/_/g'`
    exit 0 ;;
  # AIX 2.2.1 or 2.1.1 is RT/PC AIX.  uname -m gives an 8 hex-code CPU id.
  # Note that "uname -s" prints a trailing space, i.e. "AIX "
  ????????:AIX?:[12].1:2)
    echo romp-ibm-aix
    exit 0 ;;
  i?86:AIX:*:*)
    echo i386-ibm-aix
    exit 0 ;;
  *:AIX:2:3)
    if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
      f=$dummy
      trap 'rm -f $f.c $f.o $f; exit 1' 1 2 15
      sed -e 's/^[ 	]*//g' > $f.c <<EOF
        #include <sys/systemcfg.h>
        main () {
          if (! __power_pc ()) exit (1);
          puts ("powerpc-ibm-aix3.2.5");
          exit (0);
        }
EOF
      $CC_FOR_BUILD $f.c -o $f 2> /dev/null && ./$f && rm -f $f.c $f && exit 0
      rm -f $f.c $f
      trap '' 1 2 15
      echo rs6000-ibm-aix3.2.5
    elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
      echo rs6000-ibm-aix3.2.4
    else
      echo rs6000-ibm-aix3.2
    fi
    exit 0 ;;
  *:AIX:*:4)
    IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | head -1 | awk '{ print $1 }'`
    if /usr/sbin/lsattr -EHl $IBM_CPU_ID | grep POWER >/dev/null 2>&1; then
      IBM_ARCH=rs6000
    else
      IBM_ARCH=powerpc
    fi
    if test -x /usr/bin/oslevel ; then
      IBM_REV=`/usr/bin/oslevel`
    else
      IBM_REV=4.${UNAME_RELEASE}
    fi
    echo ${IBM_ARCH}-ibm-aix${IBM_REV}
    exit 0 ;;
  *:AIX:*:*)
    echo rs6000-ibm-aix
    exit 0 ;;
  ibmrt:4.4BSD:*|romp-ibm:BSD:*)
    echo romp-ibm-bsd4.4
    exit 0 ;;
  # Covers RT/PC NetBSD and 4.3 with uname added to report: romp-ibm BSD 4.3
  ibmrt:*BSD:*|romp-ibm:BSD:*)
    echo romp-ibm-bsd${UNAME_RELEASE}
    exit 0 ;;
  *:BOSX:*:*)
    echo rs6000-bull-bosx
    exit 0 ;;
  DPX/2?00:B.O.S.:*:*)
    echo m68k-bull-sysv3
    exit 0 ;;
  9000/[34]??:4.3bsd:1.*:*)
    echo m68k-hp-bsd
    exit 0 ;;
  hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
    echo m68k-hp-bsd4.4
    exit 0 ;;
  9000/[34678]??:HP-UX:*:*)
    # See /opt/langtools/lib/sched.models in HP-UX 10.20 or 11.0 for a list
    # of models and processor types.  The 700 and 800 series are a
    # bewildering mess.
    model=`echo "$UNAME_MACHINE" | sed 's=9000/=='`
    case "$model" in
      31? )                     HP_ARCH=m68000  ;;
      [34]?? )                  HP_ARCH=m68k    ;;
      [68]?? )                  HP_ARCH=hppa1.0 ;;
      [78]00 | 78? )            HP_ARCH=hppa2.0 ;;
      7[0-7]? )                 HP_ARCH=hppa1.1 ;;
      808 | 834 )               HP_ARCH=hppa1.0 ;;
      8[4-79]0 )                HP_ARCH=hppa1.0 ;;
      8[2-5]2 )                 HP_ARCH=hppa1.0 ;;
      8[1-6]5 )                 HP_ARCH=hppa1.0 ;;
      892 )                     HP_ARCH=hppa1.1 ;;
      8[0-59]1 )                HP_ARCH=hppa1.1 ;;
      8[01]3 )                  HP_ARCH=hppa1.1 ;;
      8[0125]6 )                HP_ARCH=hppa1.1 ;;
      8?7 )                     HP_ARCH=hppa1.1 ;;
      8[0-6]9 )                 HP_ARCH=hppa1.1 ;;
      8[012]0 )                 HP_ARCH=hppa2.0 ;;
      8[67]1 )                  HP_ARCH=hppa2.0 ;;
      80[24] )                  HP_ARCH=hppa2.0 ;;
      8[789]9 )                 HP_ARCH=hppa2.0 ;;
      89[3568] )                HP_ARCH=hppa2.0 ;;
      * )                       HP_ARCH=hpunknown ;;
    esac
    HPUX_REV=`echo $UNAME_RELEASE | sed -e 's/[^.]*.[0B]*//' -e 's/\..*//'`
    echo ${HP_ARCH}-hp-hpux${HPUX_REV}
    exit 0 ;;
  9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
    echo hppa1.1-hp-bsd
    exit 0 ;;
  9000/8??:4.3bsd:*:*)
    echo hppa1.0-hp-bsd
    exit 0 ;;
  *9??*:MPE/iX:*:*)
    echo hppa1.0-hp-mpeix
    exit 0 ;;
  hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
    echo hppa1.1-hp-osf
    exit 0 ;;
  hp8??:OSF1:*:*)
    echo hppa1.0-hp-osf
    exit 0 ;;
  i?86:OSF1:*:*)
    if [ -x /usr/sbin/sysversion ] ; then
      echo ${UNAME_MACHINE}-unknown-osf1mk
    else
      echo ${UNAME_MACHINE}-unknown-osf1
    fi
    exit 0 ;;
  F301:UNIX_System_V:*:*)
    echo f301-fujitsu-uxpv`echo $UNAME_RELEASE | sed 's/ .*//'`
    exit 0 ;;
  hp3[0-9][05]:NetBSD:*:*)
    echo m68k-hp-netbsd${UNAME_RELEASE}
    exit 0 ;;
  3050*:HI-UX:*:*)
    f=$dummy
    trap 'rm -f $f.c $f.o $f; exit 1' 1 2 15
    sed 's/^[ 	]*//' > $f.c <<EOF
      #include <unistd.h>
      main ()
      {
        long cpu = sysconf (_SC_CPU_VERSION);
        /* The order matters, because CPU_IS_HP_MC68K erroneously
         * returns true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns
         * correct results, however.
         */
        if (CPU_IS_PA_RISC (cpu))
          {
            switch (cpu)
              {
              case CPU_PA_RISC1_0:
                puts ("hppa1.0-hitachi-hiuxwe2"); break;
              case CPU_PA_RISC1_1:
                puts ("hppa1.1-hitachi-hiuxwe2"); break;
              case CPU_PA_RISC2_0:
                puts ("hppa2.0-hitachi-hiuxwe2"); break;
              default:
                puts ("hppa-hitachi-hiuxwe2"); break;
              }
          }
        else
          {
            if (CPU_IS_HP_MC68K (cpu))
              puts ("m68k-hitachi-hiuxwe2");
            else
              puts ("unknown-hitachi-hiuxwe2");
          }
        exit (0);
      }
EOF
    $CC_FOR_BUILD $f.c -o $f 2> /dev/null && ./$f && rm -f $f.c $f && exit 0
    rm -f $f.c $f
    trap '' 1 2 15
    echo unknown-hitachi-hiuxwe2
    exit 0 ;;
  parisc*:Lites*:*:*)
    echo hppa1.1-hp-lites
    exit 0 ;;
  hppa*:OpenBSD:*:*)
    echo hppa-unknown-openbsd
    exit 0 ;;
  C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
    echo c1-convex-bsd
    exit 0 ;;
  C2*:ConvexOS:*:* | convex:ConvexOS:C2:*)
    echo c2-convex-bsd
    exit 0 ;;
  CRAY*X-MP:*:*:*)
    echo xmp-cray-unicos
    exit 0 ;;
  CRAY*Y-MP:*:*:*)
    echo ymp-cray-unicos${UNAME_RELEASE}
    exit 0 ;;
  CRAY*[A-Z]90:*:*:*)
    echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
      | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
            -e 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/'
    exit 0 ;;
  CRAY*TS:*:*:*)
    echo t90-cray-unicos${UNAME_RELEASE}
    exit 0 ;;
  CRAY*T3E:*:*:*)
    echo t3e-cray-unicosmk${UNAME_RELEASE}
    exit 0 ;;
  CRAY-2:*:*:*)
    echo cray2-cray-unicos
    exit 0 ;;
  F300:UNIX_System_V:*:*)
    FUJITSU_SYS=`uname -p \
      | sed -e 'y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/' \
            -e 's/\///'`
    FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
    echo "f300-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
    exit 0 ;;
  i?86:Lites*:*:*)
    echo ${UNAME_MACHINE}-unknown-lites
    exit 0 ;;
  hp300:OpenBSD:*:*)
    echo m68k-unknown-openbsd${UNAME_RELEASE}
    exit 0 ;;
  i?86:BSD/386:*:* | i?86:BSD/OS:*:*)
    echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
    exit 0 ;;
  sparc*:BSD/OS:*:*)
    echo sparc-unknown-bsdi${UNAME_RELEASE}
    exit 0 ;;
  *:BSD/OS:*:*)
    echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
    exit 0 ;;
  *:FreeBSD:*:*)
    ver=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*//'`
    if test -x /usr/bin/objformat; then
      if test "elf" = "`/usr/bin/objformat`"; then
        echo ${UNAME_MACHINE}-unknown-freebsdelf$ver
        exit 0
      fi
    fi
    echo ${UNAME_MACHINE}-unknown-freebsd$ver
    exit 0 ;;
  *:NetBSD:*:*)
    ver=`echo $UNAME_RELEASE | sed -e 's/[-_].*/\./'`
    echo ${UNAME_MACHINE}-unknown-netbsd$ver
    exit 0 ;;
  *:OpenBSD:*:*)
    ver=`echo $UNAME_RELEASE | sed -e 's/[-_].*/\./'`
    echo ${UNAME_MACHINE}-unknown-openbsd$ver
    exit 0 ;;
  i*:CYGWIN*:*)
    echo i386-pc-cygwin32
    exit 0 ;;
  p*:CYGWIN*:*)
    echo powerpcle-unknown-cygwin32
    exit 0 ;;
  i*:MINGW*:*)
    echo i386-pc-mingw32
    exit 0 ;;
  i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
    # How do we know it's Interix rather than the generic POSIX subsystem?
    # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
    # UNAME_MACHINE based on the output of uname instead of i386?
    echo i386-pc-interix
    exit 0 ;;
  i*:UWIN*:*)
    echo ${UNAME_MACHINE}-pc-uwin
    exit 0 ;;
  prep*:SunOS:5.*:*)
    echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
    exit 0 ;;
  *:GNU:*:*)
    machine=`echo $UNAME_MACHINE | sed -e 's,/[-/].*$,,'`
    release=`echo $UNAME_RELEASE | sed -e 's,/-.*$,,'`
    echo ${machine}-unknown-gnu$release
    exit 0 ;;
  *:Linux:*:*)
    # Canonicalize.
    case "$UNAME_MACHINE" in
      armv*)          : ;;
      arm* | sa110* ) UNAME_MACHINE="arm"  ;;
      i?86 )          UNAME_MACHINE="ix86" ;;
    esac

    VENDOR=unknown
    case "$UNAME_MACHINE" in
      i?86) VENDOR=pc ;;
    esac

    OS=gnu
    if [ -f /etc/redhat-release ]; then
      rhver=`sed -e 's/Red Hat Linux release //' \
                 -e 's/ (.*//' \
                 -e 's/\.//g' \
                 -e 's/0$//g' \
                 -e q /etc/redhat-release`
      OS="redhat$rhver"
    fi

    # The BFD linker knows what the default object file format is, so
    # first see if it will tell us.
    ld_help_string=`ld --help 2>&1 \
                     | sed -ne '/supported emulations:/!d
                                s/[ 	][ 	]*/ /g
                                s/.*supported emulations: *//
                                s/ .*//
                                p'`
    case "$ld_help_string" in
      # If you want to distinguish between libc1 and libc2, comment out
      # these next two switches and let the compilations checks run below.
      elf_i?86 )   echo "${UNAME_MACHINE}-${VENDOR}-linux-$OS"       ; exit 0;;
      m68kelf )    echo "${UNAME_MACHINE}-${VENDOR}-linux-$OS"       ; exit 0;;

      i?86linux )  echo "${UNAME_MACHINE}-${VENDOR}-linux-${OS}aout" ; exit 0;;
      i?86coff )   echo "${UNAME_MACHINE}-${VENDOR}-linux-${OS}coff" ; exit 0;;
      sparclinux ) echo "${UNAME_MACHINE}-${VENDOR}-linux-${OS}aout" ; exit 0;;
      armlinux )   echo "${UNAME_MACHINE}-${VENDOR}-linux-${OS}aout" ; exit 0;;
      m68klinux )  echo "${UNAME_MACHINE}-${VENDOR}-linux-${OS}aout" ; exit 0;;
      elf32ppc )   echo "powerpc-${VENDOR}-linux-$OS"                ; exit 0;;
      '')          echo "${UNAME_MACHINE}-${VENDOR}-linux-${OS}oldld"; exit 0;;
    esac

    case "$UNAME_MACHINE" in
      alpha )
        sed -e 's/^[ 	]*/	/;s/^.*%%%//;' <<EOF >$dummy.s
          .globl main
          .ent main
        %%%main:
          .frame \$30,0,\$26,0
          .prologue 0
          .long 0x47e03d80 # implver $0
          lda \$2,259
          .long 0x47e20c21 # amask $2,$1
          srl \$1,8,\$2
          sll \$2,2,\$2
          sll \$0,3,\$0
          addl \$1,\$0,\$0
          addl \$2,\$0,\$0
          ret \$31,(\$26),1
          .end main
EOF
        LIBC=""
	$CC_FOR_BUILD $dummy.s -o $dummy 2>/dev/null
	if test "$?" = 0 ; then
	  ./$dummy
          result=$?
          case "$result" in
             7) UNAME_MACHINE="alpha"      ;;
            10) UNAME_MACHINE="alphapca56" ;;
            14) UNAME_MACHINE="alphaev56"  ;;
            15) UNAME_MACHINE="alphaev5"   ;;
            16) UNAME_MACHINE="alphaev6"   ;;
          esac

          objdump --private-headers $dummy | grep ld.so.1 > /dev/null
          if test "$?" = 0 ; then
            LIBC="libc1"
          fi
        fi
        rm -f $dummy.s $dummy
        echo ${UNAME_MACHINE}-${VENDOR}-linux-${OS}${LIBC}
        exit 0 ;;
      mips )
        # Determine whether the default compiler is a.out or elf
        f=$dummy
        trap 'rm -f $f.c $f.o $f; exit 1' 1 2 15
        sed 's/^[ 	]*//g' > $f.c <<EOF
          int main ()
          {
          #ifdef __MIPSEB__
            puts ("${UNAME_MACHINE}-${VENDOR}-linux-${OS}");
          #endif
          #ifdef __MIPSEL__
            puts ("${UNAME_MACHINE}sel-${VENDOR}-linux-${OS}");
          #endif
            return 0;
          }
EOF
        $CC_FOR_BUILD $f.c -o $f 2> /dev/null && ./$f && rm -f $f.c $f && exit 0
        rm -f $f.c $f
        trap '' 1 2 15
       ;;
    esac

    # Determine if code generation is for a.out or elf, and using which libc.
    f=$dummy
    trap 'rm -f $f.c $f.o $f; exit 1' 1 2 15
    sed 's/^[ 	]*//g' > $f.c <<EOF
      main ()
      {
      #include <features.h>
      #ifdef __ELF__
      #  ifdef __GLIBC__
      #    if __GLIBC__ >= 2
             puts ("${UNAME_MACHINE}-${VENDOR}-linux-${OS}");
      #    else
             puts ("${UNAME_MACHINE}-${VENDOR}-linux-${OS}libc1");
      #    endif
      #  else
           puts ("${UNAME_MACHINE}-${VENDOR}-linux-${OS}libc1");
      #  endif
      #else
        puts ("${UNAME_MACHINE}-${VENDOR}-linux-${OS}aout");
      #endif
        return 0;
      }
EOF
    $CC_FOR_BUILD $f.c -o $f 2> /dev/null && ./$f && rm -f $f.c $f && exit 0
    rm -f $f.c $f
    trap '' 1 2 15
   ;;
  # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.  earlier
  # versions are messed up and put the nodename in both sysname and nodename.
  i?86:DYNIX/ptx:4*:*)
      echo ${UNAME_MACHINE}-sequent-sysv4
      exit 0 ;;
  i?86:UNIX_SV:4.2MP:2.*)
      # Unixware is an offshoot of SVR4, but it has its own version
      # number series starting with 2...
      # Use sysv4.2uw... so that sysv4* matches it.
      echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
      exit 0 ;;
  i?86:*:4.*:* | i?86:SYSTEM_V:4.*:*)
      if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
        echo $UNAME_MACHINE-univel-sysv$UNAME_RELEASE
      else
        echo $UNAME_MACHINE-pc-sysv$UNAME_RELEASE
      fi
      exit 0 ;;
  # SysVr5/Unixware7
  i?86:*:5*:* | i?86:SYSTEM_V:5*:*)
    if uname -a | grep SCO >/dev/null 2>&1 ; then
      (uname -s|egrep UnixWare >/dev/null) && UNAME_VER=uw${UNAME_VERSION}
      if uname -X 2>/dev/null >/dev/null ; then
        (uname -X|egrep i80486 >/dev/null) && UNAME_MACHINE=i486
        (uname -X|egrep '^Machine.*Pentium' >/dev/null) && UNAME_MACHINE=i586
      fi
      echo ${UNAME_MACHINE}-sco-sysv${UNAME_RELEASE}-${UNAME_VER}
    else
      echo ${UNAME_MACHINE}-pc-sysv${UNAME_RELEASE}
    fi
    exit 0 ;;
  i?86:*:5:7*)
    UNAME_REL=`(uname -X|egrep Release|sed -e 's/.*= //')`
    UNAME_MACHINE=`uname -X | sed -ne '
        /^Machine.*Pentium Pro/{s/.*/i686/p;q;}
        /^Machine.*Pent.*II/{s/.*/i686/p;q;}
        /^Machine.*Pentium/{s/.*/i586/p;q;}
        /i80486/{s/.*/i486/p;q;}'`
    echo ${UNAME_MACHINE}-${UNAME_SYSTEM}${UNAME_VERSION}-sysv${UNAME_REL}
    exit 0 ;;
  i?86:*:3.2:*)
    if test -f /usr/options/cb.name; then
      UNAME_REL=`sed -ne 's/.*Version //p' </usr/options/cb.name`
      echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
    elif uname -X 2>/dev/null >/dev/null ; then
      UNAME_REL=`(uname -X|egrep Release|sed -e 's/.*= //')`
      UNAME_MACHINE=`uname -X | sed -ne '
          /^Machine.*Pentium Pro/{s/.*/i686/p;q;}
          /^Machine.*Pent.*II/{s/.*/i686/p;q;}
          /^Machine.*Pentium/{s/.*/i586/p;q;}
          /i80486/{s/.*/i486/p;q;}'`
      echo $UNAME_MACHINE-pc-sco$UNAME_REL
    else
      echo $UNAME_MACHINE-pc-sysv3.2
    fi
    exit 0 ;;
  paragon:*:*:*)
        echo i860-intel-osf1
        exit 0 ;;
  pc:*:*:*)
        # uname -m prints for DJGPP always 'pc', but it prints nothing about
        # the processor, so we play safe by assuming i386.
	echo i386-pc-msdosdjgpp
        exit 0 ;;
  Intel:Mach:3*:*)
        echo i386-pc-mach3
        exit 0 ;;
  i860:*:4.*:*) # i860-SVR4
        if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
          echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
        else # Add other i860-SVR4 vendors below as they are discovered.
          echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
        fi
        exit 0 ;;
  mini*:CTIX:SYS*5:*)
        # "miniframe"
        echo m68010-convergent-sysv
        exit 0 ;;
  [Mm]68*:*:R3V[567]*:* )
        test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;;
  3[34]??:*:4.0:3.0 | 3[34]??[,/]*:*:4.0:3.0 | 4850:*:4.0:3.0)
	OS_REL=
	if test -r /etc/.relid ; then
	  OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
        fi
	uname -p 2>/dev/null | grep 86 >/dev/null \
	  && echo i486-ncr-sysv4.3${OS_REL} && exit 0
	uname -p 2>/dev/null | grep entium >/dev/null \
	  && echo i586-ncr-sysv4.3${OS_REL} && exit 0 ;;
  3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
        uname -p 2>/dev/null | grep 86 >/dev/null \
          && echo i486-ncr-sysv4 && exit 0 ;;
  m68*:LynxOS:2.*:*)
	echo m68k-unknown-lynxos${UNAME_RELEASE}
        exit 0 ;;
  mc68030:UNIX_System_V:4.*:*)
        echo m68k-atari-sysv4
        exit 0 ;;
  i?86:LynxOS:2.*:* | i?86:LynxOS:3.[01]*:*)
	echo ${UNAME_MACHINE}-unknown-lynxos${UNAME_RELEASE}
        exit 0 ;;
  TSUNAMI:LynxOS:2.*:*)
        echo sparc-unknown-lynxos$UNAME_RELEASE
        exit 0 ;;
  rs6000:LynxOS:2.*:* | PowerPC:LynxOS:2.*:*)
	echo rs6000-unknown-lynxos${UNAME_RELEASE}
        exit 0 ;;
  SM[BE]S:UNIX_SV:*:*)
	echo mips-dde-sysv${UNAME_RELEASE}
	exit 0 ;;
  RM*:ReliantUNIX-*:*:*)
    echo mips-sni-sysv4
    exit 0 ;;
  RM*:SINIX-*:*:*)
    echo mips-sni-sysv4
    exit 0 ;;
  *:SINIX-*:*:*)
    if uname -p >/dev/null 2>&1; then
      UNAME_MACHINE=`(uname -p) 2>/dev/null`
      echo ${UNAME_MACHINE}-sni-sysv4
    else
      echo ns32k-sni-sysv
    fi
    exit 0 ;;
  *:UNIX_System_V:4*:FTX*)
	# From Gerald Hewes <hewes@openmarket.com>.
	# How about differentiating between stratus architectures? -djm
	echo hppa1.1-stratus-sysv4
	exit 0 ;;
  *:*:*:FTX*)
	# From seanf@swdc.stratus.com.
	echo i860-stratus-sysv4
        exit 0 ;;
  mc68*:A/UX:*:*)
	echo m68k-apple-aux${UNAME_RELEASE}
	exit 0 ;;
  news*:NEWS-OS:6*:*)
	echo mips-sony-newsos6
	exit 0 ;;
  R[34]000:*System_V*:*:* | R[34]000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:* )
	if [ -d /usr/nec ]; then
	  echo mips-nec-sysv${UNAME_RELEASE}
	else
	  echo mips-unknown-sysv${UNAME_RELEASE}
	fi
        exit 0 ;;
  BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
    echo powerpc-be-beos
    exit 0 ;;
  BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
    echo powerpc-apple-beos
    exit 0 ;;
  BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
    echo i586-pc-beos
    exit 0 ;;
  SX-4:SUPER-UX:*:*)
    echo sx4-nec-superux${UNAME_RELEASE}
    exit 0 ;;
  SX-5:SUPER-UX:*:*)
    echo sx5-nec-superux${UNAME_RELEASE}
    exit 0 ;;
  Power*:Rhapsody:*:*)
    echo powerpc-apple-rhapsody${UNAME_RELEASE}
    exit 0 ;;
  *:Rhapsody:*:*)
    echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
    exit 0 ;;
  PENTIUM:CPunix:4.0*:*)
      # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
      # says <Richard.M.Bartel@ccMail.Census.GOV>
      echo i586-unisys-sysv4
      exit 0 ;;
esac

# ----------------------------------------------------------------------

# Try some other programs.  These should echo the name of the machine type
# on stdout.
progs="
   /bin/arch
   /bin/mach
   /bin/machine
   /usr/local/bin/machine
"
machtype=""

for prog in $progs ; do
   # Should really be -x, but some old versions of test are broken
   if test -f $prog ; then
      machtype="`$prog 2> /dev/null`"
      break
   fi
done

if test -z "$machtype"; then
   # These programs just exit with a zero exit status if they are for the
   # correct machine type.  They return false otherwise.  Add programs as
   # necessary.
   #
   #  Be sure to list most specific types first.  For example, on a Sun,
   # /bin/sun will return 0 even though that's not very specific.  Try `sun3',
   # `sun4', etc. first before trying `sun'.

   commands='
      /bin/hp9000s*
      /bin/vax
      /bin/sun4c
      /bin/sun4
      /bin/sun3x
      /bin/sun3
      /bin/sun2
      /bin/sun386
      /bin/i386
      /bin/iAPX286
   '
   machtype=""

   for cmd in $commands ; do
      if test -f "$cmd" && "$cmd" ; then
         machtype="`basename $cmd`"
         break
      fi
   done
fi

case "$machtype" in
   iAPX286 )
      echo iAPX286-sun-sunos
      exit 0 ;;
   ibmrt )
      echo romp-ibm-aos
      exit 0 ;;
   hp9000s3?? | hp3?? )
      if test -f /vmunix ; then echo m68k-hp-bsd;  exit 0; fi
      if test -f /hp-ux ;  then echo m68k-hp-hpux; exit 0; fi
      echo m68k-hp-unknown
      exit 0 ;;
   hp9000s7?? | hp7?? )
      if test -f /vmunix ; then echo hppa1.1-hp-bsd;  exit 0; fi
      if test -f /hp-ux ;  then echo hppa1.1-hp-hpux; exit 0; fi
      echo hppa1.0-hp-unknown
      exit 0 ;;
   hp9000s8?? | hp8?? )
      if test -f /vmunix ; then echo hppa1.0-hp-bsd;  exit 0; fi
      if test -f /hp-ux ;  then echo hppa1.0-hp-hpux; exit 0; fi
      echo hppa1.0-hp-unknown
      exit 0 ;;
   news* )
      version="`strings /vmunix \
           | sed -n -e '/^NEWS-OS R/{s/^[^ ]* [^ ]* \([^ ]*\) .*/\1/p;q;}'`"
      echo m68k-sony-newsos$version
      exit 0 ;;
   sparc | sun4* )
      version="`strings /vmunix \
           | sed -n -e '/^SunOS R/{s/^SunOS [^ ]* \([^ ]*\) .*/\1/p;q;}
                        /^Sun UNIX/{s/.*Release \([^ ]*\) .*/\1/p;q;}'`"
      echo sparc-sun-sunos$version
      exit 0 ;;
   sun386 )
      echo i386-sun-sunos
      exit 0 ;;
   sun2 | sun3* )
      version="`strings /vmunix \
           | sed -n -e '/^SunOS R/{s/^SunOS [^ ]* \([^ ]*\) .*/\1/p;q;}
                        /^Sun UNIX/{s/.*Release \([^ ]*\) .*/\1/p;q;}'`"
      echo m68k-sun-sunos$version
      exit 0 ;;
   vax )
      version="`strings /vmunix \
           | sed -n -e '/^ULTRIX V[0-9]/{s/^ULTRIX V\([^ ]*\) .*/\1/p;q;}'`"
      echo vax-dec-ultrix$version
      exit 0 ;;
esac

# ----------------------------------------------------------------------
# Last ditch effort.  Compile a program.

cd /tmp || (echo "unknown"; exit 1)

f=$dummy
trap 'rm -f $f.c $f.o $f; exit 1' 1 2 15

cat > "$f.c" <<EOF
#ifdef _SEQUENT_
# include <sys/types.h>
# include <sys/utsname.h>
#endif

main ()
{
#if defined (sony)
#if defined (MIPSEB)
  /* BFD wants "bsd" instead of "newsos". */
  printf ("mips-sony-bsd\n"); exit (0);
#else
#include <sys/param.h>
#ifdef NEWSOS4
  printf ("m68k-sony-newsos4\n");
#else
  printf ("m68k-sony-newsos\n");
#endif
  exit (0);
#endif
#endif

#if defined (__arm) && defined (__acorn) && defined (__unix)
  printf ("arm-acorn-riscix"); exit (0);
#endif

#if defined (hp300) && !defined (hpux)
  printf ("m68k-hp-bsd\n"); exit (0);
#endif

#if defined (NeXT)
#if !defined (__ARCHITECTURE__)
#define __ARCHITECTURE__ "m68k"
#endif
  int version;
  version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`;
  if (version < 4)
    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
  else
    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
  exit (0);
#endif

#if defined (MULTIMAX) || defined (n16)
#if defined (UMAXV)
  printf ("ns32k-encore-sysv\n"); exit (0);
#else
#if defined (CMU)
  printf ("ns32k-encore-mach\n"); exit (0);
#else
  printf ("ns32k-encore-bsd\n"); exit (0);
#endif
#endif
#endif

#if defined (__386BSD__)
  printf ("i386-pc-bsd\n"); exit (0);
#endif

#if defined (sequent)
#if defined (i386)
  printf ("i386-sequent-dynix\n"); exit (0);
#endif
#if defined (ns32000)
  printf ("ns32k-sequent-dynix\n"); exit (0);
#endif
#endif

#if defined (_SEQUENT_)
  struct utsname un;

  uname(&un);

  if (strncmp (un.version, "V2", 2) == 0)
    {
      printf ("i386-sequent-ptx2\n");
      exit (0);
    }
  if (strncmp (un.version, "V1", 2) == 0)
    {
      /* XXX is V1 correct? */
      printf ("i386-sequent-ptx1\n");
      exit (0);
    }
  printf ("i386-sequent-ptx\n");
  exit (0);
#endif

#if defined (vax)
#if !defined (ultrix)
  printf ("vax-dec-bsd\n"); exit (0);
#else
  printf ("vax-dec-ultrix\n"); exit (0);
#endif

  exit (1);
}
EOF

$CC_FOR_BUILD $f.c -o $f 2> /dev/null && ./$f && rm -f $f.c $f && exit 0
rm -f $f.c $f

# Apollos put the system type in the environment.
if test -d /usr/apollo ; then
   echo $ISP-apollo-$SYSTYPE
   exit 0
fi

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

if test -f /usr/convex/getsysinfo; then
  case `getsysinfo -f cpu_type` in
    c1*) echo c1-convex-bsd; exit 0 ;;
    c2*)
      if getsysinfo -f scalar_acc ; then
        echo c32-convex-bsd
      else
        echo c2-convex-bsd
      fi
      exit 0
     ;;
    c34*) echo c34-convex-bsd ; exit 0 ;;
    c38*) echo c38-convex-bsd ; exit 0 ;;
    c4*)  echo c4-convex-bsd  ; exit 0 ;;
  esac
fi

echo "unknown"
exit 1

# hosttype ends here
