head	1.19;
access;
symbols;
locks; strict;
comment	@# @;


1.19
date	2003.12.11.20.43.41;	author rse;	state Exp;
branches;
next	1.18;

1.18
date	2003.10.31.20.43.57;	author rse;	state Exp;
branches;
next	1.17;

1.17
date	2003.10.31.20.27.48;	author rse;	state Exp;
branches;
next	1.16;

1.16
date	2003.10.31.20.01.18;	author rse;	state Exp;
branches;
next	1.15;

1.15
date	2003.10.28.09.31.49;	author rse;	state Exp;
branches;
next	1.14;

1.14
date	2003.10.26.11.31.12;	author rse;	state Exp;
branches;
next	1.13;

1.13
date	2003.10.26.10.12.18;	author rse;	state Exp;
branches;
next	1.12;

1.12
date	2003.09.29.12.53.15;	author rse;	state Exp;
branches;
next	1.11;

1.11
date	2003.09.29.10.11.31;	author rse;	state Exp;
branches;
next	1.10;

1.10
date	2003.09.28.12.17.08;	author rse;	state Exp;
branches;
next	1.9;

1.9
date	2003.09.13.18.17.49;	author rse;	state Exp;
branches;
next	1.8;

1.8
date	2003.09.12.09.25.06;	author rse;	state Exp;
branches;
next	1.7;

1.7
date	2003.09.11.17.59.34;	author rse;	state Exp;
branches;
next	1.6;

1.6
date	2003.09.09.09.24.32;	author rse;	state Exp;
branches;
next	1.5;

1.5
date	2003.09.09.09.05.31;	author rse;	state Exp;
branches;
next	1.4;

1.4
date	2003.09.08.19.13.00;	author rse;	state Exp;
branches;
next	1.3;

1.3
date	2003.09.08.19.03.03;	author rse;	state Exp;
branches;
next	1.2;

1.2
date	2003.09.08.11.24.01;	author rse;	state Exp;
branches;
next	1.1;

1.1
date	2003.09.08.11.16.13;	author rse;	state Exp;
branches;
next	;


desc
@@


1.19
log
@add RedHat AS, ES, WS and Fedora support
@
text
@##
##  OSSP platform - Unix Platform Identification
##  Copyright (c) 2003 The OSSP Project <http://www.ossp.org/>
##  Copyright (c) 2003 Ralf S. Engelschall <rse@@engelschall.com>
##
##  This file is part of OSSP platform, a Unix platform identification
##  program which can be found at http://www.ossp.org/pkg/tool/platform/.
##
##  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.0 of the License, 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 library; if not, write to the Free Software
##  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
##  USA, or contact Ralf S. Engelschall <rse@@engelschall.com>.
##
##  platform.sh: the program (language: Bourne-Shell)
##

#   program information
prog_run="${0}"
prog_cmd="platform"
prog_name="OSSP platform"
prog_vers="0.1.0"
prog_date="30-Oct-2003"

##  _________________________________________________________________________
##
##                           COMMAND LINE PARSING
##                (partly derived from GNU shtool's sh.common)
##  _________________________________________________________________________
##

#   the command line specification
str_usage="[-F|--format FORMAT]"
str_usage="$str_usage [-S|--sep STRING]"
str_usage="$str_usage [-C|--conc STRING]"
str_usage="$str_usage [-L|--lower]"
str_usage="$str_usage [-U|--upper]"
str_usage="$str_usage [-v|--verbose]"
str_usage="$str_usage [-c|--concise]"
str_usage="$str_usage [-n|--no-newline]"
str_usage="$str_usage [-t|--type TYPE]"
str_usage="$str_usage [-d|--debug]"
str_usage="$str_usage [-V|--version]"
str_usage="$str_usage [-h|--help]"
arg_spec="0="
opt_spec="F:S:C:L.U.v.c.n.t:d.V.h."
opt_alias="F:format,S:sep,C:conc,L:lower,U:upper,v:verbose,c:consise,t:type,n:no-newline,d:debug,V:version,h:help"
opt_F="%{sp} (%{ap})"
opt_S=" "
opt_C="/"
opt_L=no
opt_U=no
opt_t=""
opt_v=no
opt_c=no
opt_n=no
opt_d=no
opt_V=no
opt_h=no

#   commonly used ASCII values
ASC_TAB="	"
ASC_NL="
"

#   parse argument specification string
eval `echo $arg_spec |\
      sed -e 's/^\([0-9]*\)\([+=]\)/arg_NUMS=\1; arg_MODE=\2/'`

#   parse option specification string
eval `echo $opt_spec |\
      sed -e 's/\([a-zA-Z0-9]\)\([.:+]\)/opt_MODE_\1=\2;/g'`

#   parse option alias string
eval `echo $opt_alias |\
      tr 'x-' 'x_' | sed -e 's/\([a-zA-Z0-9]\):\([^,]*\),*/opt_ALIAS_\2=\1;/g'`

#   interate over argument line
opt_PREV=''
while [ $# -gt 0 ]; do
    #   special option stops processing
    if [ ".$1" = ".--" ]; then
        shift
        break
    fi

    #   determine option and argument
    opt_ARG_OK=no
    if [ ".$opt_PREV" != . ]; then
        #   merge previous seen option with argument
        opt_OPT="$opt_PREV"
        opt_ARG="$1"
        opt_ARG_OK=yes
        opt_PREV=''
    else
        #   split argument into option and argument
        case "$1" in
            --[a-zA-Z0-9]*=*)
                eval `echo "x$1" |\
                      sed -e 's/^x--\([a-zA-Z0-9-]*\)=\(.*\)$/opt_OPT="\1";opt_ARG="\2"/'`
                opt_STR=`echo $opt_OPT | tr 'x-' 'x_'`
                eval "opt_OPT=\${opt_ALIAS_${opt_STR}-${opt_OPT}}"
                ;;
            --[a-zA-Z0-9]*)
                opt_OPT=`echo "x$1" | cut -c4-`
                opt_STR=`echo $opt_OPT | tr 'x-' 'x_'`
                eval "opt_OPT=\${opt_ALIAS_${opt_STR}-${opt_OPT}}"
                opt_ARG=''
                ;;
            -[a-zA-Z0-9]*)
                eval `echo "x$1" |\
                      sed -e 's/^x-\([a-zA-Z0-9]\)/opt_OPT="\1";/' \
                          -e 's/";\(.*\)$/"; opt_ARG="\1"/'`
                ;;
            -[a-zA-Z0-9])
                opt_OPT=`echo "x$1" | cut -c3-`
                opt_ARG=''
                ;;
            *)
                break
                ;;
        esac
    fi

    #   eat up option
    shift

    #   determine whether option needs an argument
    eval "opt_MODE=\$opt_MODE_${opt_OPT}"
    if [ ".$opt_ARG" = . ] && [ ".$opt_ARG_OK" != .yes ]; then
        if [ ".$opt_MODE" = ".:" ] || [ ".$opt_MODE" = ".+" ]; then
            opt_PREV="$opt_OPT"
            continue
        fi
    fi

    #   process option
    case $opt_MODE in
        '.' )
            #   boolean option
            eval "opt_${opt_OPT}=yes"
            ;;
        ':' )
            #   option with argument (multiple occurances override)
            eval "opt_${opt_OPT}=\"\$opt_ARG\""
            ;;
        '+' )
            #   option with argument (multiple occurances append)
            eval "opt_${opt_OPT}=\"\$opt_${opt_OPT}\${ASC_NL}\$opt_ARG\""
            ;;
        * )
            echo "${prog_cmd}:Error: unknown option: \`$opt_OPT'" 1>&2
            echo "${prog_cmd}:Hint:  run \`${prog_run} -h' or \`man ${prog_cmd}' for details" 1>&2
            exit 1
            ;;
    esac
done
if [ ".$opt_PREV" != . ]; then
    echo "${prog_cmd}:Error: missing argument to option \`$opt_PREV'" 1>&2
    echo "${prog_cmd}:Hint: run \`${prog_run} -h' or \`man ${prog_cmd}' for details" 1>&2
    exit 1
fi

#   process help option
if [ ".$opt_h" = .yes ]; then
    echo "Usage: ${prog_run} ${str_usage}"
    exit 0
fi

#   process version option
if [ ".$opt_V" = .yes ]; then
    echo "${prog_name} ${prog_vers} (${prog_date})"
    exit 0
fi

#   complain about incorrect number of arguments
case $arg_MODE in
    '=' )
        if [ $# -ne $arg_NUMS ]; then
            echo "${prog_cmd}:Error: invalid number of arguments (exactly $arg_NUMS expected)" 1>&2
            echo "${prog_cmd}:Hint:  run \`${prog_run} -h' or \`man ${prog_cmd}' for details" 1>&2
            exit 1
        fi
        ;;
    '+' )
        if [ $# -lt $arg_NUMS ]; then
            echo "${prog_cmd}:Error: invalid number of arguments (at least $arg_NUMS expected)" 1>&2
            echo "${prog_cmd}:Hint:  run \`${prog_run} -h' or \`man ${prog_cmd}' for details" 1>&2
            exit 1
        fi
        ;;
esac

##  _________________________________________________________________________
##
##                         OPTION POST-PROCESSING
##  _________________________________________________________________________
##

if [ ".$opt_t" != . ]; then
    case "$opt_t" in
        binary )
            #   binary package id (OpenPKG RPM)
            opt_F="%<ap>-%<sp>"
            opt_L=yes
            opt_S=""
            opt_C="+"
            ;;
        build )
            #   build time checking (OpenPKG RPM)
            opt_F="%<at>-%<st>"
            opt_L=yes
            opt_S=""
            opt_C="+"
            ;;
        gnu )
            #   GNU config.guess style <arch>-<vendor>-<os><osversion>
            opt_F="%<at>-unknown-%<st>"
            opt_L=yes
            opt_S=""
            opt_C="+"
            ;;
        web )
            #   non-whitespace HTTP Server-header id
            opt_F="%<sp>-%<ap>"
            opt_S="/"
            opt_C="+"
            ;;
        summary)
            #   human readable verbose summary information
            opt_F="Class:      %[sc] (%[ac])\\nProduct:    %[sp] (%[ap])\\nTechnology: %[st] (%[at])"
            opt_S=" "
            opt_C="/"
            ;;
        all-in-one )
            #   full-table all-in-one information
            opt_F=""
            opt_F="${opt_F}concise architecture class:      %<ac>\\n"
            opt_F="${opt_F}regular architecture class:      %{ac}\\n"
            opt_F="${opt_F}verbose architecture class:      %[ac]\\n"
            opt_F="${opt_F}concise architecture product:    %<ap>\\n"
            opt_F="${opt_F}regular architecture product:    %{ap}\\n"
            opt_F="${opt_F}verbose architecture product:    %[ap]\\n"
            opt_F="${opt_F}concise architecture technology: %<at>\\n"
            opt_F="${opt_F}regular architecture technology: %{at}\\n"
            opt_F="${opt_F}verbose architecture technology: %[at]\\n"
            opt_F="${opt_F}concise system class:            %<sc>\\n"
            opt_F="${opt_F}regular system class:            %{sc}\\n"
            opt_F="${opt_F}verbose system class:            %[sc]\\n"
            opt_F="${opt_F}concise system product:          %<sp>\\n"
            opt_F="${opt_F}regular system product:          %{sp}\\n"
            opt_F="${opt_F}verbose system product:          %[sp]\\n"
            opt_F="${opt_F}concise system technology:       %<st>\\n"
            opt_F="${opt_F}regular system technology:       %{st}\\n"
            opt_F="${opt_F}verbose system technology:       %[st]"
            ;;
        * )
            echo "${prog_cmd}:Error: invalid type \`$opt_t'" 1>&2
            exit 1
            ;;
    esac
fi

##  _________________________________________________________________________
##
##                            UTILITY FUNCTIONS
##  _________________________________________________________________________
##

#   map string to lower case
util_lower () {
    echo "$1" | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'
}

#   map string to upper case
util_upper () {
    echo "$1" | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
}

##  _________________________________________________________________________
##
##                       ASSEMBLE INITIAL INFORMATION
##  _________________________________________________________________________
##

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

UNAME="${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}"

if [ ".$opt_d" = .yes ]; then
    echo "uname => ${UNAME}" 1>&2
fi

AC=""; AP=""; AT=""
SC=""; SP=""; ST=""

##  _________________________________________________________________________
##
##                         DISPATCH INTO PLATFORMS
##  _________________________________________________________________________
##

case "${UNAME}" in

    #   FreeBSD
    *:FreeBSD:* )
        #   determine architecture
        AC="${UNAME_MACHINE}"
        case "${AC}" in
            i386 ) AC="iX86" ;;
        esac
        AP="${AC}"
        AT=`(/sbin/sysctl -n hw.model) 2>&1`
        case "${AT}" in
            *"Xeon"* | *"Pentium Pro"* | *"Cyrix 6x86MX"* | *"Pentium II"* | *"Pentium III"* | *"Pentium 4"* | *"Celeron"* ) AT="i686" ;;
            *"Pentium"* ) AT="i586" ;; *"i486[SD]X"* | *"Cyrix 486"* | *"Cyrix [56]x86"* | *"Blue Lightning" | *"Cyrix 486S/DX" ) AT="i486" ;;
            *"i386[SD]X"* | *"NexGen 586"* ) AT="i386" ;;
            * ) AT="${AP}" ;;
        esac
        #   determine system
        r=`echo "${UNAME_RELEASE}" |\
           sed -e 's;[()];;' -e 's/\(-.*\)$/[\1]/'`
        ST="FreeBSD ${r}"
        SP="${ST}"
        case "${r}" in
            1.* ) SC="4.3BSD" ;;
            *   ) SC="4.4BSD" ;;
        esac
        ;;

    #   NetBSD
    *:NetBSD:* )
        #   determine architecture
        AT="${UNAME_MACHINE}"
        AP="${AT}"
        case "${AP}" in
            i[3-6]86 ) AP="iX86" ;;
        esac
        AC="${AP}"
        #   determine system
        r=`echo "${UNAME_RELEASE}" | sed -e 's/\(-.*\)$/[\1]/'`
        ST="NetBSD ${r}"
        SP="${ST}"
        case "${r}" in
            0.* ) SC="4.3BSD" ;;
            *   ) SC="4.4BSD" ;;
        esac
        ;;

    #   OpenBSD
    *:OpenBSD:* )
        #   determine architecture
        AT="${UNAME_MACHINE}"
        AP="${AT}"
        case "${AP}" in
            i[3-6]86 ) AP="iX86" ;;
        esac
        AC="${AP}"
        #   determine system
        r=`echo "${UNAME_RELEASE}" | sed -e 's/\(-.*\)$/[\1]/'`
        ST="OpenBSD ${r}"
        SP="${ST}"
        SC="4.4BSD"
        ;;

    #   GNU/Linux
    *:Linux:* )
        #   determine architecture
        AT="${UNAME_MACHINE}"
        case "${AT}" in
           ia64     ) AT="IA64"   ;;
           x86_64   ) AT='AMD64'  ;;
           parisc   ) AT="HPPA32" ;;
           parisc64 ) AT="HPPA64" ;;
        esac
        AP="${AT}"
        case "${AP}" in
           i[3-6]86 ) AP='iX86' ;;
        esac
        AC="${AP}"
        #   determine system
        v_kern=`echo "${UNAME_RELEASE}" |\
            sed -e 's/^\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/'`
        v_libc=`(strings /lib/libc.so.* | grep '^GLIBC_' | sed -e 's/^GLIBC_//' |\
            sort -n | tail -1 | sed -e 's/^\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/') 2>/dev/null`
        ST="GNU/<Linux >${v_libc}/<${v_kern}>"
        if [ -f /etc/lsb-release ]; then
            eval `( . /etc/lsb-release
                echo "SC=\"LSB${LSB_VERSION}\""
                if [ ".${DISTRIB_ID}" != . -a ".${DISTRIB_RELEASE}" != . ]; then
                    echo "SP=\"${DISTRIB_ID} ${DISTRIB_RELEASE}\""
                fi
            ) 2>/dev/null`
        fi
        if [ ".$SP" = . ]; then
            for tagfile in x \
                `cd /etc && \
                /bin/ls *[_-]release *[_-]version 2>/dev/null | \
                sed -e '/^redhat-release$/d' -e '/^lsb-release$/d'; \
                echo redhat-release lsb-release`
            do
                [ ".${tagfile}" = .x ] && continue
                [ ! -f "/etc/${tagfile}" ] && continue
                n=`echo ${tagfile} | sed -e 's/[_-]release$//' -e 's/[_-]version$//'`
                v=`(grep VERSION /etc/${tagfile}; cat /etc/${tagfile}) | grep '[0-9]' | head -1 |\
                   sed -e 's/^/#/' \
                       -e 's/^#[^0-9]*\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*$/\1/' \
                       -e 's/^#[^0-9]*\([0-9][0-9]*\.[0-9][0-9]*\).*$/\1/' \
                       -e 's/^#[^0-9]*\([0-9][0-9]*\).*$/\1/' \
                       -e 's/^#.*$//'`
                t=""
                if [ ".${n}" = .redhat ]; then
                    t=`head -1 /etc/${tagfile} | \
                       sed -e 's/^/#/' \
                           -e 's/^#.*Red Hat Enterprise Linux \([AEW]S\).*$/\1/' \
                           -e 's/^#.*$//'`
                fi
                case "`util_lower ${n}`" in
                    debian      ) n="Debian[ GNU/Linux]" ;;
                    fedora      ) n="Fedora[ GNU/Linux]" ;;
                    redhat      ) n="RedHat[ Linux]"     ;;
                    suse        ) n="SuSE[ Linux]"       ;;
                    mandrake    ) n="Mandrake[ Linux]"   ;;
                    gentoo      ) n="Gentoo[ Linux]"     ;;
                    slackware   ) n="Slackware[ Linux]"  ;;
                    turbolinux  ) n="TurboLinux"         ;;
                    unitedlinux ) n="UnitedLinux"        ;;
                    *           ) n="${n}[ GNU/Linux]"   ;;
                esac
                if [ ".${t}" != . ]; then
                    n="${n} ${t}"
                fi
                SP="$n $v"
                break
            done
        fi
        [ ".$SP" = . ] && SP="${ST}"
        [ ".$SC" = . ] && SC="LSB"
        ;;

    #   Sun Solaris
    *:SunOS:* )
        #   determine architecture
        AT="${UNAME_MACHINE}"
        case "${AT}" in
            i86pc ) AT="iX86" ;;
        esac
        AP="${AT}"
        case "${AP}" in
            sun4[cdm] ) AP="SPARC32" ;;
            sun4u     ) AP="SPARC64" ;;
            sun4*     ) AP="SPARC"   ;;
        esac
        AC="${AP}"
        case "${AC}" in
            SPARC* ) AC="SPARC" ;;
        esac
        #   determine system
        ST="[Sun ]SunOS ${UNAME_RELEASE}"
        v=`echo "${UNAME_RELEASE}" |\
           sed -e 's;^4\.;1.;' \
               -e 's;^5\.\([0-6]\)[^0-9]*$;2.\1;' \
               -e 's;^5\.\([0-9][0-9]*\).*;\1;'`
        SP="[Sun ]Solaris $v"
        case "${UNAME_RELEASE}" in
            4.* ) SC="4.3BSD" ;;
            5.* ) SC="SVR4"   ;;
        esac
        ;;

    #   SCO UnixWare
    *:UnixWare:* )
        #   determine architecture
        AT="${UNAME_MACHINE}"
        case "${AT}" in
            i[3-6]86 | ix86at ) AT="iX86" ;;
        esac
        AP="${AT}"
        #   determine system
        v=`/sbin/uname -v`
        ST="[SCO ]UnixWare ${v}"
        SP="${ST}"
        SC="SVR${UNAME_RELEASE}"
        ;;

    #   QNX
    *:QNX:* )
        #   determine architecture
        AT="${UNAME_MACHINE}"
        case "${AT}" in
            x86pc ) AT="iX86" ;;
        esac
        AP="${AT}"
        #   determine system
        v="${UNAME_RELEASE}"
        ST="QNX[ Neutrino RTOS] ${v}"
        v=`echo "${v}" | sed -e 's;^\([0-9][0-9]*\.[0-9][0-9]*\).*$;\1;'`
        SP="QNX[ Neutrino RTOS] ${v}"
        SC="QNX"
        ;;

    #   SGI IRIX
    *:IRIX*:* )
        #   determine architecture
        AT="${UNAME_MACHINE}"
        AP="${AT}"
        case "${AP}:${UNAME_SYSTEM}" in
            IP*:IRIX64 ) AP="MIPS64" ;;
            IP*:*      ) AP="MIPS"   ;;
        esac
        AC="${AP}"
        #   determine system
        v=`(/bin/uname -R || /bin/uname -r) 2>/dev/null | sed -e 's;[0-9.]* ;;'`
        ST="[SGI ]IRIX ${v}"
        v="${UNAME_RELEASE}"
        SP="[SGI ]IRIX ${v}"
        SC="4.2BSD/SVR3"
        ;;

    #   HP HP-UX
    *:HP-UX:* )
        #   determine architecture
        AT="${UNAME_MACHINE}"
        case "${AT}" in
            ia64 ) AT="IA64" ;;
            9000/[34]?? ) AT=M68K ;;
            9000/[678][0-9][0-9])
                sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
                sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
                case "${sc_cpu_version}" in
                    523 ) AT="HPPA1.0" ;;
                    528 ) AT="HPPA1.1" ;;
                    532 ) AT="HPPA2.0"
                        case "${sc_kernel_bits}" in
                            32 ) AT="${AT}n" ;;
                            64 ) AT="${AT}w" ;;
                        esac
                        ;;
                esac
                ;;
        esac
        AP="${AT}"
        case "${AP}" in
            HPPA* ) AP="HPPA" ;;
        esac
        AC="${AP}"
        #   determine system
        v=`echo "${UNAME_RELEASE}" | sed -e 's;^[^0-9]*;;'`
        ST="[HP ]<HP>-<UX> ${v}"
        SP="${ST}"
        case "${v}" in
            10.*   ) SC="SVR4.2" ;;
            [7-9]* ) SC="SVR4"   ;;
        esac
        ;;

    #   HP Tru64 (OSF1)
    *:OSF1:* )
        #   determine architecture
        AP="${UNAME_MACHINE}"
        case "${AP}" in
            alpha ) AP="Alpha" ;;
        esac
        alpha_type=`(/usr/sbin/psrinfo -v) 2>/dev/null |\
            sed -n -e 's/^.*The alpha \([^ ][^ ]*\).*processor.*$/\1/p' | head -n 1`
        AT="${AP}${alpha_type}"
        AC="${AP}"
        #   determine system
        v=`echo "${UNAME_RELEASE}" | sed -e 's;^[VTX];;'`
        ST="[HP ]Tru64 ${v}"
        SP="${ST}"
        SC="OSF1"
        ;;

    #   IBM AIX
    *:AIX:* )
        cpu_arch=rs6000
        if [ -x /usr/sbin/lsdev -a -x /usr/sbin/lsattr ]; then
            cpu_id=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
            if [ ".`/usr/sbin/lsattr -El ${cpu_id} | grep -i powerpc`" != . ]; then
                cpu_arch=powerpc
            fi
        fi
        if [ -x /usr/bin/oslevel ]; then
            os_level=`/usr/bin/oslevel`
        else
            os_level="`uname -r`.`uname -v`"
        fi
        os_level=`echo "${os_level}" |\
                  sed -e 's;^\([0-9][0-9]*\.[0-9][0-9]*\)\(\.[0-9][0-9]*\)\(.*\)$;<\1>\2[\3];' \
                      -e 's;^\([0-9][0-9]*\.[0-9][0-9]*\)\(.*\)$;<\1>\2;'`
        AT="${cpu_arch}"
        AP="${AT}"
        AC="${AP}"
        ST="[IBM ]AIX ${os_level}"
        SP="${ST}"
        case "${os_level}" in
            [12]* ) SC="SVR2" ;;
            *     ) SC="SVR4" ;;
        esac
        ;;

    #   Apple MacOS X Darwin
    *:Darwin:* )
        AT=`uname -p`
        case "${AT}" in
            powerpc ) AT="PPC" ;;
        esac
        AP="${AT}"
        AC="${AP}"
        case "${AC}" in
            i?86 ) AC="iX86" ;;
        esac
        ST="[Apple ]${UNAME_SYSTEM} ${UNAME_RELEASE}"
        SP="${ST}"
        SC="4.4BSD/Mach3"
        ;;

    #   TODO ...ADD YOUR NEW PLATFORM CHECK HERE... TODO
    # *:XXX:* )
    #   ...
    #   ;;

    #   ...A STILL UNKNOWN PLATFORM...
    * )
        AT=`echo "${UNAME_MACHINE}" | sed -e "s; ;${opt_C};g"`
        AP="${AT}"
        AC="${AP}"
        v=`echo "${UNAME_RELEASE}" |\
           sed -e 's/^/#/' \
               -e 's/^#[^0-9]*\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*$/\1/' \
               -e 's/^#[^0-9]*\([0-9][0-9]*\.[0-9][0-9]*\).*$/\1/' \
               -e 's/^#[^0-9]*\([0-9][0-9]*\).*$/\1/' \
               -e 's/^#.*$/?/'`
        ST="${UNAME_SYSTEM} ${v}"
        SP="${ST}"
        SC="${SP}"
        ;;

esac

##  _________________________________________________________________________
##
##                           PROVIDE RESULT OUTPUT
##  _________________________________________________________________________
##

#   provide fallback values
[ ".$AT" = . ] && AT="${AP:-${AC}}"
[ ".$AP" = . ] && AP="${AT:-${AC}}"
[ ".$AC" = . ] && AC="${AP:-${AT}}"
[ ".$ST" = . ] && ST="${SP:-${SC}}"
[ ".$SP" = . ] && SP="${ST:-${SC}}"
[ ".$SC" = . ] && SC="${SP:-${ST}}"

#   support explicit enforced verbose/concise output
if [ ".$opt_v" = .yes ]; then
    opt_F=`echo ":$opt_F" | sed -e 's/^://' -e 's/%\([as][cpt]\)/%[\1]/g'`
elif [ ".$opt_c" = .yes ]; then
    opt_F=`echo ":$opt_F" | sed -e 's/^://' -e 's/%\([as][cpt]\)/%<\1>/g'`
fi

#   provide verbose and concise variants
AC_V=""; AC_N=""; AC_C=""
AP_V=""; AP_N=""; AP_C=""
AT_V=""; AT_N=""; AT_C=""
SC_V=""; SC_N=""; SC_C=""
SP_V=""; SP_N=""; SP_C=""
ST_V=""; ST_N=""; ST_C=""
for var_lc in at ap ac st sp sc; do
    case "$opt_F" in
        *"%[${val_lc}]"* | *"%{${val_lc}}"* | *"%${val_lc}"* | *"%<${val_lc}>"* )
        var_uc=`util_upper "$var_lc"`
        eval "val=\"\$${var_uc}\""
        val_V=""; val_N=""; val_C=""
        case "$opt_F" in
            *"%[${var_lc}]"* )
                val_V=`echo ":$val" | \
                       sed -e 's/^://' \
                           -e 's;\[\([^]]*\)\];\1;g' \
                           -e 's;<\([^>]*\)>;\1;g' \
                           -e "s; ;§§;g" \
                           -e "s;/;%%;g" \
                           -e "s;§§;${opt_S};g" \
                           -e "s;%%;${opt_C};g"`
                eval "${var_uc}_V=\"\${val_V}\""
                ;;
        esac
        case "$opt_F" in
            *"%{${var_lc}}"* | *"%${var_lc}"* )
                val_N=`echo ":$val" | \
                       sed -e 's/^://' \
                           -e 's;\[\([^]]*\)\];;g' \
                           -e 's;<\([^>]*\)>;\1;g' \
                           -e "s; ;§§;g" \
                           -e "s;/;%%;g" \
                           -e "s;§§;${opt_S};g" \
                           -e "s;%%;${opt_C};g"`
                eval "${var_uc}_N=\"\${val_N}\""
                ;;
        esac
        case "$opt_F" in
            *"%<${var_lc}>"* )
                val_C=`echo ":$val" | \
                       sed -e 's/^://' \
                           -e 's;\[\([^]]*\)\];;g' \
                           -e 's;[^<]*<\([^>]*\)>;\1;g' \
                           -e "s; ;§§;g" \
                           -e "s;/;%%;g" \
                           -e "s;§§;${opt_S};g" \
                           -e "s;%%;${opt_C};g"`
                eval "${var_uc}_C=\"\${val_C}\""
                ;;
        esac
        ;;
    esac
done

#   create output string
output=`echo ":$opt_F" |\
        sed -e "s/^://" \
            -e "s;%\\[ac\\];${AC_V};g" \
            -e "s;%{ac};${AC_N};g" \
            -e "s;%ac;${AC_N};g" \
            -e "s;%<ac>;${AC_C};g" \
            -e "s;%\\[ap\\];${AP_V};g" \
            -e "s;%{ap};${AP_N};g" \
            -e "s;%ap;${AP_N};g" \
            -e "s;%<ap>;${AP_C};g" \
            -e "s;%\\[at\\];${AT_V};g" \
            -e "s;%{at};${AT_N};g" \
            -e "s;%at;${AT_N};g" \
            -e "s;%<at>;${AT_C};g" \
            -e "s;%\\[sc\\];${SC_V};g" \
            -e "s;%{sc};${SC_N};g" \
            -e "s;%sc;${SC_N};g" \
            -e "s;%<sc>;${SC_C};g" \
            -e "s;%\\[sp\\];${SP_V};g" \
            -e "s;%{sp};${SP_N};g" \
            -e "s;%sp;${SP_N};g" \
            -e "s;%<sp>;${SP_C};g" \
            -e "s;%\\[st\\];${ST_V};g" \
            -e "s;%{st};${ST_N};g" \
            -e "s;%st;${ST_N};g" \
            -e "s;%<st>;${ST_C};g" \
            -e 's/\\\\n/^/g' |\
         tr '^' '\012'`

#   support lower/upper-case mapping
if [ ".$opt_L" = .yes ]; then
    output=`util_lower "$output"`
elif [ ".$opt_U" = .yes ]; then
    output=`util_upper "$output"`
fi

#   display output string
if [ ".$opt_n" = .yes ]; then
    echo . | awk '{ printf("%s", output); }' output="$output"
else
    echo "$output"
fi

@


1.18
log
@bump date
@
text
@d406 1
a406 1
                if [ ".${DISTRIB_ID}" != . ]; then
d412 2
a413 1
            for tagfile in x `cd /etc && \
d415 3
a417 1
                sed -e '/redhat-release/d'; echo redhat-release`; do
d427 7
d436 1
d446 3
@


1.17
log
@more correct IBM AIX platform information determination (not tried on a real AIX box, but assembled together from various information pieces found on the net)
@
text
@d32 1
a32 1
prog_date="06-Sep-2003"
@


1.16
log
@small fixes (found through HP TestDrive machines)
@
text
@d579 16
a594 1
        AT="${UNAME_MACHINE}"
d597 1
a597 1
        ST="[IBM ]AIX ${UNAME_RELEASE}"
d599 1
a599 1
        case "${UNAME_RELEASE}" in
@


1.15
log
@correctly support Solaris 10
@
text
@d2 1
a2 1
##  OSSP platform - Platform Identification
d387 4
a390 1
           x86_64 ) AT='AMD64' ;;
d519 1
a519 1
        SC="4.2BSD${opt_C}SVR3"
d551 1
a551 1
        ST="[HP ]HP-UX ${v}"
d603 1
a603 1
        SC="4.4BSD${opt_C}Mach3"
@


1.14
log
@remove trailing blanks
@
text
@d461 1
a461 1
               -e 's;^5\.\([0-6]\).*;2.\1;' \
@


1.13
log
@- Recognize AMD64 architecture under Linux
- correctly recognize SuSE version through "VERSION = xxx" in /etc/SuSE-config
- add Apple MacOS X Darwin detection support
- provide more robust detection for unknown platforms
@
text
@d234 1
a234 1
            opt_F="%<ap>-%<sp>"
d445 1
a445 1
            i86pc ) AT="iX86" ;; 
d475 1
a475 1
            i[3-6]86 | ix86at ) AT="iX86" ;; 
d490 1
a490 1
            x86pc ) AT="iX86" ;; 
d507 2
a508 2
            IP*:IRIX64 ) AP="MIPS64" ;; 
            IP*:*      ) AP="MIPS"   ;; 
d526 1
a526 1
            9000/[678][0-9][0-9]) 
@


1.12
log
@add blind IBM AIX support; add platforms to manual page; cleanup and fix system classes
@
text
@d386 3
d415 1
a415 1
                v=`cat /etc/${tagfile} | grep '[0-9]' | head -1 |\
d587 16
d610 1
a610 1
        AT="${UNAME_MACHINE}"
d613 7
a619 1
        ST="${UNAME_SYSTEM} ${UNAME_RELEASE}"
@


1.11
log
@add NetBSD, OpenBSD, HP HP-UX and HP Tru64 support
@
text
@d347 2
a348 2
    #   OpenBSD
    *:OpenBSD:* )
d358 1
a358 1
        ST="OpenBSD ${r}"
d360 4
a363 1
        SC="4.4BSD"
d366 2
a367 2
    #   NetBSD
    *:NetBSD:* )
d377 1
a377 1
        ST="NetBSD ${r}"
d462 1
a462 1
            4.* ) SC="4.2BSD" ;;
d513 1
a513 1
        SC="BSD"
d547 4
a550 1
        SC="BSD"
d568 14
a581 1
        SC="BSD"
@


1.10
log
@add SCO UnixWare, QNX Neutrino RTOS and SGI IRIX support
@
text
@d347 32
d510 52
@


1.9
log
@add more knowledge about particular major Linux distros
@
text
@d432 48
@


1.8
log
@RedHat's (optional) lsb-release file contains only LSB_VERSION, so make sure we do not set SP to a whitespace, which in turn would disable later checks
@
text
@d384 9
a392 6
                    debian   ) n="Debian[ GNU/Linux]" ;;
                    redhat   ) n="RedHat[ Linux]"     ;;
                    suse     ) n="SuSE[ Linux]"       ;;
                    mandrake ) n="Mandrake[ Linux]"   ;;
                    gentoo   ) n="Gentoo[ Linux]"     ;;
                    *        ) n="${n}[ GNU/Linux]"   ;;
@


1.7
log
@improve and bugfix Linux detection
@
text
@d365 3
a367 1
                echo "SP=\"${DISTRIB_ID} ${DISTRIB_RELEASE}\""
@


1.6
log
@FreeBSD output just Xeon sometimes
@
text
@d360 1
a360 1
            sort -n | tail -1 | sed -e 's/^\([0-9][0-9]*\.[0-9][0-9]*\).*/\1/') 2>&1`
d364 2
a365 2
              echo "SC=\"LSB${LSB_VERSION}\""
              echo "SP=\"${DISTRIB_ID} ${DISTRIB_RELEASE}\""
d369 5
a373 2
            for tagfile in dummy `cd /etc && echo *[_-]release *[_-]version 2>/dev/null`; do
                test ! -f /etc/${tagfile} && continue
d385 1
a385 1
                    mandrake ) n="Mandrake[ Linux}"   ;;
d390 1
d525 1
a525 1
            -e "s;%\[ac\];${AC_V};g" \
d529 1
a529 1
            -e "s;%\[ap\];${AP_V};g" \
d533 1
a533 1
            -e "s;%\[at\];${AT_V};g" \
d537 1
a537 1
            -e "s;%\[sc\];${SC_V};g" \
d541 1
a541 1
            -e "s;%\[sp\];${SP_V};g" \
d545 1
a545 1
            -e "s;%\[st\];${ST_V};g" \
@


1.5
log
@fix consise output generation and ommit the GNU part in GNU/Linux under consise output
@
text
@d331 1
a331 1
            *"Pentium Pro"* | *"Cyrix 6x86MX"* | *"Pentium II"* | *"Pentium III"* | *"Pentium 4"* | *"Celeron"* ) AT="i686" ;;
@


1.4
log
@better LSB support for Linux boxes (especially important for SuSE)
@
text
@d361 1
a361 1
        ST="GNU/Linux ${v_libc}/${v_kern}"
d480 1
a480 1
                           -e 's;<\([^>]*\)>;\1;' \
d493 1
a493 1
                           -e 's;<\([^>]*\)>;\1;' \
d506 1
a506 1
                           -e 's;[^<]*<\([^>]*\)>;\1;' \
@


1.3
log
@finish mostly all (initial ;-) features of this program and the corresponding documentation
@
text
@d362 27
a388 19
        for tagfile in dummy `cd /etc && echo *[_-]release *[_-]version 2>/dev/null`; do
            test ! -f /etc/${tagfile} && continue
            n=`echo ${tagfile} | sed -e 's/[_-]release$//' -e 's/[_-]version$//'`
            v=`cat /etc/${tagfile} | grep '[0-9]' | head -1 |\
               sed -e 's/^/#/' \
                   -e 's/^#[^0-9]*\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\).*$/\1/' \
                   -e 's/^#[^0-9]*\([0-9][0-9]*\.[0-9][0-9]*\).*$/\1/' \
                   -e 's/^#[^0-9]*\([0-9][0-9]*\).*$/\1/' \
                   -e 's/^#.*$//'`
            case "`util_lower ${n}`" in
                debian   ) n="Debian[ GNU/Linux]" ;;
                redhat   ) n="RedHat[ Linux}"     ;;
                suse     ) n="SuSE[ Linux]"       ;;
                mandrake ) n="Mandrake[ Linux}"   ;;
                gentoo   ) n="Gentoo[ Linux]"     ;;
                *        ) n="${n}[ GNU/Linux]"   ;;
            esac
            SP="$n $v"
        done
d390 1
a390 1
        SC="LSB"
@


1.2
log
@fix --upper option
@
text
@d28 1
a28 1
prog_run="${prog_run}"
a46 1
str_usage="$str_usage [-T|--type TYPE]"
d49 2
a50 1
str_usage="$str_usage [-n|--newline]"
d55 3
a57 3
opt_spec="F:S:C:L.U.T:v.c.n.d.V.h."
opt_alias="F:format,S:sep,C:conc,L:lower,U:upper,T:type,v:verbose,c:consise,n:newline,d:debug,V:version,h:help"
opt_F="Class:      %sc (%ac)\\nProduct:    %sp (%ap)\\nTechnology: %st (%at)"
d62 1
a62 1
opt_T=""
d71 1
a71 1
ASC_TAB="   "
d205 70
d472 5
a476 1
                           -e 's;<\([^>]*\)>;\1;'`
d485 5
a489 1
                           -e 's;<\([^>]*\)>;\1;'`
d498 5
a502 1
                           -e 's;[^<]*<\([^>]*\)>;\1;'`
a545 6

#   support particular separator and concatenator strings
output=`echo ":$output" |
        sed -e 's/^://' \
            -e "s; ;${opt_S};g" \
            -e "s;/;${opt_C};g"`
@


1.1
log
@initial OSSP platform (FreeBSD, Linux and Solaris support only)
@
text
@d46 1
a46 1
str_usage="$str_usage [-U|--lower]"
d56 1
a56 1
opt_alias="F:format,S:sep,C:conc,L:lower,T:type,v:verbose,c:consise,n:newline,d:debug,V:version,h:help"
@