Index: build-aux/config.guess ================================================================== --- build-aux/config.guess +++ build-aux/config.guess @@ -1,10 +1,10 @@ #! /bin/sh # Attempt to guess a canonical system name. -# Copyright 1992-2018 Free Software Foundation, Inc. +# Copyright 1992-2019 Free Software Foundation, Inc. -timestamp='2018-03-08' +timestamp='2019-01-03' # This file 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 3 of the License, or # (at your option) any later version. @@ -48,11 +48,11 @@ version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. -Copyright 1992-2018 Free Software Foundation, Inc. +Copyright 1992-2019 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" @@ -82,12 +82,10 @@ if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi -trap 'exit 1' 1 2 15 - # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. @@ -94,38 +92,42 @@ # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. -set_cc_for_build=' -trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; -trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; -: ${TMPDIR=/tmp} ; - { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || - { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || - { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || - { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; -dummy=$tmp/dummy ; -tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; -case $CC_FOR_BUILD,$HOST_CC,$CC in - ,,) echo "int x;" > "$dummy.c" ; - for c in cc gcc c89 c99 ; do - if ($c -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then - CC_FOR_BUILD="$c"; break ; - fi ; - done ; - if test x"$CC_FOR_BUILD" = x ; then - CC_FOR_BUILD=no_compiler_found ; - fi - ;; - ,,*) CC_FOR_BUILD=$CC ;; - ,*,*) CC_FOR_BUILD=$HOST_CC ;; -esac ; set_cc_for_build= ;' +tmp= +# shellcheck disable=SC2172 +trap 'test -z "$tmp" || rm -fr "$tmp"' 0 1 2 13 15 + +set_cc_for_build() { + : "${TMPDIR=/tmp}" + # shellcheck disable=SC2039 + { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || + { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } || + { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } || + { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } + dummy=$tmp/dummy + case ${CC_FOR_BUILD-},${HOST_CC-},${CC-} in + ,,) echo "int x;" > "$dummy.c" + for driver in cc gcc c89 c99 ; do + if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then + CC_FOR_BUILD="$driver" + break + fi + done + if test x"$CC_FOR_BUILD" = x ; then + CC_FOR_BUILD=no_compiler_found + fi + ;; + ,,*) CC_FOR_BUILD=$CC ;; + ,*,*) CC_FOR_BUILD=$HOST_CC ;; + esac +} # 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) >/dev/null 2>&1 ; then +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 @@ -136,11 +138,11 @@ Linux|GNU|GNU/*) # If the system lacks a compiler, then just pick glibc. # We could probably try harder. LIBC=gnu - eval "$set_cc_for_build" + set_cc_for_build cat <<-EOF > "$dummy.c" #include #if defined(__UCLIBC__) LIBC=uclibc #elif defined(__dietlibc__) @@ -178,17 +180,20 @@ UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \ "/sbin/$sysctl" 2>/dev/null || \ "/usr/sbin/$sysctl" 2>/dev/null || \ echo unknown)` case "$UNAME_MACHINE_ARCH" in + aarch64eb) machine=aarch64_be-unknown ;; armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; sh5el) machine=sh5le-unknown ;; - earmv*) - arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'` + earm*) + arch="${UNAME_MACHINE_ARCH#e}" + arch="${arch%eb}" + arch="${arch%hf}" endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'` machine="${arch}${endian}"-unknown ;; *) machine="$UNAME_MACHINE_ARCH"-unknown ;; esac @@ -197,11 +202,11 @@ case "$UNAME_MACHINE_ARCH" in earm*) os=netbsdelf ;; arm*|i386|m68k|ns32k|sh3*|sparc|vax) - eval "$set_cc_for_build" + set_cc_for_build if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ELF__ then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? @@ -215,11 +220,11 @@ ;; esac # Determine ABI tags. case "$UNAME_MACHINE_ARCH" in earm*) - expr='s/^earmv[0-9]/-eabi/;s/eb$//' + expr='s/v[0-9]//;s/earm/-eabi/;s/eb$//' abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"` ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and @@ -235,11 +240,11 @@ ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. - echo "$machine-${os}${release}${abi}" + echo "$machine-${os}${release}${abi-}" exit ;; *:Bitrig:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE" exit ;; @@ -381,17 +386,30 @@ exit ;; sun4H:SunOS:5.*:*) echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" exit ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) - echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`" + set_cc_for_build + SUN_ARCH=sparc + # If there is a compiler, see if it is configured for 64-bit objects. + # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. + # This test works for both compilers. + if [ "$CC_FOR_BUILD" != no_compiler_found ]; then + if (echo '#ifdef __sparcv9'; echo IS_64BIT_ARCH; echo '#endif') | \ + (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_64BIT_ARCH >/dev/null + then + SUN_ARCH=sparcv9 + fi + fi + echo "$SUN_ARCH"-sun-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" exit ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) echo i386-pc-auroraux"$UNAME_RELEASE" exit ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) - eval "$set_cc_for_build" + set_cc_for_build SUN_ARCH=i386 # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if [ "$CC_FOR_BUILD" != no_compiler_found ]; then @@ -480,11 +498,11 @@ exit ;; 2020:CLIX:*:* | 2430:CLIX:*:*) echo clipper-intergraph-clix"$UNAME_RELEASE" exit ;; mips:*:*:UMIPS | mips:*:*:RISCos) - eval "$set_cc_for_build" + set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else @@ -577,11 +595,11 @@ fi echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV" exit ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then - eval "$set_cc_for_build" + set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #include main() { @@ -658,11 +676,11 @@ '') HP_ARCH=hppa2.0 ;; # HP-UX 10.20 esac ;; esac fi if [ "$HP_ARCH" = "" ]; then - eval "$set_cc_for_build" + set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #define _HPUX_SOURCE #include #include @@ -698,11 +716,11 @@ test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if [ "$HP_ARCH" = hppa2.0w ] then - eval "$set_cc_for_build" + set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # @@ -724,11 +742,11 @@ ia64:HP-UX:*:*) HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'` echo ia64-hp-hpux"$HPUX_REV" exit ;; 3050*:HI-UX:*:*) - eval "$set_cc_for_build" + set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #include int main () { @@ -837,10 +855,21 @@ sparc*:BSD/OS:*:*) echo sparc-unknown-bsdi"$UNAME_RELEASE" exit ;; *:BSD/OS:*:*) echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE" + exit ;; + arm:FreeBSD:*:*) + UNAME_PROCESSOR=`uname -p` + set_cc_for_build + if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ + | grep -q __ARM_PCS_VFP + then + echo "${UNAME_PROCESSOR}"-unknown-freebsd"`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`"-gnueabi + else + echo "${UNAME_PROCESSOR}"-unknown-freebsd"`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`"-gnueabihf + fi exit ;; *:FreeBSD:*:*) UNAME_PROCESSOR=`/usr/bin/uname -p` case "$UNAME_PROCESSOR" in amd64) @@ -879,11 +908,11 @@ esac ;; i*:UWIN*:*) echo "$UNAME_MACHINE"-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) - echo x86_64-unknown-cygwin + echo x86_64-pc-cygwin exit ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" exit ;; *:GNU:*:*) @@ -892,12 +921,12 @@ exit ;; *:GNU/*:*:*) # other systems with GNU libc and userland echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`-$LIBC" exit ;; - i*86:Minix:*:*) - echo "$UNAME_MACHINE"-pc-minix + *:Minix:*:*) + echo "$UNAME_MACHINE"-unknown-minix exit ;; aarch64:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; aarch64_be:Linux:*:*) @@ -920,11 +949,11 @@ exit ;; arc:Linux:*:* | arceb:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; arm*:Linux:*:*) - eval "$set_cc_for_build" + set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" else @@ -969,11 +998,11 @@ exit ;; m68*:Linux:*:*) echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" exit ;; mips:Linux:*:* | mips64:Linux:*:*) - eval "$set_cc_for_build" + set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" #undef CPU #undef ${UNAME_MACHINE} #undef ${UNAME_MACHINE}el #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) @@ -1283,11 +1312,11 @@ *:Rhapsody:*:*) echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE" exit ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown - eval "$set_cc_for_build" + set_cc_for_build if test "$UNAME_PROCESSOR" = unknown ; then UNAME_PROCESSOR=powerpc fi if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then if [ "$CC_FOR_BUILD" != no_compiler_found ]; then @@ -1356,10 +1385,11 @@ exit ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. + # shellcheck disable=SC2154 if test "$cputype" = 386; then UNAME_MACHINE=i386 else UNAME_MACHINE="$cputype" fi @@ -1412,10 +1442,13 @@ echo "$UNAME_MACHINE"-unknown-esx exit ;; amd64:Isilon\ OneFS:*:*) echo x86_64-unknown-onefs exit ;; + *:Unleashed:*:*) + echo "$UNAME_MACHINE"-unknown-unleashed"$UNAME_RELEASE" + exit ;; esac echo "$0: unable to guess system type" >&2 case "$UNAME_MACHINE:$UNAME_SYSTEM" in Index: build-aux/config.sub ================================================================== --- build-aux/config.sub +++ build-aux/config.sub @@ -1,10 +1,10 @@ #! /bin/sh # Configuration validation subroutine script. -# Copyright 1992-2018 Free Software Foundation, Inc. +# Copyright 1992-2019 Free Software Foundation, Inc. -timestamp='2018-03-08' +timestamp='2019-01-05' # This file 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 3 of the License, or # (at your option) any later version. @@ -65,11 +65,11 @@ Report bugs and patches to ." version="\ GNU config.sub ($timestamp) -Copyright 1992-2018 Free Software Foundation, Inc. +Copyright 1992-2019 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" @@ -87,11 +87,11 @@ -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) - echo "$me: invalid option $1$help" + echo "$me: invalid option $1$help" >&2 exit 1 ;; *local*) # First pass through any local machine types. echo "$1" @@ -108,1431 +108,1418 @@ 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac -# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). -# Here we must recognize all the valid KERNEL-OS combinations. -maybe_os=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` -case $maybe_os in - nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ - linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ - knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \ - kopensolaris*-gnu* | cloudabi*-eabi* | \ - storm-chaos* | os2-emx* | rtmk-nova*) - os=-$maybe_os - basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` - ;; - android-linux) - os=-linux-android - basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown - ;; - *) - basic_machine=`echo "$1" | sed 's/-[^-]*$//'` - if [ "$basic_machine" != "$1" ] - then os=`echo "$1" | sed 's/.*-/-/'` - else os=; fi - ;; -esac - -### Let's recognize common machines as not being operating systems so -### that things like config.sub decstation-3100 work. We also -### recognize some manufacturers as not being operating systems, so we -### can provide default operating systems below. -case $os in - -sun*os*) - # Prevent following clause from handling this invalid input. - ;; - -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ - -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ - -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ - -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ - -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ - -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ - -apple | -axis | -knuth | -cray | -microblaze*) - os= - basic_machine=$1 - ;; - -bluegene*) - os=-cnk - ;; - -sim | -cisco | -oki | -wec | -winbond) - os= - basic_machine=$1 - ;; - -scout) - ;; - -wrs) - os=-vxworks - basic_machine=$1 - ;; - -chorusos*) - os=-chorusos - basic_machine=$1 - ;; - -chorusrdb) - os=-chorusrdb - basic_machine=$1 - ;; - -hiux*) - os=-hiuxwe2 - ;; - -sco6) - os=-sco5v6 - basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` - ;; - -sco5) - os=-sco3.2v5 - basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` - ;; - -sco4) - os=-sco3.2v4 - basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` - ;; - -sco3.2.[4-9]*) - os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` - basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` - ;; - -sco3.2v[4-9]*) - # Don't forget version if it is 3.2v4 or newer. - basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` - ;; - -sco5v6*) - # Don't forget version if it is 3.2v4 or newer. - basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` - ;; - -sco*) - os=-sco3.2v2 - basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` - ;; - -udk*) - basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` - ;; - -isc) - os=-isc2.2 - basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` - ;; - -clix*) - basic_machine=clipper-intergraph - ;; - -isc*) - basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` - ;; - -lynx*178) - os=-lynxos178 - ;; - -lynx*5) - os=-lynxos5 - ;; - -lynx*) - os=-lynxos - ;; - -ptx*) - basic_machine=`echo "$1" | sed -e 's/86-.*/86-sequent/'` - ;; - -psos*) - os=-psos - ;; - -mint | -mint[0-9]*) - basic_machine=m68k-atari - os=-mint - ;; -esac - -# Decode aliases for certain CPU-COMPANY combinations. +# Split fields of configuration type +# shellcheck disable=SC2162 +IFS="-" read field1 field2 field3 field4 <&2 + exit 1 + ;; + *-*-*-*) + basic_machine=$field1-$field2 + os=$field3-$field4 + ;; + *-*-*) + # Ambiguous whether COMPANY is present, or skipped and KERNEL-OS is two + # parts + maybe_os=$field2-$field3 + case $maybe_os in + nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc \ + | linux-newlib* | linux-musl* | linux-uclibc* | uclinux-uclibc* \ + | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* \ + | netbsd*-eabi* | kopensolaris*-gnu* | cloudabi*-eabi* \ + | storm-chaos* | os2-emx* | rtmk-nova*) + basic_machine=$field1 + os=$maybe_os + ;; + android-linux) + basic_machine=$field1-unknown + os=linux-android + ;; + *) + basic_machine=$field1-$field2 + os=$field3 + ;; + esac + ;; + *-*) + # A lone config we happen to match not fitting any pattern + case $field1-$field2 in + decstation-3100) + basic_machine=mips-dec + os= + ;; + *-*) + # Second component is usually, but not always the OS + case $field2 in + # Prevent following clause from handling this valid os + sun*os*) + basic_machine=$field1 + os=$field2 + ;; + # Manufacturers + dec* | mips* | sequent* | encore* | pc533* | sgi* | sony* \ + | att* | 7300* | 3300* | delta* | motorola* | sun[234]* \ + | unicom* | ibm* | next | hp | isi* | apollo | altos* \ + | convergent* | ncr* | news | 32* | 3600* | 3100* \ + | hitachi* | c[123]* | convex* | sun | crds | omron* | dg \ + | ultra | tti* | harris | dolphin | highlevel | gould \ + | cbm | ns | masscomp | apple | axis | knuth | cray \ + | microblaze* | sim | cisco \ + | oki | wec | wrs | winbond) + basic_machine=$field1-$field2 + os= + ;; + *) + basic_machine=$field1 + os=$field2 + ;; + esac + ;; + esac + ;; + *) + # Convert single-component short-hands not valid as part of + # multi-component configurations. + case $field1 in + 386bsd) + basic_machine=i386-pc + os=bsd + ;; + a29khif) + basic_machine=a29k-amd + os=udi + ;; + adobe68k) + basic_machine=m68010-adobe + os=scout + ;; + alliant) + basic_machine=fx80-alliant + os= + ;; + altos | altos3068) + basic_machine=m68k-altos + os= + ;; + am29k) + basic_machine=a29k-none + os=bsd + ;; + amdahl) + basic_machine=580-amdahl + os=sysv + ;; + amiga) + basic_machine=m68k-unknown + os= + ;; + amigaos | amigados) + basic_machine=m68k-unknown + os=amigaos + ;; + amigaunix | amix) + basic_machine=m68k-unknown + os=sysv4 + ;; + apollo68) + basic_machine=m68k-apollo + os=sysv + ;; + apollo68bsd) + basic_machine=m68k-apollo + os=bsd + ;; + aros) + basic_machine=i386-pc + os=aros + ;; + aux) + basic_machine=m68k-apple + os=aux + ;; + balance) + basic_machine=ns32k-sequent + os=dynix + ;; + blackfin) + basic_machine=bfin-unknown + os=linux + ;; + cegcc) + basic_machine=arm-unknown + os=cegcc + ;; + convex-c1) + basic_machine=c1-convex + os=bsd + ;; + convex-c2) + basic_machine=c2-convex + os=bsd + ;; + convex-c32) + basic_machine=c32-convex + os=bsd + ;; + convex-c34) + basic_machine=c34-convex + os=bsd + ;; + convex-c38) + basic_machine=c38-convex + os=bsd + ;; + cray) + basic_machine=j90-cray + os=unicos + ;; + crds | unos) + basic_machine=m68k-crds + os= + ;; + da30) + basic_machine=m68k-da30 + os= + ;; + decstation | pmax | pmin | dec3100 | decstatn) + basic_machine=mips-dec + os= + ;; + delta88) + basic_machine=m88k-motorola + os=sysv3 + ;; + dicos) + basic_machine=i686-pc + os=dicos + ;; + djgpp) + basic_machine=i586-pc + os=msdosdjgpp + ;; + ebmon29k) + basic_machine=a29k-amd + os=ebmon + ;; + es1800 | OSE68k | ose68k | ose | OSE) + basic_machine=m68k-ericsson + os=ose + ;; + gmicro) + basic_machine=tron-gmicro + os=sysv + ;; + go32) + basic_machine=i386-pc + os=go32 + ;; + h8300hms) + basic_machine=h8300-hitachi + os=hms + ;; + h8300xray) + basic_machine=h8300-hitachi + os=xray + ;; + h8500hms) + basic_machine=h8500-hitachi + os=hms + ;; + harris) + basic_machine=m88k-harris + os=sysv3 + ;; + hp300) + basic_machine=m68k-hp + ;; + hp300bsd) + basic_machine=m68k-hp + os=bsd + ;; + hp300hpux) + basic_machine=m68k-hp + os=hpux + ;; + hppaosf) + basic_machine=hppa1.1-hp + os=osf + ;; + hppro) + basic_machine=hppa1.1-hp + os=proelf + ;; + i386mach) + basic_machine=i386-mach + os=mach + ;; + vsta) + basic_machine=i386-pc + os=vsta + ;; + isi68 | isi) + basic_machine=m68k-isi + os=sysv + ;; + m68knommu) + basic_machine=m68k-unknown + os=linux + ;; + magnum | m3230) + basic_machine=mips-mips + os=sysv + ;; + merlin) + basic_machine=ns32k-utek + os=sysv + ;; + mingw64) + basic_machine=x86_64-pc + os=mingw64 + ;; + mingw32) + basic_machine=i686-pc + os=mingw32 + ;; + mingw32ce) + basic_machine=arm-unknown + os=mingw32ce + ;; + monitor) + basic_machine=m68k-rom68k + os=coff + ;; + morphos) + basic_machine=powerpc-unknown + os=morphos + ;; + moxiebox) + basic_machine=moxie-unknown + os=moxiebox + ;; + msdos) + basic_machine=i386-pc + os=msdos + ;; + msys) + basic_machine=i686-pc + os=msys + ;; + mvs) + basic_machine=i370-ibm + os=mvs + ;; + nacl) + basic_machine=le32-unknown + os=nacl + ;; + ncr3000) + basic_machine=i486-ncr + os=sysv4 + ;; + netbsd386) + basic_machine=i386-pc + os=netbsd + ;; + netwinder) + basic_machine=armv4l-rebel + os=linux + ;; + news | news700 | news800 | news900) + basic_machine=m68k-sony + os=newsos + ;; + news1000) + basic_machine=m68030-sony + os=newsos + ;; + necv70) + basic_machine=v70-nec + os=sysv + ;; + nh3000) + basic_machine=m68k-harris + os=cxux + ;; + nh[45]000) + basic_machine=m88k-harris + os=cxux + ;; + nindy960) + basic_machine=i960-intel + os=nindy + ;; + mon960) + basic_machine=i960-intel + os=mon960 + ;; + nonstopux) + basic_machine=mips-compaq + os=nonstopux + ;; + os400) + basic_machine=powerpc-ibm + os=os400 + ;; + OSE68000 | ose68000) + basic_machine=m68000-ericsson + os=ose + ;; + os68k) + basic_machine=m68k-none + os=os68k + ;; + paragon) + basic_machine=i860-intel + os=osf + ;; + parisc) + basic_machine=hppa-unknown + os=linux + ;; + pw32) + basic_machine=i586-unknown + os=pw32 + ;; + rdos | rdos64) + basic_machine=x86_64-pc + os=rdos + ;; + rdos32) + basic_machine=i386-pc + os=rdos + ;; + rom68k) + basic_machine=m68k-rom68k + os=coff + ;; + sa29200) + basic_machine=a29k-amd + os=udi + ;; + sei) + basic_machine=mips-sei + os=seiux + ;; + sequent) + basic_machine=i386-sequent + os= + ;; + sps7) + basic_machine=m68k-bull + os=sysv2 + ;; + st2000) + basic_machine=m68k-tandem + os= + ;; + stratus) + basic_machine=i860-stratus + os=sysv4 + ;; + sun2) + basic_machine=m68000-sun + os= + ;; + sun2os3) + basic_machine=m68000-sun + os=sunos3 + ;; + sun2os4) + basic_machine=m68000-sun + os=sunos4 + ;; + sun3) + basic_machine=m68k-sun + os= + ;; + sun3os3) + basic_machine=m68k-sun + os=sunos3 + ;; + sun3os4) + basic_machine=m68k-sun + os=sunos4 + ;; + sun4) + basic_machine=sparc-sun + os= + ;; + sun4os3) + basic_machine=sparc-sun + os=sunos3 + ;; + sun4os4) + basic_machine=sparc-sun + os=sunos4 + ;; + sun4sol2) + basic_machine=sparc-sun + os=solaris2 + ;; + sun386 | sun386i | roadrunner) + basic_machine=i386-sun + os= + ;; + sv1) + basic_machine=sv1-cray + os=unicos + ;; + symmetry) + basic_machine=i386-sequent + os=dynix + ;; + t3e) + basic_machine=alphaev5-cray + os=unicos + ;; + t90) + basic_machine=t90-cray + os=unicos + ;; + toad1) + basic_machine=pdp10-xkl + os=tops20 + ;; + tpf) + basic_machine=s390x-ibm + os=tpf + ;; + udi29k) + basic_machine=a29k-amd + os=udi + ;; + ultra3) + basic_machine=a29k-nyu + os=sym1 + ;; + v810 | necv810) + basic_machine=v810-nec + os=none + ;; + vaxv) + basic_machine=vax-dec + os=sysv + ;; + vms) + basic_machine=vax-dec + os=vms + ;; + vxworks960) + basic_machine=i960-wrs + os=vxworks + ;; + vxworks68) + basic_machine=m68k-wrs + os=vxworks + ;; + vxworks29k) + basic_machine=a29k-wrs + os=vxworks + ;; + xbox) + basic_machine=i686-pc + os=mingw32 + ;; + ymp) + basic_machine=ymp-cray + os=unicos + ;; + *) + basic_machine=$1 + os= + ;; + esac + ;; +esac + +# Decode 1-component or ad-hoc basic machines case $basic_machine in - # Recognize the basic CPU types without company name. - # Some are omitted here because they have special meanings below. - 1750a | 580 \ - | a29k \ - | aarch64 | aarch64_be | arm64 \ - | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ - | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ - | am33_2.0 \ - | arc | arceb \ - | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \ - | avr | avr32 \ - | ba \ - | be32 | be64 \ - | bfin \ - | c4x | c8051 | clipper \ - | d10v | d30v | dlx | dsp16xx \ - | e2k | epiphany \ - | fido | fr30 | frv | ft32 \ - | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ - | hexagon \ - | i370 | i860 | i960 | ia16 | ia64 \ - | ip2k | iq2000 \ - | k1om \ - | le32 | le64 \ - | lm32 \ - | m32c | m32r | m32rle | m68000 | m68k | m88k \ - | maxq | mb | microblaze | microblazeel | mcore | mep | metag \ - | mips | mipsbe | mipseb | mipsel | mipsle \ - | mips16 \ - | mips64 | mips64el \ - | mips64octeon | mips64octeonel \ - | mips64orion | mips64orionel \ - | mips64r5900 | mips64r5900el \ - | mips64vr | mips64vrel \ - | mips64vr4100 | mips64vr4100el \ - | mips64vr4300 | mips64vr4300el \ - | mips64vr5000 | mips64vr5000el \ - | mips64vr5900 | mips64vr5900el \ - | mipsisa32 | mipsisa32el \ - | mipsisa32r2 | mipsisa32r2el \ - | mipsisa32r6 | mipsisa32r6el \ - | mipsisa64 | mipsisa64el \ - | mipsisa64r2 | mipsisa64r2el \ - | mipsisa64r6 | mipsisa64r6el \ - | mipsisa64sb1 | mipsisa64sb1el \ - | mipsisa64sr71k | mipsisa64sr71kel \ - | mipsr5900 | mipsr5900el \ - | mipstx39 | mipstx39el \ - | mn10200 | mn10300 \ - | moxie \ - | mt \ - | msp430 \ - | nds32 | nds32le | nds32be \ - | nios | nios2 | nios2eb | nios2el \ - | ns16k | ns32k \ - | open8 | or1k | or1knd | or32 \ - | pdp10 | pj | pjl \ - | powerpc | powerpc64 | powerpc64le | powerpcle \ - | pru \ - | pyramid \ - | riscv32 | riscv64 \ - | rl78 | rx \ - | score \ - | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ - | sh64 | sh64le \ - | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ - | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ - | spu \ - | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ - | ubicom32 \ - | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \ - | visium \ - | wasm32 \ - | x86 | xc16x | xstormy16 | xtensa \ - | z8k | z80) - basic_machine=$basic_machine-unknown - ;; - c54x) - basic_machine=tic54x-unknown - ;; - c55x) - basic_machine=tic55x-unknown - ;; - c6x) - basic_machine=tic6x-unknown + # Here we handle the default manufacturer of certain CPU types. It is in + # some cases the only manufacturer, in others, it is the most popular. + w89k) + cpu=hppa1.1 + vendor=winbond + ;; + op50n) + cpu=hppa1.1 + vendor=oki + ;; + op60c) + cpu=hppa1.1 + vendor=oki + ;; + ibm*) + cpu=i370 + vendor=ibm + ;; + orion105) + cpu=clipper + vendor=highlevel + ;; + mac | mpw | mac-mpw) + cpu=m68k + vendor=apple + ;; + pmac | pmac-mpw) + cpu=powerpc + vendor=apple + ;; + + # Recognize the various machine names and aliases which stand + # for a CPU type and a company and sometimes even an OS. + 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) + cpu=m68000 + vendor=att + ;; + 3b*) + cpu=we32k + vendor=att + ;; + bluegene*) + cpu=powerpc + vendor=ibm + os=cnk + ;; + decsystem10* | dec10*) + cpu=pdp10 + vendor=dec + os=tops10 + ;; + decsystem20* | dec20*) + cpu=pdp10 + vendor=dec + os=tops20 + ;; + delta | 3300 | motorola-3300 | motorola-delta \ + | 3300-motorola | delta-motorola) + cpu=m68k + vendor=motorola + ;; + dpx2*) + cpu=m68k + vendor=bull + os=sysv3 + ;; + encore | umax | mmax) + cpu=ns32k + vendor=encore + ;; + elxsi) + cpu=elxsi + vendor=elxsi + os=${os:-bsd} + ;; + fx2800) + cpu=i860 + vendor=alliant + ;; + genix) + cpu=ns32k + vendor=ns + ;; + h3050r* | hiux*) + cpu=hppa1.1 + vendor=hitachi + os=hiuxwe2 + ;; + hp3k9[0-9][0-9] | hp9[0-9][0-9]) + cpu=hppa1.0 + vendor=hp + ;; + hp9k2[0-9][0-9] | hp9k31[0-9]) + cpu=m68000 + vendor=hp + ;; + hp9k3[2-9][0-9]) + cpu=m68k + vendor=hp + ;; + hp9k6[0-9][0-9] | hp6[0-9][0-9]) + cpu=hppa1.0 + vendor=hp + ;; + hp9k7[0-79][0-9] | hp7[0-79][0-9]) + cpu=hppa1.1 + vendor=hp + ;; + hp9k78[0-9] | hp78[0-9]) + # FIXME: really hppa2.0-hp + cpu=hppa1.1 + vendor=hp + ;; + hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) + # FIXME: really hppa2.0-hp + cpu=hppa1.1 + vendor=hp + ;; + hp9k8[0-9][13679] | hp8[0-9][13679]) + cpu=hppa1.1 + vendor=hp + ;; + hp9k8[0-9][0-9] | hp8[0-9][0-9]) + cpu=hppa1.0 + vendor=hp + ;; + i*86v32) + cpu=`echo "$1" | sed -e 's/86.*/86/'` + vendor=pc + os=sysv32 + ;; + i*86v4*) + cpu=`echo "$1" | sed -e 's/86.*/86/'` + vendor=pc + os=sysv4 + ;; + i*86v) + cpu=`echo "$1" | sed -e 's/86.*/86/'` + vendor=pc + os=sysv + ;; + i*86sol2) + cpu=`echo "$1" | sed -e 's/86.*/86/'` + vendor=pc + os=solaris2 + ;; + j90 | j90-cray) + cpu=j90 + vendor=cray + os=${os:-unicos} + ;; + iris | iris4d) + cpu=mips + vendor=sgi + case $os in + irix*) + ;; + *) + os=irix4 + ;; + esac + ;; + miniframe) + cpu=m68000 + vendor=convergent + ;; + *mint | mint[0-9]* | *MiNT | *MiNT[0-9]*) + cpu=m68k + vendor=atari + os=mint + ;; + news-3600 | risc-news) + cpu=mips + vendor=sony + os=newsos + ;; + next | m*-next) + cpu=m68k + vendor=next + case $os in + nextstep* ) + ;; + ns2*) + os=nextstep2 + ;; + *) + os=nextstep3 + ;; + esac + ;; + np1) + cpu=np1 + vendor=gould + ;; + op50n-* | op60c-*) + cpu=hppa1.1 + vendor=oki + os=proelf + ;; + pa-hitachi) + cpu=hppa1.1 + vendor=hitachi + os=hiuxwe2 + ;; + pbd) + cpu=sparc + vendor=tti + ;; + pbb) + cpu=m68k + vendor=tti + ;; + pc532) + cpu=ns32k + vendor=pc532 + ;; + pn) + cpu=pn + vendor=gould + ;; + power) + cpu=power + vendor=ibm + ;; + ps2) + cpu=i386 + vendor=ibm + ;; + psp) + cpu=mipsallegrexel + vendor=psp + ;; + rm[46]00) + cpu=mips + vendor=siemens + ;; + rtpc | rtpc-*) + cpu=romp + vendor=ibm + ;; + sde) + cpu=mipsisa32 + vendor=sde + os=${os:-elf} + ;; + simso-wrs) + cpu=sparclite + vendor=wrs + os=vxworks + ;; + tower | tower-32) + cpu=m68k + vendor=ncr + ;; + vpp*|vx|vx-*) + cpu=f301 + vendor=fujitsu + ;; + w65) + cpu=w65 + vendor=wdc + ;; + w89k-*) + cpu=hppa1.1 + vendor=winbond + os=proelf + ;; + none) + cpu=none + vendor=none ;; leon|leon[3-9]) - basic_machine=sparc-$basic_machine - ;; - m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip) - basic_machine=$basic_machine-unknown - os=-none - ;; - m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65) - ;; - ms1) - basic_machine=mt-unknown - ;; - - strongarm | thumb | xscale) - basic_machine=arm-unknown - ;; - xgate) - basic_machine=$basic_machine-unknown - os=-none - ;; - xscaleeb) - basic_machine=armeb-unknown - ;; - - xscaleel) - basic_machine=armel-unknown - ;; - + cpu=sparc + vendor=$basic_machine + ;; + leon-*|leon[3-9]-*) + cpu=sparc + vendor=`echo "$basic_machine" | sed 's/-.*//'` + ;; + + *-*) + # shellcheck disable=SC2162 + IFS="-" read cpu vendor <&2 - exit 1 - ;; - # Recognize the basic CPU types with company name. - 580-* \ - | a29k-* \ - | aarch64-* | aarch64_be-* | arm64-* \ - | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ - | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ - | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \ - | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ - | avr-* | avr32-* \ - | ba-* \ - | be32-* | be64-* \ - | bfin-* | bs2000-* \ - | c[123]* | c30-* | [cjt]90-* | c4x-* \ - | c8051-* | clipper-* | craynv-* | cydra-* \ - | d10v-* | d30v-* | dlx-* \ - | e2k-* | elxsi-* \ - | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ - | h8300-* | h8500-* \ - | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ - | hexagon-* \ - | i*86-* | i860-* | i960-* | ia16-* | ia64-* \ - | ip2k-* | iq2000-* \ - | k1om-* \ - | le32-* | le64-* \ - | lm32-* \ - | m32c-* | m32r-* | m32rle-* \ - | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ - | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \ - | microblaze-* | microblazeel-* \ - | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ - | mips16-* \ - | mips64-* | mips64el-* \ - | mips64octeon-* | mips64octeonel-* \ - | mips64orion-* | mips64orionel-* \ - | mips64r5900-* | mips64r5900el-* \ - | mips64vr-* | mips64vrel-* \ - | mips64vr4100-* | mips64vr4100el-* \ - | mips64vr4300-* | mips64vr4300el-* \ - | mips64vr5000-* | mips64vr5000el-* \ - | mips64vr5900-* | mips64vr5900el-* \ - | mipsisa32-* | mipsisa32el-* \ - | mipsisa32r2-* | mipsisa32r2el-* \ - | mipsisa32r6-* | mipsisa32r6el-* \ - | mipsisa64-* | mipsisa64el-* \ - | mipsisa64r2-* | mipsisa64r2el-* \ - | mipsisa64r6-* | mipsisa64r6el-* \ - | mipsisa64sb1-* | mipsisa64sb1el-* \ - | mipsisa64sr71k-* | mipsisa64sr71kel-* \ - | mipsr5900-* | mipsr5900el-* \ - | mipstx39-* | mipstx39el-* \ - | mmix-* \ - | mt-* \ - | msp430-* \ - | nds32-* | nds32le-* | nds32be-* \ - | nios-* | nios2-* | nios2eb-* | nios2el-* \ - | none-* | np1-* | ns16k-* | ns32k-* \ - | open8-* \ - | or1k*-* \ - | orion-* \ - | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ - | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ - | pru-* \ - | pyramid-* \ - | riscv32-* | riscv64-* \ - | rl78-* | romp-* | rs6000-* | rx-* \ - | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ - | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ - | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ - | sparclite-* \ - | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \ - | tahoe-* \ - | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ - | tile*-* \ - | tron-* \ - | ubicom32-* \ - | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \ - | vax-* \ - | visium-* \ - | wasm32-* \ - | we32k-* \ - | x86-* | x86_64-* | xc16x-* | xps100-* \ - | xstormy16-* | xtensa*-* \ - | ymp-* \ - | z8k-* | z80-*) - ;; - # Recognize the basic CPU types without company name, with glob match. - xtensa*) - basic_machine=$basic_machine-unknown - ;; - # Recognize the various machine names and aliases which stand - # for a CPU type and a company and sometimes even an OS. - 386bsd) - basic_machine=i386-pc - os=-bsd - ;; - 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) - basic_machine=m68000-att - ;; - 3b*) - basic_machine=we32k-att - ;; - a29khif) - basic_machine=a29k-amd - os=-udi - ;; - abacus) - basic_machine=abacus-unknown - ;; - adobe68k) - basic_machine=m68010-adobe - os=-scout - ;; - alliant | fx80) - basic_machine=fx80-alliant - ;; - altos | altos3068) - basic_machine=m68k-altos - ;; - am29k) - basic_machine=a29k-none - os=-bsd - ;; - amd64) - basic_machine=x86_64-pc - ;; + cpu=$basic_machine + vendor=pc + ;; + # These rules are duplicated from below for sake of the special case above; + # i.e. things that normalized to x86 arches should also default to "pc" + pc98) + cpu=i386 + vendor=pc + ;; + x64 | amd64) + cpu=x86_64 + vendor=pc + ;; + # Recognize the basic CPU types without company name. + *) + cpu=$basic_machine + vendor=unknown + ;; +esac + +unset -v basic_machine + +# Decode basic machines in the full and proper CPU-Company form. +case $cpu-$vendor in + # Here we handle the default manufacturer of certain CPU types in canonical form. It is in + # some cases the only manufacturer, in others, it is the most popular. + craynv-unknown) + vendor=cray + os=${os:-unicosmp} + ;; + c90-unknown | c90-cray) + vendor=cray + os=${os:-unicos} + ;; + fx80-unknown) + vendor=alliant + ;; + romp-unknown) + vendor=ibm + ;; + mmix-unknown) + vendor=knuth + ;; + microblaze-unknown | microblazeel-unknown) + vendor=xilinx + ;; + rs6000-unknown) + vendor=ibm + ;; + vax-unknown) + vendor=dec + ;; + pdp11-unknown) + vendor=dec + ;; + we32k-unknown) + vendor=att + ;; + cydra-unknown) + vendor=cydrome + ;; + i370-ibm*) + vendor=ibm + ;; + orion-unknown) + vendor=highlevel + ;; + xps-unknown | xps100-unknown) + cpu=xps100 + vendor=honeywell + ;; + + # Here we normalize CPU types with a missing or matching vendor + dpx20-unknown | dpx20-bull) + cpu=rs6000 + vendor=bull + os=${os:-bosx} + ;; + + # Here we normalize CPU types irrespective of the vendor amd64-*) - basic_machine=x86_64-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - amdahl) - basic_machine=580-amdahl - os=-sysv - ;; - amiga | amiga-*) - basic_machine=m68k-unknown - ;; - amigaos | amigados) - basic_machine=m68k-unknown - os=-amigaos - ;; - amigaunix | amix) - basic_machine=m68k-unknown - os=-sysv4 - ;; - apollo68) - basic_machine=m68k-apollo - os=-sysv - ;; - apollo68bsd) - basic_machine=m68k-apollo - os=-bsd - ;; - aros) - basic_machine=i386-pc - os=-aros - ;; - asmjs) - basic_machine=asmjs-unknown - ;; - aux) - basic_machine=m68k-apple - os=-aux - ;; - balance) - basic_machine=ns32k-sequent - os=-dynix - ;; - blackfin) - basic_machine=bfin-unknown - os=-linux + cpu=x86_64 ;; blackfin-*) - basic_machine=bfin-`echo "$basic_machine" | sed 's/^[^-]*-//'` - os=-linux - ;; - bluegene*) - basic_machine=powerpc-ibm - os=-cnk + cpu=bfin + os=linux ;; c54x-*) - basic_machine=tic54x-`echo "$basic_machine" | sed 's/^[^-]*-//'` + cpu=tic54x ;; c55x-*) - basic_machine=tic55x-`echo "$basic_machine" | sed 's/^[^-]*-//'` + cpu=tic55x ;; c6x-*) - basic_machine=tic6x-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - c90) - basic_machine=c90-cray - os=-unicos - ;; - cegcc) - basic_machine=arm-unknown - os=-cegcc - ;; - convex-c1) - basic_machine=c1-convex - os=-bsd - ;; - convex-c2) - basic_machine=c2-convex - os=-bsd - ;; - convex-c32) - basic_machine=c32-convex - os=-bsd - ;; - convex-c34) - basic_machine=c34-convex - os=-bsd - ;; - convex-c38) - basic_machine=c38-convex - os=-bsd - ;; - cray | j90) - basic_machine=j90-cray - os=-unicos - ;; - craynv) - basic_machine=craynv-cray - os=-unicosmp - ;; - cr16 | cr16-*) - basic_machine=cr16-unknown - os=-elf - ;; - crds | unos) - basic_machine=m68k-crds - ;; - crisv32 | crisv32-* | etraxfs*) - basic_machine=crisv32-axis - ;; - cris | cris-* | etrax*) - basic_machine=cris-axis - ;; - crx) - basic_machine=crx-unknown - os=-elf - ;; - da30 | da30-*) - basic_machine=m68k-da30 - ;; - decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) - basic_machine=mips-dec - ;; - decsystem10* | dec10*) - basic_machine=pdp10-dec - os=-tops10 - ;; - decsystem20* | dec20*) - basic_machine=pdp10-dec - os=-tops20 - ;; - delta | 3300 | motorola-3300 | motorola-delta \ - | 3300-motorola | delta-motorola) - basic_machine=m68k-motorola - ;; - delta88) - basic_machine=m88k-motorola - os=-sysv3 - ;; - dicos) - basic_machine=i686-pc - os=-dicos - ;; - djgpp) - basic_machine=i586-pc - os=-msdosdjgpp - ;; - dpx20 | dpx20-*) - basic_machine=rs6000-bull - os=-bosx - ;; - dpx2*) - basic_machine=m68k-bull - os=-sysv3 - ;; - e500v[12]) - basic_machine=powerpc-unknown - os=$os"spe" - ;; - e500v[12]-*) - basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'` - os=$os"spe" - ;; - ebmon29k) - basic_machine=a29k-amd - os=-ebmon - ;; - elxsi) - basic_machine=elxsi-elxsi - os=-bsd - ;; - encore | umax | mmax) - basic_machine=ns32k-encore - ;; - es1800 | OSE68k | ose68k | ose | OSE) - basic_machine=m68k-ericsson - os=-ose - ;; - fx2800) - basic_machine=i860-alliant - ;; - genix) - basic_machine=ns32k-ns - ;; - gmicro) - basic_machine=tron-gmicro - os=-sysv - ;; - go32) - basic_machine=i386-pc - os=-go32 - ;; - h3050r* | hiux*) - basic_machine=hppa1.1-hitachi - os=-hiuxwe2 - ;; - h8300hms) - basic_machine=h8300-hitachi - os=-hms - ;; - h8300xray) - basic_machine=h8300-hitachi - os=-xray - ;; - h8500hms) - basic_machine=h8500-hitachi - os=-hms - ;; - harris) - basic_machine=m88k-harris - os=-sysv3 - ;; - hp300-*) - basic_machine=m68k-hp - ;; - hp300bsd) - basic_machine=m68k-hp - os=-bsd - ;; - hp300hpux) - basic_machine=m68k-hp - os=-hpux - ;; - hp3k9[0-9][0-9] | hp9[0-9][0-9]) - basic_machine=hppa1.0-hp - ;; - hp9k2[0-9][0-9] | hp9k31[0-9]) - basic_machine=m68000-hp - ;; - hp9k3[2-9][0-9]) - basic_machine=m68k-hp - ;; - hp9k6[0-9][0-9] | hp6[0-9][0-9]) - basic_machine=hppa1.0-hp - ;; - hp9k7[0-79][0-9] | hp7[0-79][0-9]) - basic_machine=hppa1.1-hp - ;; - hp9k78[0-9] | hp78[0-9]) - # FIXME: really hppa2.0-hp - basic_machine=hppa1.1-hp - ;; - hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) - # FIXME: really hppa2.0-hp - basic_machine=hppa1.1-hp - ;; - hp9k8[0-9][13679] | hp8[0-9][13679]) - basic_machine=hppa1.1-hp - ;; - hp9k8[0-9][0-9] | hp8[0-9][0-9]) - basic_machine=hppa1.0-hp - ;; - hppaosf) - basic_machine=hppa1.1-hp - os=-osf - ;; - hppro) - basic_machine=hppa1.1-hp - os=-proelf - ;; - i370-ibm* | ibm*) - basic_machine=i370-ibm - ;; - i*86v32) - basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` - os=-sysv32 - ;; - i*86v4*) - basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` - os=-sysv4 - ;; - i*86v) - basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` - os=-sysv - ;; - i*86sol2) - basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` - os=-solaris2 - ;; - i386mach) - basic_machine=i386-mach - os=-mach - ;; - vsta) - basic_machine=i386-unknown - os=-vsta - ;; - iris | iris4d) - basic_machine=mips-sgi - case $os in - -irix*) - ;; - *) - os=-irix4 - ;; - esac - ;; - isi68 | isi) - basic_machine=m68k-isi - os=-sysv - ;; - leon-*|leon[3-9]-*) - basic_machine=sparc-`echo "$basic_machine" | sed 's/-.*//'` - ;; - m68knommu) - basic_machine=m68k-unknown - os=-linux + cpu=tic6x + ;; + e500v[12]-*) + cpu=powerpc + os=$os"spe" + ;; + mips3*-*) + cpu=mips64 + ;; + ms1-*) + cpu=mt ;; m68knommu-*) - basic_machine=m68k-`echo "$basic_machine" | sed 's/^[^-]*-//'` - os=-linux - ;; - magnum | m3230) - basic_machine=mips-mips - os=-sysv - ;; - merlin) - basic_machine=ns32k-utek - os=-sysv - ;; - microblaze*) - basic_machine=microblaze-xilinx - ;; - mingw64) - basic_machine=x86_64-pc - os=-mingw64 - ;; - mingw32) - basic_machine=i686-pc - os=-mingw32 - ;; - mingw32ce) - basic_machine=arm-unknown - os=-mingw32ce - ;; - miniframe) - basic_machine=m68000-convergent - ;; - *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) - basic_machine=m68k-atari - os=-mint - ;; - mips3*-*) - basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'` - ;; - mips3*) - basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`-unknown - ;; - monitor) - basic_machine=m68k-rom68k - os=-coff - ;; - morphos) - basic_machine=powerpc-unknown - os=-morphos - ;; - moxiebox) - basic_machine=moxie-unknown - os=-moxiebox - ;; - msdos) - basic_machine=i386-pc - os=-msdos - ;; - ms1-*) - basic_machine=`echo "$basic_machine" | sed -e 's/ms1-/mt-/'` - ;; - msys) - basic_machine=i686-pc - os=-msys - ;; - mvs) - basic_machine=i370-ibm - os=-mvs - ;; - nacl) - basic_machine=le32-unknown - os=-nacl - ;; - ncr3000) - basic_machine=i486-ncr - os=-sysv4 - ;; - netbsd386) - basic_machine=i386-unknown - os=-netbsd - ;; - netwinder) - basic_machine=armv4l-rebel - os=-linux - ;; - news | news700 | news800 | news900) - basic_machine=m68k-sony - os=-newsos - ;; - news1000) - basic_machine=m68030-sony - os=-newsos - ;; - news-3600 | risc-news) - basic_machine=mips-sony - os=-newsos - ;; - necv70) - basic_machine=v70-nec - os=-sysv - ;; - next | m*-next) - basic_machine=m68k-next - case $os in - -nextstep* ) - ;; - -ns2*) - os=-nextstep2 - ;; - *) - os=-nextstep3 - ;; - esac - ;; - nh3000) - basic_machine=m68k-harris - os=-cxux - ;; - nh[45]000) - basic_machine=m88k-harris - os=-cxux - ;; - nindy960) - basic_machine=i960-intel - os=-nindy - ;; - mon960) - basic_machine=i960-intel - os=-mon960 - ;; - nonstopux) - basic_machine=mips-compaq - os=-nonstopux - ;; - np1) - basic_machine=np1-gould + cpu=m68k + os=linux + ;; + m9s12z-* | m68hcs12z-* | hcs12z-* | s12z-*) + cpu=s12z + ;; + openrisc-*) + cpu=or32 + ;; + parisc-*) + cpu=hppa + os=linux + ;; + pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) + cpu=i586 + ;; + pentiumpro-* | p6-* | 6x86-* | athlon-* | athalon_*-*) + cpu=i686 + ;; + pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) + cpu=i686 + ;; + pentium4-*) + cpu=i786 + ;; + pc98-*) + cpu=i386 + ;; + ppc-* | ppcbe-*) + cpu=powerpc + ;; + ppcle-* | powerpclittle-*) + cpu=powerpcle + ;; + ppc64-*) + cpu=powerpc64 + ;; + ppc64le-* | powerpc64little-*) + cpu=powerpc64le + ;; + sb1-*) + cpu=mipsisa64sb1 + ;; + sb1el-*) + cpu=mipsisa64sb1el + ;; + sh5e[lb]-*) + cpu=`echo "$cpu" | sed 's/^\(sh.\)e\(.\)$/\1\2e/'` + ;; + spur-*) + cpu=spur + ;; + strongarm-* | thumb-*) + cpu=arm + ;; + tx39-*) + cpu=mipstx39 + ;; + tx39el-*) + cpu=mipstx39el + ;; + x64-*) + cpu=x86_64 + ;; + xscale-* | xscalee[bl]-*) + cpu=`echo "$cpu" | sed 's/^xscale/arm/'` + ;; + + # Recognize the canonical CPU Types that limit and/or modify the + # company names they are paired with. + cr16-*) + os=${os:-elf} + ;; + crisv32-* | etraxfs*-*) + cpu=crisv32 + vendor=axis + ;; + cris-* | etrax*-*) + cpu=cris + vendor=axis + ;; + crx-*) + os=${os:-elf} ;; neo-tandem) - basic_machine=neo-tandem + cpu=neo + vendor=tandem ;; nse-tandem) - basic_machine=nse-tandem + cpu=nse + vendor=tandem ;; nsr-tandem) - basic_machine=nsr-tandem + cpu=nsr + vendor=tandem ;; nsv-tandem) - basic_machine=nsv-tandem + cpu=nsv + vendor=tandem ;; nsx-tandem) - basic_machine=nsx-tandem - ;; - op50n-* | op60c-*) - basic_machine=hppa1.1-oki - os=-proelf - ;; - openrisc | openrisc-*) - basic_machine=or32-unknown - ;; - os400) - basic_machine=powerpc-ibm - os=-os400 - ;; - OSE68000 | ose68000) - basic_machine=m68000-ericsson - os=-ose - ;; - os68k) - basic_machine=m68k-none - os=-os68k - ;; - pa-hitachi) - basic_machine=hppa1.1-hitachi - os=-hiuxwe2 - ;; - paragon) - basic_machine=i860-intel - os=-osf - ;; - parisc) - basic_machine=hppa-unknown - os=-linux - ;; - parisc-*) - basic_machine=hppa-`echo "$basic_machine" | sed 's/^[^-]*-//'` - os=-linux - ;; - pbd) - basic_machine=sparc-tti - ;; - pbb) - basic_machine=m68k-tti - ;; - pc532 | pc532-*) - basic_machine=ns32k-pc532 - ;; - pc98) - basic_machine=i386-pc - ;; - pc98-*) - basic_machine=i386-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - pentium | p5 | k5 | k6 | nexgen | viac3) - basic_machine=i586-pc - ;; - pentiumpro | p6 | 6x86 | athlon | athlon_*) - basic_machine=i686-pc - ;; - pentiumii | pentium2 | pentiumiii | pentium3) - basic_machine=i686-pc - ;; - pentium4) - basic_machine=i786-pc - ;; - pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) - basic_machine=i586-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - pentiumpro-* | p6-* | 6x86-* | athlon-*) - basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) - basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - pentium4-*) - basic_machine=i786-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - pn) - basic_machine=pn-gould - ;; - power) basic_machine=power-ibm - ;; - ppc | ppcbe) basic_machine=powerpc-unknown - ;; - ppc-* | ppcbe-*) - basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - ppcle | powerpclittle) - basic_machine=powerpcle-unknown - ;; - ppcle-* | powerpclittle-*) - basic_machine=powerpcle-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - ppc64) basic_machine=powerpc64-unknown - ;; - ppc64-*) basic_machine=powerpc64-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - ppc64le | powerpc64little) - basic_machine=powerpc64le-unknown - ;; - ppc64le-* | powerpc64little-*) - basic_machine=powerpc64le-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - ps2) - basic_machine=i386-ibm - ;; - psp) - basic_machine=mipsallegrexel-psp - os=-elf - ;; - pw32) - basic_machine=i586-unknown - os=-pw32 - ;; - rdos | rdos64) - basic_machine=x86_64-pc - os=-rdos - ;; - rdos32) - basic_machine=i386-pc - os=-rdos - ;; - rom68k) - basic_machine=m68k-rom68k - os=-coff - ;; - rm[46]00) - basic_machine=mips-siemens - ;; - rtpc | rtpc-*) - basic_machine=romp-ibm - ;; - s390 | s390-*) - basic_machine=s390-ibm - ;; - s390x | s390x-*) - basic_machine=s390x-ibm - ;; - sa29200) - basic_machine=a29k-amd - os=-udi - ;; - sb1) - basic_machine=mipsisa64sb1-unknown - ;; - sb1el) - basic_machine=mipsisa64sb1el-unknown - ;; - sde) - basic_machine=mipsisa32-sde - os=-elf - ;; - sei) - basic_machine=mips-sei - os=-seiux - ;; - sequent) - basic_machine=i386-sequent - ;; - sh5el) - basic_machine=sh5le-unknown - ;; - simso-wrs) - basic_machine=sparclite-wrs - os=-vxworks - ;; - sps7) - basic_machine=m68k-bull - os=-sysv2 - ;; - spur) - basic_machine=spur-unknown - ;; - st2000) - basic_machine=m68k-tandem - ;; - stratus) - basic_machine=i860-stratus - os=-sysv4 - ;; - strongarm-* | thumb-*) - basic_machine=arm-`echo "$basic_machine" | sed 's/^[^-]*-//'` - ;; - sun2) - basic_machine=m68000-sun - ;; - sun2os3) - basic_machine=m68000-sun - os=-sunos3 - ;; - sun2os4) - basic_machine=m68000-sun - os=-sunos4 - ;; - sun3os3) - basic_machine=m68k-sun - os=-sunos3 - ;; - sun3os4) - basic_machine=m68k-sun - os=-sunos4 - ;; - sun4os3) - basic_machine=sparc-sun - os=-sunos3 - ;; - sun4os4) - basic_machine=sparc-sun - os=-sunos4 - ;; - sun4sol2) - basic_machine=sparc-sun - os=-solaris2 - ;; - sun3 | sun3-*) - basic_machine=m68k-sun - ;; - sun4) - basic_machine=sparc-sun - ;; - sun386 | sun386i | roadrunner) - basic_machine=i386-sun - ;; - sv1) - basic_machine=sv1-cray - os=-unicos - ;; - symmetry) - basic_machine=i386-sequent - os=-dynix - ;; - t3e) - basic_machine=alphaev5-cray - os=-unicos - ;; - t90) - basic_machine=t90-cray - os=-unicos - ;; - tile*) - basic_machine=$basic_machine-unknown - os=-linux-gnu - ;; - tx39) - basic_machine=mipstx39-unknown - ;; - tx39el) - basic_machine=mipstx39el-unknown - ;; - toad1) - basic_machine=pdp10-xkl - os=-tops20 - ;; - tower | tower-32) - basic_machine=m68k-ncr - ;; - tpf) - basic_machine=s390x-ibm - os=-tpf - ;; - udi29k) - basic_machine=a29k-amd - os=-udi - ;; - ultra3) - basic_machine=a29k-nyu - os=-sym1 - ;; - v810 | necv810) - basic_machine=v810-nec - os=-none - ;; - vaxv) - basic_machine=vax-dec - os=-sysv - ;; - vms) - basic_machine=vax-dec - os=-vms - ;; - vpp*|vx|vx-*) - basic_machine=f301-fujitsu - ;; - vxworks960) - basic_machine=i960-wrs - os=-vxworks - ;; - vxworks68) - basic_machine=m68k-wrs - os=-vxworks - ;; - vxworks29k) - basic_machine=a29k-wrs - os=-vxworks - ;; - w65*) - basic_machine=w65-wdc - os=-none - ;; - w89k-*) - basic_machine=hppa1.1-winbond - os=-proelf - ;; - x64) - basic_machine=x86_64-pc - ;; - xbox) - basic_machine=i686-pc - os=-mingw32 - ;; - xps | xps100) - basic_machine=xps100-honeywell - ;; - xscale-* | xscalee[bl]-*) - basic_machine=`echo "$basic_machine" | sed 's/^xscale/arm/'` - ;; - ymp) - basic_machine=ymp-cray - os=-unicos - ;; - none) - basic_machine=none-none - os=-none - ;; - -# Here we handle the default manufacturer of certain CPU types. It is in -# some cases the only manufacturer, in others, it is the most popular. - w89k) - basic_machine=hppa1.1-winbond - ;; - op50n) - basic_machine=hppa1.1-oki - ;; - op60c) - basic_machine=hppa1.1-oki - ;; - romp) - basic_machine=romp-ibm - ;; - mmix) - basic_machine=mmix-knuth - ;; - rs6000) - basic_machine=rs6000-ibm - ;; - vax) - basic_machine=vax-dec - ;; - pdp11) - basic_machine=pdp11-dec - ;; - we32k) - basic_machine=we32k-att - ;; - sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) - basic_machine=sh-unknown - ;; - cydra) - basic_machine=cydra-cydrome - ;; - orion) - basic_machine=orion-highlevel - ;; - orion105) - basic_machine=clipper-highlevel - ;; - mac | mpw | mac-mpw) - basic_machine=m68k-apple - ;; - pmac | pmac-mpw) - basic_machine=powerpc-apple - ;; - *-unknown) - # Make sure to match an already-canonicalized machine name. - ;; + cpu=nsx + vendor=tandem + ;; + s390-*) + cpu=s390 + vendor=ibm + ;; + s390x-*) + cpu=s390x + vendor=ibm + ;; + tile*-*) + os=${os:-linux-gnu} + ;; + *) - echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2 - exit 1 + # Recognize the canonical CPU types that are allowed with any + # company name. + case $cpu in + 1750a | 580 \ + | a29k \ + | aarch64 | aarch64_be | arm64 \ + | abacus \ + | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] \ + | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] \ + | alphapca5[67] | alpha64pca5[67] \ + | am33_2.0 \ + | amdgcn \ + | arc | arceb \ + | arm | arm[lb]e | arme[lb] | armv* \ + | avr | avr32 \ + | asmjs \ + | ba \ + | be32 | be64 \ + | bfin | bs2000 \ + | c[123]* | c30 | [cjt]90 | c4x \ + | c8051 | clipper | craynv | csky | cydra \ + | d10v | d30v | dlx | dsp16xx \ + | e2k | elxsi | epiphany \ + | f30[01] | f700 | fido | fr30 | frv | ft32 | fx80 \ + | h8300 | h8500 \ + | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ + | hexagon \ + | i370 | i*86 | i860 | i960 | ia16 | ia64 \ + | ip2k | iq2000 \ + | k1om \ + | le32 | le64 \ + | lm32 \ + | m32c | m32r | m32rle \ + | m5200 | m68000 | m680[012346]0 | m68360 | m683?2 | m68k \ + | m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x \ + | m88110 | m88k | maxq | mb | mcore | mep | metag \ + | microblaze | microblazeel \ + | mips | mipsbe | mipseb | mipsel | mipsle \ + | mips16 \ + | mips64 | mips64eb | mips64el \ + | mips64octeon | mips64octeonel \ + | mips64orion | mips64orionel \ + | mips64r5900 | mips64r5900el \ + | mips64vr | mips64vrel \ + | mips64vr4100 | mips64vr4100el \ + | mips64vr4300 | mips64vr4300el \ + | mips64vr5000 | mips64vr5000el \ + | mips64vr5900 | mips64vr5900el \ + | mipsisa32 | mipsisa32el \ + | mipsisa32r2 | mipsisa32r2el \ + | mipsisa32r6 | mipsisa32r6el \ + | mipsisa64 | mipsisa64el \ + | mipsisa64r2 | mipsisa64r2el \ + | mipsisa64r6 | mipsisa64r6el \ + | mipsisa64sb1 | mipsisa64sb1el \ + | mipsisa64sr71k | mipsisa64sr71kel \ + | mipsr5900 | mipsr5900el \ + | mipstx39 | mipstx39el \ + | mmix \ + | mn10200 | mn10300 \ + | moxie \ + | mt \ + | msp430 \ + | nds32 | nds32le | nds32be \ + | nfp \ + | nios | nios2 | nios2eb | nios2el \ + | none | np1 | ns16k | ns32k | nvptx \ + | open8 \ + | or1k* \ + | or32 \ + | orion \ + | picochip \ + | pdp10 | pdp11 | pj | pjl | pn | power \ + | powerpc | powerpc64 | powerpc64le | powerpcle | powerpcspe \ + | pru \ + | pyramid \ + | riscv | riscv32 | riscv64 \ + | rl78 | romp | rs6000 | rx \ + | score \ + | sh | shl \ + | sh[1234] | sh[24]a | sh[24]ae[lb] | sh[23]e | she[lb] | sh[lb]e \ + | sh[1234]e[lb] | sh[12345][lb]e | sh[23]ele | sh64 | sh64le \ + | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet \ + | sparclite \ + | sparcv8 | sparcv9 | sparcv9b | sparcv9v | sv1 | sx* \ + | spu \ + | tahoe \ + | tic30 | tic4x | tic54x | tic55x | tic6x | tic80 \ + | tron \ + | ubicom32 \ + | v70 | v850 | v850e | v850e1 | v850es | v850e2 | v850e2v3 \ + | vax \ + | visium \ + | w65 | wasm32 \ + | we32k \ + | x86 | x86_64 | xc16x | xgate | xps100 \ + | xstormy16 | xtensa* \ + | ymp \ + | z8k | z80) + ;; + + *) + echo Invalid configuration \`"$1"\': machine \`"$cpu-$vendor"\' not recognized 1>&2 + exit 1 + ;; + esac ;; esac # Here we canonicalize certain aliases for manufacturers. -case $basic_machine in - *-digital*) - basic_machine=`echo "$basic_machine" | sed 's/digital.*/dec/'` +case $vendor in + digital*) + vendor=dec ;; - *-commodore*) - basic_machine=`echo "$basic_machine" | sed 's/commodore.*/cbm/'` + commodore*) + vendor=cbm ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. -if [ x"$os" != x"" ] +if [ x$os != x ] then case $os in # First match some system type aliases that might get confused # with valid system types. - # -solaris* is a basic system type, with this one exception. - -auroraux) - os=-auroraux + # solaris* is a basic system type, with this one exception. + auroraux) + os=auroraux ;; - -solaris1 | -solaris1.*) + bluegene*) + os=cnk + ;; + solaris1 | solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` ;; - -solaris) - os=-solaris2 + solaris) + os=solaris2 ;; - -unixware*) - os=-sysv4.2uw + unixware*) + os=sysv4.2uw ;; - -gnu/linux*) + gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # es1800 is here to avoid being matched by es* (a different OS) - -es1800*) - os=-ose + es1800*) + os=ose + ;; + # Some version numbers need modification + chorusos*) + os=chorusos + ;; + isc) + os=isc2.2 + ;; + sco6) + os=sco5v6 + ;; + sco5) + os=sco3.2v5 + ;; + sco4) + os=sco3.2v4 + ;; + sco3.2.[4-9]*) + os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` + ;; + sco3.2v[4-9]* | sco5v6*) + # Don't forget version if it is 3.2v4 or newer. + ;; + scout) + # Don't match below + ;; + sco*) + os=sco3.2v2 + ;; + psos*) + os=psos ;; # Now accept the basic system types. # The portable systems comes first. # Each alternative MUST end in a * to match a version number. - # -sysv* is not here because it comes later, after sysvr4. - -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ - | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ - | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ - | -sym* | -kopensolaris* | -plan9* \ - | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ - | -aos* | -aros* | -cloudabi* | -sortix* \ - | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ - | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ - | -hiux* | -knetbsd* | -mirbsd* | -netbsd* \ - | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \ - | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ - | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ - | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ - | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* | -hcos* \ - | -chorusos* | -chorusrdb* | -cegcc* | -glidix* \ - | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ - | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ - | -linux-newlib* | -linux-musl* | -linux-uclibc* \ - | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \ - | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* \ - | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ - | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ - | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ - | -morphos* | -superux* | -rtmk* | -windiss* \ - | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ - | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \ - | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox* | -bme* \ - | -midnightbsd*) + # sysv* is not here because it comes later, after sysvr4. + gnu* | bsd* | mach* | minix* | genix* | ultrix* | irix* \ + | *vms* | esix* | aix* | cnk* | sunos | sunos[34]*\ + | hpux* | unos* | osf* | luna* | dgux* | auroraux* | solaris* \ + | sym* | kopensolaris* | plan9* \ + | amigaos* | amigados* | msdos* | newsos* | unicos* | aof* \ + | aos* | aros* | cloudabi* | sortix* \ + | nindy* | vxsim* | vxworks* | ebmon* | hms* | mvs* \ + | clix* | riscos* | uniplus* | iris* | isc* | rtu* | xenix* \ + | knetbsd* | mirbsd* | netbsd* \ + | bitrig* | openbsd* | solidbsd* | libertybsd* \ + | ekkobsd* | kfreebsd* | freebsd* | riscix* | lynxos* \ + | bosx* | nextstep* | cxux* | aout* | elf* | oabi* \ + | ptx* | coff* | ecoff* | winnt* | domain* | vsta* \ + | udi* | eabi* | lites* | ieee* | go32* | aux* | hcos* \ + | chorusrdb* | cegcc* | glidix* \ + | cygwin* | msys* | pe* | moss* | proelf* | rtems* \ + | midipix* | mingw32* | mingw64* | linux-gnu* | linux-android* \ + | linux-newlib* | linux-musl* | linux-uclibc* \ + | uxpv* | beos* | mpeix* | udk* | moxiebox* \ + | interix* | uwin* | mks* | rhapsody* | darwin* \ + | openstep* | oskit* | conix* | pw32* | nonstopux* \ + | storm-chaos* | tops10* | tenex* | tops20* | its* \ + | os2* | vos* | palmos* | uclinux* | nucleus* \ + | morphos* | superux* | rtmk* | windiss* \ + | powermax* | dnix* | nx6 | nx7 | sei* | dragonfly* \ + | skyos* | haiku* | rdos* | toppers* | drops* | es* \ + | onefs* | tirtos* | phoenix* | fuchsia* | redox* | bme* \ + | midnightbsd* | amdhsa* | unleashed* | emscripten*) # Remember, each alternative MUST END IN *, to match a version number. ;; - -qnx*) - case $basic_machine in - x86-* | i*86-*) + qnx*) + case $cpu in + x86 | i*86) ;; *) - os=-nto$os + os=nto-$os ;; esac ;; - -nto-qnx*) + hiux*) + os=hiuxwe2 ;; - -nto*) + nto-qnx*) + ;; + nto*) os=`echo $os | sed -e 's|nto|nto-qnx|'` ;; - -sim | -xray | -os68k* | -v88r* \ - | -windows* | -osx | -abug | -netware* | -os9* \ - | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) - ;; - -mac*) - os=`echo "$os" | sed -e 's|mac|macos|'` - ;; - -linux-dietlibc) - os=-linux-dietlibc - ;; - -linux*) + sim | xray | os68k* | v88r* \ + | windows* | osx | abug | netware* | os9* \ + | macos* | mpw* | magic* | mmixware* | mon960* | lnews*) + ;; + linux-dietlibc) + os=linux-dietlibc + ;; + linux*) os=`echo $os | sed -e 's|linux|linux-gnu|'` ;; - -sunos5*) + lynx*178) + os=lynxos178 + ;; + lynx*5) + os=lynxos5 + ;; + lynx*) + os=lynxos + ;; + mac*) + os=`echo "$os" | sed -e 's|mac|macos|'` + ;; + opened*) + os=openedition + ;; + os400*) + os=os400 + ;; + sunos5*) os=`echo "$os" | sed -e 's|sunos5|solaris2|'` ;; - -sunos6*) + sunos6*) os=`echo "$os" | sed -e 's|sunos6|solaris3|'` ;; - -opened*) - os=-openedition - ;; - -os400*) - os=-os400 - ;; - -wince*) - os=-wince - ;; - -utek*) - os=-bsd - ;; - -dynix*) - os=-bsd - ;; - -acis*) - os=-aos - ;; - -atheos*) - os=-atheos - ;; - -syllable*) - os=-syllable - ;; - -386bsd) - os=-bsd - ;; - -ctix* | -uts*) - os=-sysv - ;; - -nova*) - os=-rtmk-nova - ;; - -ns2) - os=-nextstep2 - ;; - -nsk*) - os=-nsk + wince*) + os=wince + ;; + utek*) + os=bsd + ;; + dynix*) + os=bsd + ;; + acis*) + os=aos + ;; + atheos*) + os=atheos + ;; + syllable*) + os=syllable + ;; + 386bsd) + os=bsd + ;; + ctix* | uts*) + os=sysv + ;; + nova*) + os=rtmk-nova + ;; + ns2) + os=nextstep2 + ;; + nsk*) + os=nsk ;; # Preserve the version number of sinix5. - -sinix5.*) + sinix5.*) os=`echo $os | sed -e 's|sinix|sysv|'` ;; - -sinix*) - os=-sysv4 - ;; - -tpf*) - os=-tpf - ;; - -triton*) - os=-sysv3 - ;; - -oss*) - os=-sysv3 - ;; - -svr4*) - os=-sysv4 - ;; - -svr3) - os=-sysv3 - ;; - -sysvr4) - os=-sysv4 - ;; - # This must come after -sysvr4. - -sysv*) - ;; - -ose*) - os=-ose - ;; - -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) - os=-mint - ;; - -zvmoe) - os=-zvmoe - ;; - -dicos*) - os=-dicos - ;; - -pikeos*) + sinix*) + os=sysv4 + ;; + tpf*) + os=tpf + ;; + triton*) + os=sysv3 + ;; + oss*) + os=sysv3 + ;; + svr4*) + os=sysv4 + ;; + svr3) + os=sysv3 + ;; + sysvr4) + os=sysv4 + ;; + # This must come after sysvr4. + sysv*) + ;; + ose*) + os=ose + ;; + *mint | mint[0-9]* | *MiNT | MiNT[0-9]*) + os=mint + ;; + zvmoe) + os=zvmoe + ;; + dicos*) + os=dicos + ;; + pikeos*) # Until real need of OS specific support for # particular features comes up, bare metal # configurations are quite functional. - case $basic_machine in + case $cpu in arm*) - os=-eabi + os=eabi ;; *) - os=-elf + os=elf ;; esac ;; - -nacl*) + nacl*) + ;; + ios) ;; - -ios) + none) ;; - -none) + *-eabi) ;; *) - # Get rid of the `-' at the beginning of $os. - os=`echo $os | sed 's/[^-]*-//'` echo Invalid configuration \`"$1"\': system \`"$os"\' not recognized 1>&2 exit 1 ;; esac else @@ -1545,261 +1532,268 @@ # "-sun"), then you have to tell the case statement up towards the top # that MANUFACTURER isn't an operating system. Otherwise, code above # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. -case $basic_machine in +case $cpu-$vendor in score-*) - os=-elf + os=elf ;; spu-*) - os=-elf + os=elf ;; *-acorn) - os=-riscix1.2 + os=riscix1.2 ;; arm*-rebel) - os=-linux + os=linux ;; arm*-semi) - os=-aout + os=aout ;; c4x-* | tic4x-*) - os=-coff + os=coff ;; c8051-*) - os=-elf + os=elf + ;; + clipper-intergraph) + os=clix ;; hexagon-*) - os=-elf + os=elf ;; tic54x-*) - os=-coff + os=coff ;; tic55x-*) - os=-coff + os=coff ;; tic6x-*) - os=-coff + os=coff ;; # This must come before the *-dec entry. pdp10-*) - os=-tops20 + os=tops20 ;; pdp11-*) - os=-none + os=none ;; *-dec | vax-*) - os=-ultrix4.2 + os=ultrix4.2 ;; m68*-apollo) - os=-domain + os=domain ;; i386-sun) - os=-sunos4.0.2 + os=sunos4.0.2 ;; m68000-sun) - os=-sunos3 + os=sunos3 ;; m68*-cisco) - os=-aout + os=aout ;; mep-*) - os=-elf + os=elf ;; mips*-cisco) - os=-elf + os=elf ;; mips*-*) - os=-elf + os=elf ;; or32-*) - os=-coff + os=coff ;; *-tti) # must be before sparc entry or we get the wrong os. - os=-sysv3 + os=sysv3 ;; sparc-* | *-sun) - os=-sunos4.1.1 + os=sunos4.1.1 ;; pru-*) - os=-elf + os=elf ;; *-be) - os=-beos + os=beos ;; *-ibm) - os=-aix + os=aix ;; *-knuth) - os=-mmixware + os=mmixware ;; *-wec) - os=-proelf + os=proelf ;; *-winbond) - os=-proelf + os=proelf ;; *-oki) - os=-proelf + os=proelf ;; *-hp) - os=-hpux + os=hpux ;; *-hitachi) - os=-hiux + os=hiux ;; i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) - os=-sysv + os=sysv ;; *-cbm) - os=-amigaos + os=amigaos ;; *-dg) - os=-dgux + os=dgux ;; *-dolphin) - os=-sysv3 + os=sysv3 ;; m68k-ccur) - os=-rtu + os=rtu ;; m88k-omron*) - os=-luna + os=luna ;; *-next) - os=-nextstep + os=nextstep ;; *-sequent) - os=-ptx + os=ptx ;; *-crds) - os=-unos + os=unos ;; *-ns) - os=-genix + os=genix ;; i370-*) - os=-mvs + os=mvs ;; *-gould) - os=-sysv + os=sysv ;; *-highlevel) - os=-bsd + os=bsd ;; *-encore) - os=-bsd + os=bsd ;; *-sgi) - os=-irix + os=irix ;; *-siemens) - os=-sysv4 + os=sysv4 ;; *-masscomp) - os=-rtu + os=rtu ;; f30[01]-fujitsu | f700-fujitsu) - os=-uxpv + os=uxpv ;; *-rom68k) - os=-coff + os=coff ;; *-*bug) - os=-coff + os=coff ;; *-apple) - os=-macos + os=macos ;; *-atari*) - os=-mint + os=mint + ;; + *-wrs) + os=vxworks ;; *) - os=-none + os=none ;; esac fi # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. -vendor=unknown -case $basic_machine in - *-unknown) +case $vendor in + unknown) case $os in - -riscix*) + riscix*) vendor=acorn ;; - -sunos*) + sunos*) vendor=sun ;; - -cnk*|-aix*) + cnk*|-aix*) vendor=ibm ;; - -beos*) + beos*) vendor=be ;; - -hpux*) + hpux*) vendor=hp ;; - -mpeix*) + mpeix*) vendor=hp ;; - -hiux*) + hiux*) vendor=hitachi ;; - -unos*) + unos*) vendor=crds ;; - -dgux*) + dgux*) vendor=dg ;; - -luna*) + luna*) vendor=omron ;; - -genix*) - vendor=ns - ;; - -mvs* | -opened*) - vendor=ibm - ;; - -os400*) - vendor=ibm - ;; - -ptx*) - vendor=sequent - ;; - -tpf*) - vendor=ibm - ;; - -vxsim* | -vxworks* | -windiss*) - vendor=wrs - ;; - -aux*) - vendor=apple - ;; - -hms*) - vendor=hitachi - ;; - -mpw* | -macos*) - vendor=apple - ;; - -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) - vendor=atari - ;; - -vos*) + genix*) + vendor=ns + ;; + clix*) + vendor=intergraph + ;; + mvs* | opened*) + vendor=ibm + ;; + os400*) + vendor=ibm + ;; + ptx*) + vendor=sequent + ;; + tpf*) + vendor=ibm + ;; + vxsim* | vxworks* | windiss*) + vendor=wrs + ;; + aux*) + vendor=apple + ;; + hms*) + vendor=hitachi + ;; + mpw* | macos*) + vendor=apple + ;; + *mint | mint[0-9]* | *MiNT | MiNT[0-9]*) + vendor=atari + ;; + vos*) vendor=stratus ;; esac - basic_machine=`echo "$basic_machine" | sed "s/unknown/$vendor/"` ;; esac -echo "$basic_machine$os" +echo "$cpu-$vendor-$os" exit # Local variables: # eval: (add-hook 'before-save-hook 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: Index: build-aux/install-sh ================================================================== --- build-aux/install-sh +++ build-aux/install-sh @@ -1,501 +1,301 @@ #!/bin/sh -# install - install a program, script, or datafile - -scriptversion=2013-12-25.23; # UTC - -# This originates from X11R5 (mit/util/scripts/install.sh), which was -# later released in X11R6 (xc/config/util/install.sh) with the -# following copyright and license. -# -# Copyright (C) 1994 X Consortium -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to -# deal in the Software without restriction, including without limitation the -# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -# sell copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in -# all copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN -# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- -# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -# -# Except as contained in this notice, the name of the X Consortium shall not -# be used in advertising or otherwise to promote the sale, use or other deal- -# ings in this Software without prior written authorization from the X Consor- -# tium. -# -# -# FSF changes to this file are in the public domain. +# +# $NetBSD: install-sh.in,v 1.6 2012/01/11 13:07:31 hans Exp $ +# This script now also installs multiple files, but might choke on installing +# multiple files with spaces in the file names. +# +# install - install a program, script, or datafile +# This comes from X11R5 (mit/util/scripts/install.sh). +# +# Copyright 1991 by the Massachusetts Institute of Technology +# +# Permission to use, copy, modify, distribute, and sell this software and its +# documentation for any purpose is hereby granted without fee, provided that +# the above copyright notice appear in all copies and that both that +# copyright notice and this permission notice appear in supporting +# documentation, and that the name of M.I.T. not be used in advertising or +# publicity pertaining to distribution of the software without specific, +# written prior permission. M.I.T. makes no representations about the +# suitability of this software for any purpose. It is provided "as is" +# without express or implied warranty. # # Calling this script install-sh is preferred over install.sh, to prevent -# 'make' implicit rules from creating a file called install from it +# `make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. -tab=' ' -nl=' -' -IFS=" $tab$nl" - -# Set DOITPROG to "echo" to test this script. - -doit=${DOITPROG-} -doit_exec=${doit:-exec} - -# Put in absolute file names if you don't have them in your path; -# or use environment vars. - -chgrpprog=${CHGRPPROG-chgrp} -chmodprog=${CHMODPROG-chmod} -chownprog=${CHOWNPROG-chown} -cmpprog=${CMPPROG-cmp} -cpprog=${CPPROG-cp} -mkdirprog=${MKDIRPROG-mkdir} -mvprog=${MVPROG-mv} -rmprog=${RMPROG-rm} -stripprog=${STRIPPROG-strip} - -posix_mkdir= - -# Desired mode of installed file. -mode=0755 - -chgrpcmd= -chmodcmd=$chmodprog -chowncmd= -mvcmd=$mvprog -rmcmd="$rmprog -f" -stripcmd= - -src= -dst= -dir_arg= -dst_arg= - -copy_on_change=false -is_target_a_directory=possibly - -usage="\ -Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE - or: $0 [OPTION]... SRCFILES... DIRECTORY - or: $0 [OPTION]... -t DIRECTORY SRCFILES... - or: $0 [OPTION]... -d DIRECTORIES... - -In the 1st form, copy SRCFILE to DSTFILE. -In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. -In the 4th, create DIRECTORIES. - -Options: - --help display this help and exit. - --version display version info and exit. - - -c (ignored) - -C install only if different (preserve the last data modification time) - -d create directories instead of installing files. - -g GROUP $chgrpprog installed files to GROUP. - -m MODE $chmodprog installed files to MODE. - -o USER $chownprog installed files to USER. - -s $stripprog installed files. - -t DIRECTORY install into DIRECTORY. - -T report an error if DSTFILE is a directory. - -Environment variables override the default commands: - CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG - RMPROG STRIPPROG -" - -while test $# -ne 0; do - case $1 in - -c) ;; - - -C) copy_on_change=true;; - - -d) dir_arg=true;; - - -g) chgrpcmd="$chgrpprog $2" - shift;; - - --help) echo "$usage"; exit $?;; - - -m) mode=$2 - case $mode in - *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*) - echo "$0: invalid mode: $mode" >&2 - exit 1;; - esac - shift;; - - -o) chowncmd="$chownprog $2" - shift;; - - -s) stripcmd=$stripprog;; - - -t) - is_target_a_directory=always - dst_arg=$2 - # Protect names problematic for 'test' and other utilities. - case $dst_arg in - -* | [=\(\)!]) dst_arg=./$dst_arg;; - esac - shift;; - - -T) is_target_a_directory=never;; - - --version) echo "$0 $scriptversion"; exit $?;; - - --) shift - break;; - - -*) echo "$0: invalid option: $1" >&2 - exit 1;; - - *) break;; - esac - shift -done - -# We allow the use of options -d and -T together, by making -d -# take the precedence; this is for compatibility with GNU install. - -if test -n "$dir_arg"; then - if test -n "$dst_arg"; then - echo "$0: target directory not allowed when installing a directory." >&2 - exit 1 - fi -fi - -if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then - # When -d is used, all remaining arguments are directories to create. - # When -t is used, the destination is already specified. - # Otherwise, the last argument is the destination. Remove it from $@. - for arg - do - if test -n "$dst_arg"; then - # $@ is not empty: it contains at least $arg. - set fnord "$@" "$dst_arg" - shift # fnord - fi - shift # arg - dst_arg=$arg - # Protect names problematic for 'test' and other utilities. - case $dst_arg in - -* | [=\(\)!]) dst_arg=./$dst_arg;; - esac - done -fi - -if test $# -eq 0; then - if test -z "$dir_arg"; then - echo "$0: no input file specified." >&2 - exit 1 - fi - # It's OK to call 'install-sh -d' without argument. - # This can happen when creating conditional directories. - exit 0 -fi - -if test -z "$dir_arg"; then - if test $# -gt 1 || test "$is_target_a_directory" = always; then - if test ! -d "$dst_arg"; then - echo "$0: $dst_arg: Is not a directory." >&2 - exit 1 - fi - fi -fi - -if test -z "$dir_arg"; then - do_exit='(exit $ret); exit $ret' - trap "ret=129; $do_exit" 1 - trap "ret=130; $do_exit" 2 - trap "ret=141; $do_exit" 13 - trap "ret=143; $do_exit" 15 - - # Set umask so as not to create temps with too-generous modes. - # However, 'strip' requires both read and write access to temps. - case $mode in - # Optimize common cases. - *644) cp_umask=133;; - *755) cp_umask=22;; - - *[0-7]) - if test -z "$stripcmd"; then - u_plus_rw= - else - u_plus_rw='% 200' - fi - cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; - *) - if test -z "$stripcmd"; then - u_plus_rw= - else - u_plus_rw=,u+rw - fi - cp_umask=$mode$u_plus_rw;; - esac -fi - -for src -do - # Protect names problematic for 'test' and other utilities. - case $src in - -* | [=\(\)!]) src=./$src;; - esac - - if test -n "$dir_arg"; then - dst=$src - dstdir=$dst - test -d "$dstdir" - dstdir_status=$? - else - - # Waiting for this to be detected by the "$cpprog $src $dsttmp" command - # might cause directories to be created, which would be especially bad - # if $src (and thus $dsttmp) contains '*'. - if test ! -f "$src" && test ! -d "$src"; then - echo "$0: $src does not exist." >&2 - exit 1 - fi - - if test -z "$dst_arg"; then - echo "$0: no destination specified." >&2 - exit 1 - fi - dst=$dst_arg - - # If destination is a directory, append the input filename; won't work - # if double slashes aren't ignored. - if test -d "$dst"; then - if test "$is_target_a_directory" = never; then - echo "$0: $dst_arg: Is a directory" >&2 - exit 1 - fi - dstdir=$dst - dst=$dstdir/`basename "$src"` - dstdir_status=0 - else - dstdir=`dirname "$dst"` - test -d "$dstdir" - dstdir_status=$? - fi - fi - - obsolete_mkdir_used=false - - if test $dstdir_status != 0; then - case $posix_mkdir in - '') - # Create intermediate dirs using mode 755 as modified by the umask. - # This is like FreeBSD 'install' as of 1997-10-28. - umask=`umask` - case $stripcmd.$umask in - # Optimize common cases. - *[2367][2367]) mkdir_umask=$umask;; - .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; - - *[0-7]) - mkdir_umask=`expr $umask + 22 \ - - $umask % 100 % 40 + $umask % 20 \ - - $umask % 10 % 4 + $umask % 2 - `;; - *) mkdir_umask=$umask,go-w;; - esac - - # With -d, create the new directory with the user-specified mode. - # Otherwise, rely on $mkdir_umask. - if test -n "$dir_arg"; then - mkdir_mode=-m$mode - else - mkdir_mode= - fi - - posix_mkdir=false - case $umask in - *[123567][0-7][0-7]) - # POSIX mkdir -p sets u+wx bits regardless of umask, which - # is incompatible with FreeBSD 'install' when (umask & 300) != 0. - ;; - *) - tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ - trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0 - - if (umask $mkdir_umask && - exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1 - then - if test -z "$dir_arg" || { - # Check for POSIX incompatibilities with -m. - # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or - # other-writable bit of parent directory when it shouldn't. - # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. - ls_ld_tmpdir=`ls -ld "$tmpdir"` - case $ls_ld_tmpdir in - d????-?r-*) different_mode=700;; - d????-?--*) different_mode=755;; - *) false;; - esac && - $mkdirprog -m$different_mode -p -- "$tmpdir" && { - ls_ld_tmpdir_1=`ls -ld "$tmpdir"` - test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" - } - } - then posix_mkdir=: - fi - rmdir "$tmpdir/d" "$tmpdir" - else - # Remove any dirs left behind by ancient mkdir implementations. - rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null - fi - trap '' 0;; - esac;; - esac - - if - $posix_mkdir && ( - umask $mkdir_umask && - $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" - ) - then : - else - - # The umask is ridiculous, or mkdir does not conform to POSIX, - # or it failed possibly due to a race condition. Create the - # directory the slow way, step by step, checking for races as we go. - - case $dstdir in - /*) prefix='/';; - [-=\(\)!]*) prefix='./';; - *) prefix='';; - esac - - oIFS=$IFS - IFS=/ - set -f - set fnord $dstdir - shift - set +f - IFS=$oIFS - - prefixes= - - for d - do - test X"$d" = X && continue - - prefix=$prefix$d - if test -d "$prefix"; then - prefixes= - else - if $posix_mkdir; then - (umask=$mkdir_umask && - $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break - # Don't fail if two instances are running concurrently. - test -d "$prefix" || exit 1 - else - case $prefix in - *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; - *) qprefix=$prefix;; - esac - prefixes="$prefixes '$qprefix'" - fi - fi - prefix=$prefix/ - done - - if test -n "$prefixes"; then - # Don't fail if two instances are running concurrently. - (umask $mkdir_umask && - eval "\$doit_exec \$mkdirprog $prefixes") || - test -d "$dstdir" || exit 1 - obsolete_mkdir_used=true - fi - fi - fi - - if test -n "$dir_arg"; then - { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && - { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && - { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || - test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 - else - - # Make a couple of temp file names in the proper directory. - dsttmp=$dstdir/_inst.$$_ - rmtmp=$dstdir/_rm.$$_ - - # Trap to clean up those temp files at exit. - trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 - - # Copy the file name to the temp name. - (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && - - # and set any options; do chmod last to preserve setuid bits. - # - # If any of these fail, we abort the whole thing. If we want to - # ignore errors from any of these, just make sure not to ignore - # errors from the above "$doit $cpprog $src $dsttmp" command. - # - { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && - { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && - { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && - { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && - - # If -C, don't bother to copy if it wouldn't change the file. - if $copy_on_change && - old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && - new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && - set -f && - set X $old && old=:$2:$4:$5:$6 && - set X $new && new=:$2:$4:$5:$6 && - set +f && - test "$old" = "$new" && - $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 - then - rm -f "$dsttmp" - else - # Rename the file to the real destination. - $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || - - # The rename failed, perhaps because mv can't rename something else - # to itself, or perhaps because mv is so ancient that it does not - # support -f. - { - # Now remove or move aside any old file at destination location. - # We try this two ways since rm can't unlink itself on some - # systems and the destination file might be busy for other - # reasons. In this case, the final cleanup might fail but the new - # file should still install successfully. - { - test ! -f "$dst" || - $doit $rmcmd -f "$dst" 2>/dev/null || - { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && - { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } - } || - { echo "$0: cannot unlink or rename $dst" >&2 - (exit 1); exit 1 - } - } && - - # Now rename the file to the real destination. - $doit $mvcmd "$dsttmp" "$dst" - } - fi || exit 1 - - trap '' 0 - fi -done - -# Local variables: -# eval: (add-hook 'write-file-hooks 'time-stamp) -# time-stamp-start: "scriptversion=" -# time-stamp-format: "%:y-%02m-%02d.%02H" -# time-stamp-time-zone: "UTC" -# time-stamp-end: "; # UTC" -# End: +# set DOITPROG to echo to test this script + +# Don't use :- since 4.3BSD and earlier shells don't like it. +doit="${DOITPROG-}" + + +# put in absolute paths if you don't have them in your path; or use env. vars. + +awkprog="${AWKPROG-awk}" +mvprog="${MVPROG-mv}" +cpprog="${CPPROG-cp}" +chmodprog="${CHMODPROG-chmod}" +chownprog="${CHOWNPROG-chown}" +chgrpprog="${CHGRPPROG-chgrp}" +stripprog="${STRIPPROG-strip}" +rmprog="${RMPROG-rm}" +mkdirprog="${MKDIRPROG-mkdir}" + +instcmd="$cpprog" +instflags="" +pathcompchmodcmd="$chmodprog 755" +chmodcmd="$chmodprog 755" +chowncmd="" +chgrpcmd="" +stripcmd="" +stripflags="" +rmcmd="$rmprog -f" +mvcmd="$mvprog" +src="" +msrc="" +dst="" +dir_arg="" +suffix="" +suffixfmt="" + +while [ x"$1" != x ]; do + case $1 in + -b) suffix=".old" + shift + continue;; + + -B) suffixfmt="$2" + shift + shift + continue;; + + -c) instcmd="$cpprog" + shift + continue;; + + -d) dir_arg=true + shift + continue;; + + -m) chmodcmd="$chmodprog $2" + shift + shift + continue;; + + -m*) + chmodcmd="$chmodprog ${1#-m}" + shift + continue;; + + -o) chowncmd="$chownprog $2" + shift + shift + continue;; + + -g) chgrpcmd="$chgrpprog $2" + shift + shift + continue;; + + -s) stripcmd="$stripprog" + shift + continue;; + + -S) stripcmd="$stripprog" + stripflags="-S $2 $stripflags" + shift + shift + continue;; + + -p) instflags="-p" + shift + continue;; + + *) if [ x"$msrc" = x ] + then + msrc="$dst" + else + msrc="$msrc $dst" + fi + src="$dst" + dst="$1" + shift + continue;; + esac +done + +if [ x"$dir_arg" = x ] +then + dstisfile="" + if [ ! -d "$dst" ] + then + if [ x"$msrc" = x"$src" ] + then + dstisfile=true + else + echo "install: destination is not a directory" + exit 1 + fi + fi +else + msrc="$msrc $dst" +fi + +if [ x"$msrc" = x ] +then + echo "install: no destination specified" + exit 1 +fi + +for srcarg in $msrc; do + +if [ x"$dir_arg" != x ]; then + + dstarg="$srcarg" +else + dstarg="$dst" + +# Waiting for this to be detected by the "$instcmd $srcarg $dsttmp" command +# might cause directories to be created, which would be especially bad +# if $src (and thus $dsttmp) contains '*'. + + if [ -f "$srcarg" ] + then + doinst="$instcmd $instflags" + elif [ -d "$srcarg" ] + then + echo "install: $srcarg: not a regular file" + exit 1 + elif [ "$srcarg" = "/dev/null" ] + then + doinst="$cpprog" + else + echo "install: $srcarg does not exist" + exit 1 + fi + +# If destination is a directory, append the input filename; if your system +# does not like double slashes in filenames, you may need to add some logic + + if [ -d "$dstarg" ] + then + dstarg="$dstarg"/`basename "$srcarg"` + fi +fi + +## this sed command emulates the dirname command +dstdir=`echo "$dstarg" | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'` + +# Make sure that the destination directory exists. +# this part is taken from Noah Friedman's mkinstalldirs script + +# Skip lots of stat calls in the usual case. +if [ ! -d "$dstdir" ]; then +defaultIFS=' +' +IFS="${IFS-${defaultIFS}}" + +oIFS="${IFS}" +# Some sh's can't handle IFS=/ for some reason. +IFS='%' +set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'` +IFS="${oIFS}" + +pathcomp='' + +while [ $# -ne 0 ] ; do + pathcomp="${pathcomp}${1}" + shift + + if [ ! -d "${pathcomp}" ] ; + then + $doit $mkdirprog "${pathcomp}" + if [ x"$chowncmd" != x ]; then $doit $chowncmd "${pathcomp}"; else true ; fi && + if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd "${pathcomp}"; else true ; fi && + if [ x"$pathcompchmodcmd" != x ]; then $doit $pathcompchmodcmd "${pathcomp}"; else true ; fi + + else + true + fi + + pathcomp="${pathcomp}/" +done +fi + + if [ x"$dir_arg" != x ] + then + if [ -d "$dstarg" ]; then + true + else + $doit $mkdirprog "$dstarg" && + + if [ x"$chowncmd" != x ]; then $doit $chowncmd "$dstarg"; else true ; fi && + if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd "$dstarg"; else true ; fi && + if [ x"$chmodcmd" != x ]; then $doit $chmodcmd "$dstarg"; else true ; fi + fi + else + + if [ x"$dstisfile" = x ] + then + file=$srcarg + else + file=$dst + fi + + dstfile=`basename "$file"` + dstfinal="$dstdir/$dstfile" + +# Make a temp file name in the proper directory. + + dsttmp=$dstdir/#inst.$$# + +# Make a backup file name in the proper directory. + case x$suffixfmt in + *%*) suffix=`echo x | + $awkprog -v bname="$dstfinal" -v fmt="$suffixfmt" ' + { cnt = 0; + do { + sfx = sprintf(fmt, cnt++); + name = bname sfx; + } while (system("test -f " name) == 0); + print sfx; }' -`;; + x) ;; + *) suffix="$suffixfmt";; + esac + dstbackup="$dstfinal$suffix" + +# Move or copy the file name to the temp name + + $doit $doinst $srcarg "$dsttmp" && + + trap "rm -f ${dsttmp}" 0 && + +# and set any options; do chmod last to preserve setuid bits + +# If any of these fail, we abort the whole thing. If we want to +# ignore errors from any of these, just make sure not to ignore +# errors from the above "$doit $instcmd $src $dsttmp" command. + + if [ x"$chowncmd" != x ]; then $doit $chowncmd "$dsttmp"; else true;fi && + if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd "$dsttmp"; else true;fi && + if [ x"$stripcmd" != x ]; then $doit $stripcmd $stripflags "$dsttmp"; else true;fi && + if [ x"$chmodcmd" != x ]; then $doit $chmodcmd "$dsttmp"; else true;fi && + +# Now rename the file to the real destination. + + if [ x"$suffix" != x ] && [ -f "$dstfinal" ] + then + $doit $mvcmd "$dstfinal" "$dstbackup" + else + $doit $rmcmd -f "$dstfinal" + fi && + $doit $mvcmd "$dsttmp" "$dstfinal" + fi + +done && + + +exit 0 Index: configure.ac ================================================================== --- configure.ac +++ configure.ac @@ -16,13 +16,10 @@ BUILDSYS_INIT AC_CANONICAL_HOST -AC_ARG_WITH(ixemul, - AS_HELP_STRING([--with-ixemul], [build with ixemul])) - dnl Used to disable checking for -pedantic on some platforms where it's broken check_pedantic="yes" case "$host" in arm-*-riscos*) @@ -46,10 +43,11 @@ ]) OBJCFLAGS="$OBJCFLAGS -noixemul" OBJFW_OBJCFLAGS="$OBJFW_OBJCFLAGS -noixemul" CPPFLAGS="$CPPFLAGS -D__NO_NET_API" LDFLAGS="$LDFLAGS -noixemul" + LIBS="$LIBS -ldebug" enable_files="yes" # Required for reading ENV: enable_shared="no" supports_amiga_lib="yes" @@ -60,12 +58,13 @@ AC_SUBST(SFDC_INLINE_H, inline.h) dnl For 68000, GCC emits calls to helper functions that dnl do not work properly in a library. t="-mcpu=68020 -fbaserel -noixemul" AC_SUBST(AMIGA_LIB_CFLAGS, "$t -ffreestanding") - AC_SUBST(AMIGA_LIB_LDFLAGS, - "$t -resident -nostartfiles") + t="$t -resident -nostartfiles -nodefaultlibs" + t="$t -ldebug -lc" + AC_SUBST(AMIGA_LIB_LDFLAGS, $t) ]) AC_SUBST(LIBBASES_M, libbases.m) ;; powerpc-*-amigaos*) @@ -75,35 +74,34 @@ enable_shared="no" AC_SUBST(LIBBASES_M, libbases.m) ;; *-morphos*) - AS_IF([test x"$with_ixemul" != x"yes"], [ - AS_IF([test x"$OBJCFLAGS" = x""], [ - OBJCFLAGS="-O2 -g" - ]) - OBJCFLAGS="$OBJCFLAGS -noixemul" - OBJFW_OBJCFLAGS="$OBJFW_OBJCFLAGS -noixemul" - LDFLAGS="$LDFLAGS -noixemul" - enable_files="yes" # Required for reading ENV: - supports_amiga_lib="yes" - check_pedantic="no" # Breaks generated inlines - - AS_IF([test x"$enable_amiga_lib" != x"no"], [ - AC_SUBST(OBJFWRT_AMIGA_LIB, objfwrt.library) - AC_SUBST(CVINCLUDE_INLINE_H, inline.h) - t="-mresident32 -ffreestanding -noixemul" - AC_SUBST(AMIGA_LIB_CFLAGS, $t) - t="-mresident32 -nostartfiles -nodefaultlibs" - t="$t -noixemul -lc" - AC_SUBST(AMIGA_LIB_LDFLAGS, $t) - ]) - - AC_SUBST(LIBBASES_M, libbases.m) - ]) - + AS_IF([test x"$OBJCFLAGS" = x""], [ + OBJCFLAGS="-O2 -g" + ]) + OBJCFLAGS="$OBJCFLAGS -noixemul" + OBJFW_OBJCFLAGS="$OBJFW_OBJCFLAGS -noixemul" + LDFLAGS="$LDFLAGS -noixemul" + LIBS="$LIBS -ldebug" + + enable_files="yes" # Required for reading ENV: enable_shared="no" + supports_amiga_lib="yes" + check_pedantic="no" # Breaks generated inlines + + AS_IF([test x"$enable_amiga_lib" != x"no"], [ + AC_SUBST(OBJFWRT_AMIGA_LIB, objfwrt.library) + AC_SUBST(CVINCLUDE_INLINE_H, inline.h) + t="-mresident32 -ffreestanding -noixemul" + AC_SUBST(AMIGA_LIB_CFLAGS, $t) + t="-mresident32 -nostartfiles -nodefaultlibs" + t="$t -noixemul -ldebug -lc" + AC_SUBST(AMIGA_LIB_LDFLAGS, $t) + ]) + + AC_SUBST(LIBBASES_M, libbases.m) ;; *-msdosdjgpp*) enable_shared="no" enable_threads="no" enable_sockets="no" @@ -731,39 +729,10 @@ ]) AS_IF([test x"$ac_cv_c_bigendian" = x"universal"], [ AC_DEFINE(OF_UNIVERSAL, 1, [Whether we are building a universal binary]) ]) -AC_MSG_CHECKING(for SIZE_MAX) -AC_EGREP_CPP(egrep_cpp_yes, [ - #include - #include - - #ifdef SIZE_MAX - egrep_cpp_yes - #endif -], [ - AC_MSG_RESULT(yes) -], [ - AC_MSG_RESULT(no) - AC_MSG_CHECKING(for SIZE_T_MAX) - AC_EGREP_CPP(egrep_cpp_yes, [ - #include - #include - - #ifdef SIZE_T_MAX - egrep_cpp_yes - #endif - ], [ - AC_MSG_RESULT(yes) - size_max="SIZE_T_MAX" - ], [ - AC_MSG_RESULT(no) - size_max="(~(size_t)0)" - ]) - AC_DEFINE_UNQUOTED(SIZE_MAX, $size_max, [Maximum value for size_t]) -]) AC_MSG_CHECKING(for SSIZE_MAX) AC_EGREP_CPP(egrep_cpp_yes, [ #include #include @@ -772,12 +741,11 @@ #endif ], [ AC_MSG_RESULT(yes) ], [ AC_MSG_RESULT(no) - AC_DEFINE(SSIZE_MAX, [((ssize_t)(SIZE_MAX / 2))], - [Maximum value for ssize_t]) + AC_DEFINE(SSIZE_MAX, [(SIZE_MAX / 2)], [Maximum value for ssize_t]) ]) AC_MSG_CHECKING(for UINTPTR_MAX) AC_EGREP_CPP(egrep_cpp_yes, [ #include #include @@ -787,11 +755,13 @@ #endif ], [ AC_MSG_RESULT(yes) ], [ AC_MSG_RESULT(no) - AC_DEFINE(UINTPTR_MAX, [(~(uintptr_t)0)], [Maximum value for uintptr_t]) + AC_CHECK_SIZEOF(uintptr_t) + AC_DEFINE(UINTPTR_MAX, + [(SIZEOF_UINTPTR_T * CHAR_BIT)], [Maximum value for uintptr_t]) ]) AC_CHECK_HEADER(inttypes.h, [AC_DEFINE(OF_HAVE_INTTYPES_H, 1, [Whether we have inttypes.h])]) @@ -837,41 +807,10 @@ AC_MSG_RESULT($fp_endianess) AS_IF([test x"$fp_endianess" = x"unknown"], [ AC_MSG_ERROR( [Floating point implementation does not conform to IEEE 754!])]) -AC_MSG_CHECKING(for INFINITY) -AC_COMPILE_IFELSE([ - AC_LANG_PROGRAM([ - #include - #include - ], [ - printf("%f", INFINITY); - ]) -], [ - AC_MSG_RESULT(yes) -], [ - AC_MSG_RESULT(no) - - AC_MSG_CHECKING(for __builtin_inf) - AC_COMPILE_IFELSE([ - AC_LANG_PROGRAM([ - #include - ], [ - printf("%f", __builtin_inf()); - ]) - ], [ - AC_MSG_RESULT(yes) - AC_DEFINE(INFINITY, [(__builtin_inf())], - [Workaround for missing INFINITY]) - ], [ - AC_MSG_RESULT(no) - - AC_MSG_ERROR([Neither INFINITY or __builtin_inf was found!]) - ]) -]) - case "$host_cpu" in arm* | earm*) AC_MSG_CHECKING(for VFP2 or above) AC_COMPILE_IFELSE([ AC_LANG_PROGRAM([], [ @@ -950,15 +889,13 @@ ENCODINGS_SRCS="dummy.m" ]) AC_SUBST(ENCODINGS_SRCS) AS_IF([test x"$enable_shared" != x"no"], [ AC_SUBST(ENCODINGS_LIB_A, "encodings.lib.a") - AC_SUBST(ENCODINGS_ENCODINGS_LIB_A, "encodings/encodings.lib.a") ]) AS_IF([test x"$enable_static" = x"yes" -o x"$enable_shared" = x"no"], [ AC_SUBST(ENCODINGS_A, "encodings.a") - AC_SUBST(ENCODINGS_ENCODINGS_A, "encodings/encodings.a") ]) AC_CHECK_FUNCS(arc4random arc4random_buf getrandom random, break) AS_IF([test x"$host_os" != x"morphos"], [ @@ -1806,13 +1743,14 @@ OBJCFLAGS="$OBJCFLAGS -Wunreachable-code" AC_MSG_CHECKING(whether -Wunreachable-code can be used) AC_COMPILE_IFELSE([ AC_LANG_SOURCE([[ #include - - typedef void *SEL; - + + struct objc_selector; + typedef const struct objc_selector *SEL; + #ifdef __has_attribute # if __has_attribute(objc_root_class) __attribute__((__objc_root_class__)) # endif #endif @@ -1822,14 +1760,14 @@ __attribute__((__noreturn__)) #endif ; - (void)dealloc; @end - + @interface Foo: Object @end - + void test(void) { if (sizeof(int) == 4) __asm__ (""); @@ -1836,11 +1774,11 @@ else if (sizeof(int) == 8) __asm__ (""); else abort(); } - + /* * Unfortunately, this cannot be shorter, as it only * works when it is used inside a macro. */ #ifdef __clang__ @@ -1859,11 +1797,11 @@ \ abort(); \ \ [super dealloc]; #endif - + @implementation Foo - (void)dealloc { OF_DEALLOC_UNSUPPORTED } Index: src/OFBlock.m ================================================================== --- src/OFBlock.m +++ src/OFBlock.m @@ -191,13 +191,13 @@ #ifdef OF_HAVE_ATOMIC_OPS of_atomic_int_inc(&block->flags); #else unsigned hash = SPINLOCK_HASH(block); - OF_ENSURE(of_spinlock_lock(&blockSpinlocks[hash])); + OF_ENSURE(of_spinlock_lock(&blockSpinlocks[hash]) == 0); block->flags++; - OF_ENSURE(of_spinlock_unlock(&blockSpinlocks[hash])); + OF_ENSURE(of_spinlock_unlock(&blockSpinlocks[hash]) == 0); #endif } return block; } @@ -218,22 +218,22 @@ free(block); } #else unsigned hash = SPINLOCK_HASH(block); - OF_ENSURE(of_spinlock_lock(&blockSpinlocks[hash])); + OF_ENSURE(of_spinlock_lock(&blockSpinlocks[hash]) == 0); if ((--block->flags & OF_BLOCK_REFCOUNT_MASK) == 0) { - OF_ENSURE(of_spinlock_unlock(&blockSpinlocks[hash])); + OF_ENSURE(of_spinlock_unlock(&blockSpinlocks[hash]) == 0); if (block->flags & OF_BLOCK_HAS_COPY_DISPOSE) block->descriptor->dispose_helper(block); free(block); return; } - OF_ENSURE(of_spinlock_unlock(&blockSpinlocks[hash])); + OF_ENSURE(of_spinlock_unlock(&blockSpinlocks[hash]) == 0); #endif } void _Block_object_assign(void *dst_, const void *src_, const int flags_) @@ -283,32 +283,33 @@ *dst = src->forwarding; } #else unsigned hash = SPINLOCK_HASH(src); - OF_ENSURE(of_spinlock_lock(&byrefSpinlocks[hash])); + OF_ENSURE(of_spinlock_lock(&byrefSpinlocks[hash]) == 0); if (src->forwarding == src) src->forwarding = *dst; else { src->byref_dispose(*dst); free(*dst); *dst = src->forwarding; } - OF_ENSURE(of_spinlock_unlock(&byrefSpinlocks[hash])); + OF_ENSURE( + of_spinlock_unlock(&byrefSpinlocks[hash]) == 0); #endif } else *dst = src; #ifdef OF_HAVE_ATOMIC_OPS of_atomic_int_inc(&(*dst)->flags); #else unsigned hash = SPINLOCK_HASH(*dst); - OF_ENSURE(of_spinlock_lock(&byrefSpinlocks[hash])); + OF_ENSURE(of_spinlock_lock(&byrefSpinlocks[hash]) == 0); (*dst)->flags++; - OF_ENSURE(of_spinlock_unlock(&byrefSpinlocks[hash])); + OF_ENSURE(of_spinlock_unlock(&byrefSpinlocks[hash]) == 0); #endif break; } } @@ -343,20 +344,21 @@ free(object); } #else unsigned hash = SPINLOCK_HASH(object); - OF_ENSURE(of_spinlock_lock(&byrefSpinlocks[hash])); + OF_ENSURE(of_spinlock_lock(&byrefSpinlocks[hash]) == 0); if ((--object->flags & OF_BLOCK_REFCOUNT_MASK) == 0) { - OF_ENSURE(of_spinlock_unlock(&byrefSpinlocks[hash])); + OF_ENSURE( + of_spinlock_unlock(&byrefSpinlocks[hash]) == 0); if (object->flags & OF_BLOCK_HAS_COPY_DISPOSE) object->byref_dispose(object); free(object); } - OF_ENSURE(of_spinlock_unlock(&byrefSpinlocks[hash])); + OF_ENSURE(of_spinlock_unlock(&byrefSpinlocks[hash]) == 0); #endif break; } } @@ -363,12 +365,12 @@ @implementation OFBlock + (void)load { #ifndef OF_HAVE_ATOMIC_OPS for (size_t i = 0; i < NUM_SPINLOCKS; i++) - if (!of_spinlock_new(&blockSpinlocks[i]) || - !of_spinlock_new(&byrefSpinlocks[i])) + if (of_spinlock_new(&blockSpinlocks[i]) != 0 || + of_spinlock_new(&byrefSpinlocks[i]) != 0) @throw [OFInitializationFailedException exceptionWithClass: self]; #endif #ifdef OF_APPLE_RUNTIME Index: src/OFCondition.m ================================================================== --- src/OFCondition.m +++ src/OFCondition.m @@ -36,11 +36,11 @@ - (instancetype)init { self = [super init]; - if (!of_condition_new(&_condition)) { + if (of_condition_new(&_condition) != 0) { Class c = self.class; [self release]; @throw [OFInitializationFailedException exceptionWithClass: c]; } @@ -50,12 +50,14 @@ } - (void)dealloc { if (_conditionInitialized) { - if (!of_condition_free(&_condition)) { - OF_ENSURE(errno == EBUSY); + int error = of_condition_free(&_condition); + + if (error != 0) { + OF_ENSURE(error == EBUSY); @throw [OFConditionStillWaitingException exceptionWithCondition: self]; } } @@ -63,53 +65,60 @@ [super dealloc]; } - (void)wait { - if (!of_condition_wait(&_condition, &_mutex)) + int error = of_condition_wait(&_condition, &_mutex); + + if (error != 0) @throw [OFConditionWaitFailedException exceptionWithCondition: self - errNo: errno]; + errNo: error]; } #ifdef OF_AMIGAOS - (void)waitForConditionOrExecSignal: (ULONG *)signalMask { - if (!of_condition_wait_or_signal(&_condition, &_mutex, signalMask)) + int error = of_condition_wait_or_signal(&_condition, &_mutex, + signalMask); + + if (error != 0) @throw [OFConditionWaitFailedException exceptionWithCondition: self - errNo: errno]; + errNo: error]; } #endif - (bool)waitForTimeInterval: (of_time_interval_t)timeInterval { - if (!of_condition_timed_wait(&_condition, &_mutex, timeInterval)) { - if (errno == ETIMEDOUT) - return false; - else - @throw [OFConditionWaitFailedException - exceptionWithCondition: self - errNo: errno]; - } + int error = of_condition_timed_wait(&_condition, &_mutex, timeInterval); + + if (error == ETIMEDOUT) + return false; + + if (error != 0) + @throw [OFConditionWaitFailedException + exceptionWithCondition: self + errNo: error]; return true; } #ifdef OF_AMIGAOS - (bool)waitForTimeInterval: (of_time_interval_t)timeInterval orExecSignal: (ULONG *)signalMask { - if (!of_condition_timed_wait_or_signal(&_condition, &_mutex, - timeInterval, signalMask)) { - if (errno == ETIMEDOUT) - return false; - else - @throw [OFConditionWaitFailedException - exceptionWithCondition: self - errNo: errno]; - } + int error = of_condition_timed_wait_or_signal(&_condition, &_mutex, + timeInterval, signalMask); + + if (error == ETIMEDOUT) + return false; + + if (error != 0) + @throw [OFConditionWaitFailedException + exceptionWithCondition: self + errNo: error]; return true; } #endif @@ -127,19 +136,23 @@ } #endif - (void)signal { - if (!of_condition_signal(&_condition)) + int error = of_condition_signal(&_condition); + + if (error != 0) @throw [OFConditionSignalFailedException exceptionWithCondition: self - errNo: errno]; + errNo: error]; } - (void)broadcast { - if (!of_condition_broadcast(&_condition)) + int error = of_condition_broadcast(&_condition); + + if (error != 0) @throw [OFConditionBroadcastFailedException exceptionWithCondition: self - errNo: errno]; + errNo: error]; } @end Index: src/OFDNSResolverSettings.m ================================================================== --- src/OFDNSResolverSettings.m +++ src/OFDNSResolverSettings.m @@ -46,19 +46,22 @@ /* Newer versions of libctru started using id as a parameter name. */ # define id id_3ds # include <3ds.h> # undef id #endif + +#ifdef OF_MORPHOS +# include +# include +# include +#endif #import "socket_helpers.h" #if defined(OF_HAIKU) # define HOSTS_PATH @"/system/settings/network/hosts" # define RESOLV_CONF_PATH @"/system/settings/network/resolv.conf" -#elif defined(OF_MORPHOS) -# define HOSTS_PATH @"ENV:sys/net/hosts" -# define RESOLV_CONF_PATH @"ENV:sys/net/resolv.conf" #elif defined(OF_AMIGAOS4) # define HOSTS_PATH @"DEVS:Internet/hosts" #elif defined(OF_AMIGAOS) # define HOSTS_PATH @"AmiTCP:db/hosts" # define RESOLV_CONF_PATH @"AmiTCP:db/resolv.conf" @@ -65,42 +68,118 @@ #else # define HOSTS_PATH @"/etc/hosts" # define RESOLV_CONF_PATH @"/etc/resolv.conf" #endif -#ifndef OF_WII static OFString * -domainFromHostname(void) +domainFromHostname(OFString *hostname) { - char hostname[256]; - OFString *domain, *ret; - - if (gethostname(hostname, 256) != 0) + if (hostname == nil) return nil; - domain = [OFString stringWithCString: hostname - encoding: [OFLocale encoding]]; - @try { - of_socket_address_parse_ip(domain, 0); + of_socket_address_parse_ip(hostname, 0); /* * If we are still here, the host name is a valid IP address. * We can't use that as local domain. */ return nil; } @catch (OFInvalidFormatException *e) { /* Not an IP address -> we can use it if it contains a dot. */ - size_t pos = [domain rangeOfString: @"."].location; + size_t pos = [hostname rangeOfString: @"."].location; if (pos == OF_NOT_FOUND) return nil; - ret = [domain substringFromIndex: pos + 1]; + return [hostname substringFromIndex: pos + 1]; + } +} + +#if !defined(OF_WII) && !defined(OF_MORPHOS) +static OFString * +obtainHostname(void) +{ + char hostname[256]; + + if (gethostname(hostname, 256) != 0) + return nil; + + return [OFString stringWithCString: hostname + encoding: [OFLocale encoding]]; +} +#endif + +#ifdef OF_MORPHOS +static OFString * +arexxCommand(const char *port, const char *command) +{ + struct Library *RexxSysBase; + struct MsgPort *replyPort = NULL; + struct RexxMsg *msg = NULL; + + if ((RexxSysBase = OpenLibrary("rexxsyslib.library", 36)) == NULL) + return nil; + + @try { + struct MsgPort *rexxPort; + + if ((replyPort = CreateMsgPort()) == NULL) + return nil; + + if ((msg = CreateRexxMsg(replyPort, NULL, port)) == NULL) + return nil; + + msg->rm_Action = RXCOMM | RXFF_RESULT; + + if ((msg->rm_Args[0] = (char *)CreateArgstring( + command, strlen(command))) == NULL) + return nil; + + Forbid(); + + if ((rexxPort = FindPort(port)) == NULL) { + Permit(); + return nil; + } + + PutMsg(rexxPort, &msg->rm_Node); + Permit(); + WaitPort(replyPort); + GetMsg(replyPort); + + if (msg->rm_Result1 != RC_OK || msg->rm_Result2 == 0) + return nil; + + return [OFString stringWithCString: (char *)msg->rm_Result2 + encoding: [OFLocale encoding]]; + } @finally { + if (msg != NULL) { + if (msg->rm_Args[0] != NULL) + DeleteArgstring(msg->rm_Args[0]); + if (msg->rm_Result2 != 0) + DeleteArgstring((char *)msg->rm_Result2); + + DeleteRexxMsg(msg); + } + + if (replyPort != NULL) + DeleteMsgPort(replyPort); + + CloseLibrary(RexxSysBase); } +} - return ret; +static OFArray OF_GENERIC(OFString *) * +parseNetStackArray(OFString *string) +{ + if (![string hasPrefix: @"["] || ![string hasSuffix: @"]"]) + return nil; + + string = [string substringWithRange: of_range(1, string.length - 2)]; + + return [string componentsSeparatedByString: @"|"]; } #endif @implementation OFDNSResolverSettings - (void)dealloc @@ -161,21 +240,19 @@ #else _configReloadInterval = 0; #endif } -#if defined(OF_HAVE_FILES) && !defined(OF_NINTENDO_3DS) +#if defined(OF_HAVE_FILES) && !defined(OF_MORPHOS) && !defined(OF_NINTENDO_3DS) - (void)parseHosts: (OFString *)path { void *pool = objc_autoreleasePoolPush(); OFCharacterSet *whitespaceCharacterSet = [OFCharacterSet whitespaceCharacterSet]; OFMutableDictionary *staticHosts; OFFile *file; OFString *line; - OFEnumerator *enumerator; - OFMutableArray *addresses; @try { file = [OFFile fileWithPath: path mode: @"r"]; } @catch (OFOpenItemFailedException *e) { @@ -184,11 +261,10 @@ } staticHosts = [OFMutableDictionary dictionary]; while ((line = [file readLine]) != nil) { - void *pool2 = objc_autoreleasePoolPush(); OFArray *components, *hosts; size_t pos; OFString *address; pos = [line rangeOfString: @"#"].location; @@ -197,41 +273,34 @@ components = [line componentsSeparatedByCharactersInSet: whitespaceCharacterSet options: OF_STRING_SKIP_EMPTY]; - if (components.count < 2) { - objc_autoreleasePoolPop(pool2); + if (components.count < 2) continue; - } address = components.firstObject; hosts = [components objectsInRange: of_range(1, components.count - 1)]; for (OFString *host in hosts) { - addresses = [staticHosts objectForKey: host]; + OFMutableArray *addresses = + [staticHosts objectForKey: host]; if (addresses == nil) { addresses = [OFMutableArray array]; [staticHosts setObject: addresses forKey: host]; } [addresses addObject: address]; } - - objc_autoreleasePoolPop(pool2); } - - enumerator = [staticHosts objectEnumerator]; - while ((addresses = [enumerator nextObject]) != nil) + for (OFMutableArray *addresses in [staticHosts objectEnumerator]) [addresses makeImmutable]; [staticHosts makeImmutable]; - - [_staticHosts release]; _staticHosts = [staticHosts copy]; objc_autoreleasePoolPop(pool); } @@ -386,10 +455,61 @@ _localDomain = [[OFString alloc] initWithCString: fixedInfo->DomainName encoding: encoding]; } #endif + +#ifdef OF_MORPHOS +- (void)obtainMorphOSSystemConfig +{ + void *pool = objc_autoreleasePoolPush(); + OFMutableDictionary *staticHosts; + + _nameServers = [parseNetStackArray(arexxCommand("NETSTACK", + "QUERY NAMESERVERS")) copy]; + _localDomain = [domainFromHostname(arexxCommand("NETSTACK", + "QUERY HOSTNAME")) copy]; + _searchDomains = [parseNetStackArray(arexxCommand("NETSTACK", + "QUERY DOMAINS")) copy]; + + staticHosts = [OFMutableDictionary dictionary]; + + for (OFString *entry in parseNetStackArray(arexxCommand("NETSTACK", + "QUERY HOSTS"))) { + OFArray *components = [entry componentsSeparatedByString: @" "]; + OFString *address; + OFArray *hosts; + + if (components.count < 2) + continue; + + address = components.firstObject; + hosts = [components objectsInRange: + of_range(1, components.count - 1)]; + + for (OFString *host in hosts) { + OFMutableArray *addresses = + [staticHosts objectForKey: host]; + + if (addresses == nil) { + addresses = [OFMutableArray array]; + [staticHosts setObject: addresses + forKey: host]; + } + + [addresses addObject: address]; + } + } + for (OFMutableArray *addresses in [staticHosts objectEnumerator]) + [addresses makeImmutable]; + + [staticHosts makeImmutable]; + _staticHosts = [staticHosts copy]; + + objc_autoreleasePoolPop(pool); +} +#endif #ifdef OF_AMIGAOS4 - (void)obtainAmigaOS4SystemConfig { OFMutableArray *nameServers = [OFMutableArray array]; @@ -508,10 +628,12 @@ if (path != nil) [self parseHosts: path]; # endif [self obtainWindowsSystemConfig]; +#elif defined(OF_MORPHOS) + [self obtainMorphOSSystemConfig]; #elif defined(OF_AMIGAOS4) [self parseHosts: HOSTS_PATH]; [self obtainAmigaOS4SystemConfig]; #elif defined(OF_NINTENDO_3DS) [self obtainNintendo3DSSytemConfig]; @@ -539,13 +661,13 @@ initWithObjects: @"127.0.0.1", @"::1", nil]; #else _nameServers = [[OFArray alloc] initWithObject: @"127.0.0.1"]; #endif -#ifndef OF_WII +#if !defined(OF_WII) && !defined(OF_MORPHOS) if (_localDomain == nil) - _localDomain = [domainFromHostname() copy]; + _localDomain = [domainFromHostname(obtainHostname()) copy]; #endif if (_searchDomains == nil) { if (_localDomain != nil) _searchDomains = [[OFArray alloc] Index: src/OFDate.m ================================================================== --- src/OFDate.m +++ src/OFDate.m @@ -108,10 +108,16 @@ } #if (!defined(HAVE_GMTIME_R) || !defined(HAVE_LOCALTIME_R)) && \ defined(OF_HAVE_THREADS) static OFMutex *mutex; + +static void +releaseMutex(void) +{ + [mutex release]; +} #endif #ifdef OF_WINDOWS static __time64_t (*func__mktime64)(struct tm *); #endif @@ -344,10 +350,11 @@ placeholder.isa = [OFDatePlaceholder class]; #if (!defined(HAVE_GMTIME_R) || !defined(HAVE_LOCALTIME_R)) && \ defined(OF_HAVE_THREADS) mutex = [[OFMutex alloc] init]; + atexit(releaseMutex); #endif #ifdef OF_WINDOWS if ((module = LoadLibrary("msvcrt.dll")) != NULL) func__mktime64 = (__time64_t (*)(struct tm *)) Index: src/OFFileURLHandler.m ================================================================== --- src/OFFileURLHandler.m +++ src/OFFileURLHandler.m @@ -83,11 +83,11 @@ # ifdef OF_AMIGAOS4 # define DeleteFile(path) Delete(path) # endif #endif -#if defined(OF_WINDOWS) || (defined(OF_AMIGAOS) && !defined(OF_MORPHOS)) +#if defined(OF_WINDOWS) || defined(OF_AMIGAOS) typedef struct { of_offset_t st_size; unsigned int st_mode; of_time_interval_t st_atime, st_mtime, st_ctime; # ifdef OF_WINDOWS @@ -107,13 +107,25 @@ # define S_ISLNK(mode) (mode & S_IFLNK) #endif #if defined(OF_FILE_MANAGER_SUPPORTS_OWNER) && defined(OF_HAVE_THREADS) static OFMutex *passwdMutex; + +static void +releasePasswdMutex(void) +{ + [passwdMutex release]; +} #endif #if !defined(HAVE_READDIR_R) && defined(OF_HAVE_THREADS) && !defined(OF_WINDOWS) static OFMutex *readdirMutex; + +static void +releaseReaddirMutex(void) +{ + [readdirMutex release]; +} #endif #ifdef OF_WINDOWS static int (*func__wutime64)(const wchar_t *, struct __utimbuf64 *); static WINAPI BOOLEAN (*func_CreateSymbolicLinkW)(LPCWSTR, LPCWSTR, DWORD); @@ -127,74 +139,60 @@ { return (double)((int64_t)filetime->dwHighDateTime << 32 | filetime->dwLowDateTime) / 10000000.0 - 11644473600.0; } -static void -setErrno(void) +static int +retrieveError(void) { switch (GetLastError()) { case ERROR_FILE_NOT_FOUND: case ERROR_PATH_NOT_FOUND: case ERROR_NO_MORE_FILES: - errno = ENOENT; - return; + return ENOENT; case ERROR_ACCESS_DENIED: - errno = EACCES; - return; + return EACCES; case ERROR_DIRECTORY: - errno = ENOTDIR; - return; + return ENOTDIR; case ERROR_NOT_READY: - errno = EBUSY; - return; + return EBUSY; + default: + return EIO; } - - errno = 0; } #endif #ifdef OF_AMIGAOS -static void -setErrno(void) +static int +retrieveError(void) { switch (IoErr()) { case ERROR_DELETE_PROTECTED: case ERROR_READ_PROTECTED: case ERROR_WRITE_PROTECTED: - errno = EACCES; - break; + return EACCES; case ERROR_DISK_NOT_VALIDATED: case ERROR_OBJECT_IN_USE: - errno = EBUSY; - break; + return EBUSY; case ERROR_OBJECT_EXISTS: - errno = EEXIST; - break; + return EEXIST; case ERROR_DIR_NOT_FOUND: case ERROR_NO_MORE_ENTRIES: case ERROR_OBJECT_NOT_FOUND: - errno = ENOENT; - break; + return ENOENT; case ERROR_NO_FREE_STORE: - errno = ENOMEM; - break; + return ENOMEM; case ERROR_DISK_FULL: - errno = ENOSPC; - break; + return ENOSPC; case ERROR_DIRECTORY_NOT_EMPTY: - errno = ENOTEMPTY; - break; + return ENOTEMPTY; case ERROR_DISK_WRITE_PROTECTED: - errno = EROFS; - break; + return EROFS; case ERROR_RENAME_ACROSS_DEVICES: - errno = EXDEV; - break; + return EXDEV; default: - errno = 0; - break; + return EIO; } } #endif static int @@ -210,14 +208,12 @@ else success = GetFileAttributesExA( [path cStringWithEncoding: [OFLocale encoding]], GetFileExInfoStandard, &data); - if (!success) { - setErrno(); - return -1; - } + if (!success) + return retrieveError(); buffer->st_size = (uint64_t)data.nFileSizeHigh << 32 | data.nFileSizeLow; if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) @@ -229,22 +225,18 @@ */ WIN32_FIND_DATAW findData; HANDLE findHandle; if ((findHandle = FindFirstFileW(path.UTF16String, - &findData)) == INVALID_HANDLE_VALUE) { - setErrno(); - return -1; - } + &findData)) == INVALID_HANDLE_VALUE) + return retrieveError(); @try { if (!(findData.dwFileAttributes & - FILE_ATTRIBUTE_REPARSE_POINT)) { + FILE_ATTRIBUTE_REPARSE_POINT)) /* Race? Indicate to try again. */ - errno = EAGAIN; - return -1; - } + return EAGAIN; buffer->st_mode = (findData.dwReserved0 == IO_REPARSE_TAG_SYMLINK ? S_IFLNK : S_IFREG); } @finally { @@ -261,11 +253,11 @@ buffer->st_ctime = buffer->st_birthtime = filetimeToTimeInterval(&data.ftCreationTime); buffer->fileAttributes = data.dwFileAttributes; return 0; -#elif defined(OF_AMIGAOS) && !defined(OF_MORPHOS) +#elif defined(OF_AMIGAOS) BPTR lock; # ifdef OF_AMIGAOS4 struct ExamineData *ed; # else struct FileInfoBlock fib; @@ -273,33 +265,37 @@ of_time_interval_t timeInterval; struct Locale *locale; struct DateStamp *date; if ((lock = Lock([path cStringWithEncoding: [OFLocale encoding]], - SHARED_LOCK)) == 0) { - setErrno(); - return -1; - } + SHARED_LOCK)) == 0) + return retrieveError(); -# ifdef OF_AMIGAOS4 +# if defined(OF_MORPHOS) + if (!Examine64(lock, &fib, TAG_DONE)) { +# elif defined(OF_AMIGAOS4) if ((ed = ExamineObjectTags(EX_FileLockInput, lock, TAG_END)) == NULL) { # else if (!Examine(lock, &fib)) { # endif + int error = retrieveError(); UnLock(lock); - - errno = 0; - return -1; + return error; } UnLock(lock); -# ifdef OF_AMIGAOS4 +# if defined(OF_MORPHOS) + buffer->st_size = fib.fib_Size64; +# elif defined(OF_AMIGAOS4) buffer->st_size = ed->FileSize; - buffer->st_mode = (EXD_IS_DIRECTORY(ed) ? S_IFDIR : S_IFREG); # else buffer->st_size = fib.fib_Size; +# endif +# ifdef OF_AMIGAOS4 + buffer->st_mode = (EXD_IS_DIRECTORY(ed) ? S_IFDIR : S_IFREG); +# else buffer->st_mode = (fib.fib_DirEntryType > 0 ? S_IFDIR : S_IFREG); # endif timeInterval = 252460800; /* 1978-01-01 */ @@ -327,26 +323,38 @@ FreeDosObject(DOS_EXAMINEDATA, ed); # endif return 0; #elif defined(HAVE_STAT64) - return stat64([path cStringWithEncoding: [OFLocale encoding]], buffer); + if (stat64([path cStringWithEncoding: [OFLocale encoding]], + buffer) != 0) + return errno; + + return 0; #else - return stat([path cStringWithEncoding: [OFLocale encoding]], buffer); + if (stat([path cStringWithEncoding: [OFLocale encoding]], buffer) != 0) + return errno; + + return 0; #endif } static int of_lstat(OFString *path, of_stat_t *buffer) { #if defined(HAVE_LSTAT) && !defined(OF_WINDOWS) && !defined(OF_AMIGAOS) && \ !defined(OF_NINTENDO_3DS) && !defined(OF_WII) # ifdef HAVE_LSTAT64 - return lstat64([path cStringWithEncoding: [OFLocale encoding]], buffer); + if (lstat64([path cStringWithEncoding: [OFLocale encoding]], + buffer) != 0) + return errno; # else - return lstat([path cStringWithEncoding: [OFLocale encoding]], buffer); + if (lstat([path cStringWithEncoding: [OFLocale encoding]], buffer) != 0) + return errno; # endif + + return 0; #else return of_stat(path, buffer); #endif } @@ -487,11 +495,11 @@ if ((handle = CreateFileW(path.UTF16String, 0, (FILE_SHARE_READ | FILE_SHARE_WRITE), NULL, OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT, NULL)) == INVALID_HANDLE_VALUE) @throw [OFRetrieveItemAttributesFailedException exceptionWithURL: URL - errNo: 0]; + errNo: retrieveError()]; @try { union { char bytes[MAXIMUM_REPARSE_DATA_BUFFER_SIZE]; REPARSE_DATA_BUFFER data; @@ -503,16 +511,16 @@ if (!DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, NULL, 0, buffer.bytes, MAXIMUM_REPARSE_DATA_BUFFER_SIZE, &size, NULL)) @throw [OFRetrieveItemAttributesFailedException exceptionWithURL: URL - errNo: 0]; + errNo: retrieveError()]; if (buffer.data.ReparseTag != IO_REPARSE_TAG_SYMLINK) @throw [OFRetrieveItemAttributesFailedException exceptionWithURL: URL - errNo: 0]; + errNo: retrieveError()]; # define slrb buffer.data.SymbolicLinkReparseBuffer tmp = slrb.PathBuffer + (slrb.SubstituteNameOffset / sizeof(wchar_t)); @@ -544,13 +552,15 @@ if (self != [OFFileURLHandler class]) return; #if defined(OF_FILE_MANAGER_SUPPORTS_OWNER) && defined(OF_HAVE_THREADS) passwdMutex = [[OFMutex alloc] init]; + atexit(releasePasswdMutex); #endif #if !defined(HAVE_READDIR_R) && !defined(OF_WINDOWS) && defined(OF_HAVE_THREADS) readdirMutex = [[OFMutex alloc] init]; + atexit(releaseReaddirMutex); #endif #ifdef OF_WINDOWS if ((module = LoadLibrary("msvcrt.dll")) != NULL) func__wutime64 = (int (*)(const wchar_t *, @@ -576,11 +586,11 @@ + (bool)of_directoryExistsAtPath: (OFString *)path { of_stat_t s; - if (of_stat(path, &s) == -1) + if (of_stat(path, &s) != 0) return false; return S_ISDIR(s.st_mode); } @@ -600,10 +610,11 @@ - (of_file_attributes_t)attributesOfItemAtURL: (OFURL *)URL { of_mutable_file_attributes_t ret = [OFMutableDictionary dictionary]; void *pool = objc_autoreleasePoolPush(); OFString *path; + int error; of_stat_t s; if (URL == nil) @throw [OFInvalidArgumentException exception]; @@ -610,14 +621,14 @@ if (![[URL scheme] isEqual: _scheme]) @throw [OFInvalidArgumentException exception]; path = URL.fileSystemRepresentation; - if (of_lstat(path, &s) == -1) + if ((error = of_lstat(path, &s)) != 0) @throw [OFRetrieveItemAttributesFailedException exceptionWithURL: URL - errNo: errno]; + errNo: error]; if (s.st_size < 0) @throw [OFOutOfRangeException exception]; [ret setObject: [NSNumber numberWithUnsignedLongLong: s.st_size] @@ -716,20 +727,22 @@ date.ds_Days = modificationTime / 86400; date.ds_Minute = ((LONG)modificationTime % 86400) / 60; date.ds_Tick = fmod(modificationTime, 60) * TICKS_PER_SECOND; +# ifdef OF_AMIGAOS4 + if (!SetDate([path cStringWithEncoding: [OFLocale encoding]], + &date) != 0) +# else if (!SetFileDate([path cStringWithEncoding: [OFLocale encoding]], - &date) != 0) { - setErrno(); - + &date) != 0) +# endif @throw [OFSetItemAttributesFailedException exceptionWithURL: URL attributes: attributes failedAttribute: attributeKey - errNo: errno]; - } + errNo: retrieveError()]; #else of_time_interval_t lastAccessTime = lastAccessDate.timeIntervalSince1970; of_time_interval_t modificationTime = modificationDate.timeIntervalSince1970; @@ -918,11 +931,11 @@ @throw [OFInvalidArgumentException exception]; if (![URL.scheme isEqual: _scheme]) @throw [OFInvalidArgumentException exception]; - if (of_stat(URL.fileSystemRepresentation, &s) == -1) { + if (of_stat(URL.fileSystemRepresentation, &s) != 0) { objc_autoreleasePoolPop(pool); return false; } ret = S_ISREG(s.st_mode); @@ -942,11 +955,11 @@ @throw [OFInvalidArgumentException exception]; if (![URL.scheme isEqual: _scheme]) @throw [OFInvalidArgumentException exception]; - if (of_stat(URL.fileSystemRepresentation, &s) == -1) { + if (of_stat(URL.fileSystemRepresentation, &s) != 0) { objc_autoreleasePoolPop(pool); return false; } ret = S_ISDIR(s.st_mode); @@ -984,17 +997,14 @@ errNo: errno]; #elif defined(OF_AMIGAOS) BPTR lock; if ((lock = CreateDir( - [path cStringWithEncoding: [OFLocale encoding]])) == 0) { - setErrno(); - + [path cStringWithEncoding: [OFLocale encoding]])) == 0) @throw [OFCreateDirectoryFailedException exceptionWithURL: URL - errNo: errno]; - } + errNo: retrieveError()]; UnLock(lock); #else if (mkdir([path cStringWithEncoding: [OFLocale encoding]], 0777) != 0) @throw [OFCreateDirectoryFailedException @@ -1026,21 +1036,15 @@ if ([OFSystemInfo isWindowsNT]) { WIN32_FIND_DATAW fd; if ((handle = FindFirstFileW(path.UTF16String, - &fd)) == INVALID_HANDLE_VALUE) { - int errNo = 0; - - if (GetLastError() == ERROR_FILE_NOT_FOUND) - errNo = ENOENT; - + &fd)) == INVALID_HANDLE_VALUE) @throw [OFOpenItemFailedException exceptionWithURL: URL mode: nil - errNo: errNo]; - } + errNo: retrieveError()]; @try { do { OFString *file; @@ -1059,31 +1063,25 @@ if (GetLastError() != ERROR_NO_MORE_FILES) @throw [OFReadFailedException exceptionWithObject: self requestedLength: 0 - errNo: EIO]; + errNo: retrieveError()]; } @finally { FindClose(handle); } } else { of_string_encoding_t encoding = [OFLocale encoding]; WIN32_FIND_DATA fd; if ((handle = FindFirstFileA( [path cStringWithEncoding: encoding], &fd)) == - INVALID_HANDLE_VALUE) { - int errNo = 0; - - if (GetLastError() == ERROR_FILE_NOT_FOUND) - errNo = ENOENT; - + INVALID_HANDLE_VALUE) @throw [OFOpenItemFailedException exceptionWithURL: URL mode: nil - errNo: errNo]; - } + errNo: retrieveError()]; @try { do { OFString *file; @@ -1103,27 +1101,25 @@ if (GetLastError() != ERROR_NO_MORE_FILES) @throw [OFReadFailedException exceptionWithObject: self requestedLength: 0 - errNo: EIO]; + errNo: retrieveError()]; } @finally { FindClose(handle); } } #elif defined(OF_AMIGAOS) of_string_encoding_t encoding = [OFLocale encoding]; BPTR lock; if ((lock = Lock([path cStringWithEncoding: encoding], - SHARED_LOCK)) == 0) { - setErrno(); - - @throw [OFOpenItemFailedException exceptionWithURL: URL - mode: nil - errNo: errno]; - } + SHARED_LOCK)) == 0) + @throw [OFOpenItemFailedException + exceptionWithURL: URL + mode: nil + errNo: retrieveError()]; @try { # ifdef OF_AMIGAOS4 struct ExamineData *ed; APTR context; @@ -1132,11 +1128,11 @@ EX_DoCurrentDir, TRUE, EX_DataFields, EXF_NAME, TAG_END)) == NULL) @throw [OFOpenItemFailedException exceptionWithURL: URL mode: nil - errNo: 0]; + errNo: retrieveError()]; @try { while ((ed = ExamineDir(context)) != NULL) { OFString *file = [[OFString alloc] initWithCString: ed->Name @@ -1156,11 +1152,11 @@ if (!Examine(lock, &fib)) @throw [OFOpenItemFailedException exceptionWithURL: URL mode: nil - errNo: 0]; + errNo: retrieveError()]; while (ExNext(lock, &fib)) { OFString *file = [[OFString alloc] initWithCString: fib.fib_FileName encoding: encoding]; @@ -1175,11 +1171,11 @@ if (IoErr() != ERROR_NO_MORE_ENTRIES) @throw [OFReadFailedException exceptionWithObject: self requestedLength: 0 - errNo: EIO]; + errNo: retrieveError()]; } @finally { UnLock(lock); } #else of_string_encoding_t encoding = [OFLocale encoding]; @@ -1258,10 +1254,11 @@ - (void)removeItemAtURL: (OFURL *)URL { void *pool = objc_autoreleasePoolPush(); OFString *path; + int error; of_stat_t s; if (URL == nil) @throw [OFInvalidArgumentException exception]; @@ -1268,13 +1265,13 @@ if (![URL.scheme isEqual: _scheme]) @throw [OFInvalidArgumentException exception]; path = URL.fileSystemRepresentation; - if (of_lstat(path, &s) != 0) + if ((error = of_lstat(path, &s)) != 0) @throw [OFRemoveItemFailedException exceptionWithURL: URL - errNo: errno]; + errNo: error]; if (S_ISDIR(s.st_mode)) { OFArray *contents; @try { @@ -1336,16 +1333,14 @@ errNo: errno]; #endif } #ifdef OF_AMIGAOS - if (!DeleteFile([path cStringWithEncoding: [OFLocale encoding]])) { - setErrno(); - - @throw [OFRemoveItemFailedException exceptionWithURL: URL - errNo: errno]; - } + if (!DeleteFile([path cStringWithEncoding: [OFLocale encoding]])) + @throw [OFRemoveItemFailedException + exceptionWithURL: URL + errNo: retrieveError()]; #endif objc_autoreleasePoolPop(pool); } @@ -1383,11 +1378,11 @@ if (!func_CreateHardLinkW(destinationPath.UTF16String, sourcePath.UTF16String, NULL)) @throw [OFLinkFailedException exceptionWithSourceURL: source destinationURL: destination - errNo: 0]; + errNo: retrieveError()]; # endif objc_autoreleasePoolPop(pool); } #endif @@ -1423,11 +1418,11 @@ if (!func_CreateSymbolicLinkW(path.UTF16String, target.UTF16String, 0)) @throw [OFCreateSymbolicLinkFailedException exceptionWithURL: URL target: target - errNo: 0]; + errNo: retrieveError()]; # endif objc_autoreleasePoolPop(pool); } #endif @@ -1453,18 +1448,15 @@ of_string_encoding_t encoding = [OFLocale encoding]; if (!Rename([source.fileSystemRepresentation cStringWithEncoding: encoding], [destination.fileSystemRepresentation - cStringWithEncoding: encoding])) { - setErrno(); - + cStringWithEncoding: encoding])) @throw [OFMoveItemFailedException exceptionWithSourceURL: source destinationURL: destination - errNo: errno]; - } + errNo: retrieveError()]; #else int status; # ifdef OF_WINDOWS if ([OFSystemInfo isWindowsNT]) Index: src/OFMutex.m ================================================================== --- src/OFMutex.m +++ src/OFMutex.m @@ -37,11 +37,11 @@ - (instancetype)init { self = [super init]; - if (!of_mutex_new(&_mutex)) { + if (of_mutex_new(&_mutex) != 0) { Class c = self.class; [self release]; @throw [OFInitializationFailedException exceptionWithClass: c]; } @@ -51,12 +51,14 @@ } - (void)dealloc { if (_initialized) { - if (!of_mutex_free(&_mutex)) { - OF_ENSURE(errno == EBUSY); + int error = of_mutex_free(&_mutex); + + if (error != 0) { + OF_ENSURE(error == EBUSY); @throw [OFStillLockedException exceptionWithLock: self]; } } @@ -65,33 +67,39 @@ [super dealloc]; } - (void)lock { - if (!of_mutex_lock(&_mutex)) + int error = of_mutex_lock(&_mutex); + + if (error != 0) @throw [OFLockFailedException exceptionWithLock: self - errNo: errno]; + errNo: error]; } - (bool)tryLock { - if (!of_mutex_trylock(&_mutex)) { - if (errno == EBUSY) + int error = of_mutex_trylock(&_mutex); + + if (error != 0) { + if (error == EBUSY) return false; else @throw [OFLockFailedException exceptionWithLock: self - errNo: errno]; + errNo: error]; } return true; } - (void)unlock { - if (!of_mutex_unlock(&_mutex)) + int error = of_mutex_unlock(&_mutex); + + if (error != 0) @throw [OFUnlockFailedException exceptionWithLock: self - errNo: errno]; + errNo: error]; } - (OFString *)description { if (_name == nil) Index: src/OFObject.m ================================================================== --- src/OFObject.m +++ src/OFObject.m @@ -309,12 +309,12 @@ } ((struct pre_ivar *)instance)->retainCount = 1; #if !defined(OF_HAVE_ATOMIC_OPS) && !defined(OF_AMIGAOS) - if OF_UNLIKELY (!of_spinlock_new( - &((struct pre_ivar *)instance)->retainCountSpinlock)) { + if OF_UNLIKELY (of_spinlock_new( + &((struct pre_ivar *)instance)->retainCountSpinlock) != 0) { free(instance); @throw [OFInitializationFailedException exceptionWithClass: class]; } #endif @@ -1119,13 +1119,13 @@ PRE_IVARS->retainCount++; # ifndef OF_AMIGAOS_M68K Permit(); # endif #else - OF_ENSURE(of_spinlock_lock(&PRE_IVARS->retainCountSpinlock)); + OF_ENSURE(of_spinlock_lock(&PRE_IVARS->retainCountSpinlock) == 0); PRE_IVARS->retainCount++; - OF_ENSURE(of_spinlock_unlock(&PRE_IVARS->retainCountSpinlock)); + OF_ENSURE(of_spinlock_unlock(&PRE_IVARS->retainCountSpinlock) == 0); #endif return self; } @@ -1155,13 +1155,13 @@ if (retainCount == 0) [self dealloc]; #else int retainCount; - OF_ENSURE(of_spinlock_lock(&PRE_IVARS->retainCountSpinlock)); + OF_ENSURE(of_spinlock_lock(&PRE_IVARS->retainCountSpinlock) == 0); retainCount = --PRE_IVARS->retainCount; - OF_ENSURE(of_spinlock_unlock(&PRE_IVARS->retainCountSpinlock)); + OF_ENSURE(of_spinlock_unlock(&PRE_IVARS->retainCountSpinlock) == 0); if (retainCount == 0) [self dealloc]; #endif } Index: src/OFRecursiveMutex.m ================================================================== --- src/OFRecursiveMutex.m +++ src/OFRecursiveMutex.m @@ -37,11 +37,11 @@ - (instancetype)init { self = [super init]; - if (!of_rmutex_new(&_rmutex)) { + if (of_rmutex_new(&_rmutex) != 0) { Class c = self.class; [self release]; @throw [OFInitializationFailedException exceptionWithClass: c]; } @@ -51,12 +51,14 @@ } - (void)dealloc { if (_initialized) { - if (!of_rmutex_free(&_rmutex)) { - OF_ENSURE(errno == EBUSY); + int error = of_rmutex_free(&_rmutex); + + if (error != 0) { + OF_ENSURE(error == EBUSY); @throw [OFStillLockedException exceptionWithLock: self]; } } @@ -65,33 +67,39 @@ [super dealloc]; } - (void)lock { - if (!of_rmutex_lock(&_rmutex)) + int error = of_rmutex_lock(&_rmutex); + + if (error != 0) @throw [OFLockFailedException exceptionWithLock: self - errNo: errno]; + errNo: error]; } - (bool)tryLock { - if (!of_rmutex_trylock(&_rmutex)) { - if (errno == EBUSY) + int error = of_rmutex_trylock(&_rmutex); + + if (error != 0) { + if (error == EBUSY) return false; else @throw [OFLockFailedException exceptionWithLock: self - errNo: errno]; + errNo: error]; } return true; } - (void)unlock { - if (!of_rmutex_unlock(&_rmutex)) + int error = of_rmutex_unlock(&_rmutex); + + if (error != 0) @throw [OFUnlockFailedException exceptionWithLock: self - errNo: errno]; + errNo: error]; } - (OFString *)description { if (_name == nil) Index: src/OFSecureData.m ================================================================== --- src/OFSecureData.m +++ src/OFSecureData.m @@ -121,21 +121,21 @@ # endif numPreallocatedPages--; # if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS) OF_ENSURE(of_tlskey_set(numPreallocatedPagesKey, - (void *)numPreallocatedPages)); + (void *)numPreallocatedPages) == 0); # endif page = preallocatedPages[numPreallocatedPages]; if (numPreallocatedPages == 0) { free(preallocatedPages); preallocatedPages = NULL; # if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS) OF_ENSURE(of_tlskey_set(preallocatedPagesKey, - preallocatedPages)); + preallocatedPages) == 0); # endif } return page; } @@ -171,14 +171,14 @@ lastPage = page; if (firstPage == NULL) firstPage = page; # else - OF_ENSURE(of_tlskey_set(lastPageKey, page)); + OF_ENSURE(of_tlskey_set(lastPageKey, page) == 0); if (of_tlskey_get(firstPageKey) == NULL) - OF_ENSURE(of_tlskey_set(firstPageKey, page)); + OF_ENSURE(of_tlskey_set(firstPageKey, page) == 0); # endif return page; } @@ -207,13 +207,13 @@ firstPage = page->next; if (lastPage == page) lastPage = page->previous; # else if (of_tlskey_get(firstPageKey) == page) - OF_ENSURE(of_tlskey_set(firstPageKey, page->next)); + OF_ENSURE(of_tlskey_set(firstPageKey, page->next) == 0); if (of_tlskey_get(lastPageKey) == page) - OF_ENSURE(of_tlskey_set(lastPageKey, page->previous)); + OF_ENSURE(of_tlskey_set(lastPageKey, page->previous) == 0); # endif free(page); } @@ -272,13 +272,14 @@ + (void)initialize { if (self != [OFSecureData class]) return; - if (!of_tlskey_new(&firstPageKey) || !of_tlskey_new(&lastPageKey) || - !of_tlskey_new(&preallocatedPagesKey) || - !of_tlskey_new(&numPreallocatedPagesKey)) + if (of_tlskey_new(&firstPageKey) != 0 || + of_tlskey_new(&lastPageKey) != 0 || + of_tlskey_new(&preallocatedPagesKey) != 0 || + of_tlskey_new(&numPreallocatedPagesKey) != 0) @throw [OFInitializationFailedException exceptionWithClass: self]; } #endif @@ -296,11 +297,11 @@ if (preallocatedPages != NULL) @throw [OFInvalidArgumentException exception]; preallocatedPages = of_alloc_zeroed(numPages, sizeof(struct page)); # if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS) - of_tlskey_set(preallocatedPagesKey, preallocatedPages); + OF_ENSURE(of_tlskey_set(preallocatedPagesKey, preallocatedPages) == 0); # endif @try { for (i = 0; i < numPages; i++) preallocatedPages[i] = addPage(false); @@ -314,12 +315,12 @@ @throw e; } numPreallocatedPages = numPages; # if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS) - of_tlskey_set(numPreallocatedPagesKey, - (void *)(uintptr_t)numPreallocatedPages); + OF_ENSURE(of_tlskey_set(numPreallocatedPagesKey, + (void *)(uintptr_t)numPreallocatedPages) == 0); # endif #else @throw [OFNotImplementedException exceptionWithSelector: _cmd object: self]; #endif Index: src/OFString+JSONParsing.m ================================================================== --- src/OFString+JSONParsing.m +++ src/OFString+JSONParsing.m @@ -29,10 +29,14 @@ #import "OFDictionary.h" #import "OFNumber.h" #import "OFNull.h" #import "OFInvalidJSONException.h" + +#ifndef INFINITY +# define INFINITY __builtin_inf() +#endif int _OFString_JSONParsing_reference; static id nextObject(const char **pointer, const char *stop, size_t *line, size_t depthLimit); Index: src/OFString.m ================================================================== --- src/OFString.m +++ src/OFString.m @@ -74,10 +74,14 @@ #ifdef OF_AMIGAOS_M68K /* libnix has strtod, but not strtof */ # define strtof strtod #endif + +#ifndef INFINITY +# define INFINITY __builtin_inf() +#endif static struct { Class isa; } placeholder; @@ -2238,18 +2242,25 @@ - (OFArray *)componentsSeparatedByString: (OFString *)delimiter options: (int)options { void *pool; - OFMutableArray *array = [OFMutableArray array]; + OFMutableArray *array; const of_unichar_t *characters, *delimiterCharacters; bool skipEmpty = (options & OF_STRING_SKIP_EMPTY); size_t length = self.length; size_t delimiterLength = delimiter.length; size_t last; OFString *component; + if (delimiter == nil) + @throw [OFInvalidArgumentException exception]; + + if (delimiter.length == 0) + return [OFArray arrayWithObject: self]; + + array = [OFMutableArray array]; pool = objc_autoreleasePoolPush(); characters = self.characters; delimiterCharacters = delimiter.characters; @@ -2340,25 +2351,68 @@ - (long long)longLongValueWithBase: (int)base { void *pool = objc_autoreleasePoolPush(); const char *UTF8String = self.UTF8String; - char *endPointer = NULL; - long long value; - - errno = 0; - value = strtoll(UTF8String, &endPointer, base); - - if ((value == LLONG_MIN || value == LLONG_MAX) && errno == ERANGE) - @throw [OFOutOfRangeException exception]; - - /* Check if there are any invalid chars left */ - if (endPointer != NULL) - for (; *endPointer != '\0'; endPointer++) - /* Use isspace since strtoll uses the same. */ - if (!isspace((unsigned char)*endPointer)) + bool negative = false; + long long value = 0; + + while (of_ascii_isspace(*UTF8String)) + UTF8String++; + + switch (*UTF8String) { + case '-': + negative = true; + case '+': + UTF8String++; + } + + if (UTF8String[0] == '0') { + if (UTF8String[1] == 'x') { + if (base == 0) + base = 16; + + if (base != 16 || UTF8String[2] == '\0') @throw [OFInvalidFormatException exception]; + + UTF8String += 2; + } else { + if (base == 0) + base = 8; + + UTF8String++; + } + } + + while (*UTF8String != '\0') { + unsigned char c = of_ascii_toupper(*UTF8String++); + + if (c >= '0' && c <= '9') + c -= '0'; + else if (c >= 'A' && c <= 'Z') + c -= ('A' - 10); + else if (of_ascii_isspace(c)) { + while (*UTF8String != '\0') + if (!of_ascii_isspace(*UTF8String++)) + @throw [OFInvalidFormatException + exception]; + + break; + } else + @throw [OFInvalidFormatException exception]; + + if (c >= base) + @throw [OFInvalidFormatException exception]; + + if (LLONG_MAX / base < value || LLONG_MAX - (value * base) < c) + @throw [OFOutOfRangeException exception]; + + value = (value * base) + c; + } + + if (negative) + value *= -1; objc_autoreleasePoolPop(pool); return value; } @@ -2370,32 +2424,65 @@ - (unsigned long long)unsignedLongLongValueWithBase: (int)base { void *pool = objc_autoreleasePoolPush(); const char *UTF8String = self.UTF8String; - char *endPointer = NULL; - unsigned long long value; - - /* Use isspace since strtoull uses the same. */ - while (isspace((unsigned char)*UTF8String)) - UTF8String++; - - if (*UTF8String == '-') - @throw [OFInvalidFormatException exception]; - - errno = 0; - value = strtoull(UTF8String, &endPointer, base); - - if (value == ULLONG_MAX && errno == ERANGE) - @throw [OFOutOfRangeException exception]; - - /* Check if there are any invalid chars left */ - if (endPointer != NULL) - for (; *endPointer != '\0'; endPointer++) - /* Use isspace since strtoull uses the same. */ - if (!isspace((unsigned char)*endPointer)) - @throw [OFInvalidFormatException exception]; + unsigned long long value = 0; + + while (of_ascii_isspace(*UTF8String)) + UTF8String++; + + switch (*UTF8String) { + case '-': + @throw [OFInvalidFormatException exception]; + case '+': + UTF8String++; + } + + if (UTF8String[0] == '0') { + if (UTF8String[1] == 'x') { + if (base == 0) + base = 16; + + if (base != 16 || UTF8String[2] == '\0') + @throw [OFInvalidFormatException exception]; + + UTF8String += 2; + } else { + if (base == 0) + base = 8; + + UTF8String++; + } + } + + while (*UTF8String != '\0') { + unsigned char c = of_ascii_toupper(*UTF8String++); + + if (c >= '0' && c <= '9') + c -= '0'; + else if (c >= 'A' && c <= 'Z') + c -= ('A' - 10); + else if (of_ascii_isspace(c)) { + while (*UTF8String != '\0') + if (!of_ascii_isspace(*UTF8String++)) + @throw [OFInvalidFormatException + exception]; + + break; + } else + @throw [OFInvalidFormatException exception]; + + if (c >= base) + @throw [OFInvalidFormatException exception]; + + if (ULLONG_MAX / base < value || + ULLONG_MAX - (value * base) < c) + @throw [OFOutOfRangeException exception]; + + value = (value * base) + c; + } objc_autoreleasePoolPop(pool); return value; } Index: src/OFThread.m ================================================================== --- src/OFThread.m +++ src/OFThread.m @@ -101,11 +101,11 @@ callMain(id object) { OFThread *thread = (OFThread *)object; OFString *name; - if (!of_tlskey_set(threadSelfKey, thread)) + if (of_tlskey_set(threadSelfKey, thread) != 0) @throw [OFInitializationFailedException exceptionWithClass: thread.class]; #ifndef OF_OBJFW_RUNTIME thread->_pool = objc_autoreleasePoolPush(); @@ -164,11 +164,11 @@ + (void)initialize { if (self != [OFThread class]) return; - if (!of_tlskey_new(&threadSelfKey)) + if (of_tlskey_new(&threadSelfKey) != 0) @throw [OFInitializationFailedException exceptionWithClass: self]; } + (instancetype)thread @@ -348,21 +348,21 @@ { mainThread = [[OFThread alloc] init]; mainThread->_thread = of_thread_current(); mainThread->_running = OF_THREAD_RUNNING; - if (!of_tlskey_set(threadSelfKey, mainThread)) + if (of_tlskey_set(threadSelfKey, mainThread) != 0) @throw [OFInitializationFailedException exceptionWithClass: self]; } - (instancetype)init { self = [super init]; @try { - if (!of_thread_attr_init(&_attr)) + if (of_thread_attr_init(&_attr) != 0) @throw [OFInitializationFailedException exceptionWithClass: self.class]; } @catch (id e) { [self release]; @throw e; @@ -409,10 +409,12 @@ # endif } - (void)start { + int error; + if (_running == OF_THREAD_RUNNING) @throw [OFThreadStillRunningException exceptionWithThread: self]; if (_running == OF_THREAD_WAITING_FOR_JOIN) { @@ -422,30 +424,31 @@ [self retain]; _running = OF_THREAD_RUNNING; - if (!of_thread_new(&_thread, - [_name cStringWithEncoding: [OFLocale encoding]], callMain, self, - &_attr)) { + if ((error = of_thread_new(&_thread, [_name cStringWithEncoding: + [OFLocale encoding]], callMain, self, &_attr)) != 0) { [self release]; @throw [OFThreadStartFailedException exceptionWithThread: self - errNo: errno]; + errNo: error]; } } - (id)join { + int error; + if (_running == OF_THREAD_NOT_RUNNING) @throw [OFThreadJoinFailedException exceptionWithThread: self errNo: EINVAL]; - if (!of_thread_join(_thread)) + if ((error = of_thread_join(_thread)) != 0) @throw [OFThreadJoinFailedException exceptionWithThread: self - errNo: errno]; + errNo: error]; _running = OF_THREAD_NOT_RUNNING; return _returnValue; } Index: src/OFURLHandler.m ================================================================== --- src/OFURLHandler.m +++ src/OFURLHandler.m @@ -34,10 +34,16 @@ #endif static OFMutableDictionary OF_GENERIC(OFString *, OFURLHandler *) *handlers; #ifdef OF_HAVE_THREADS static OFMutex *mutex; + +static void +releaseMutex(void) +{ + [mutex release]; +} #endif @implementation OFURLHandler @synthesize scheme = _scheme; @@ -47,10 +53,11 @@ return; handlers = [[OFMutableDictionary alloc] init]; #ifdef OF_HAVE_THREADS mutex = [[OFMutex alloc] init]; + atexit(releaseMutex); #endif #ifdef OF_HAVE_FILES [self registerClass: [OFFileURLHandler class] forScheme: @"file"]; Index: src/OFUTF8String.m ================================================================== --- src/OFUTF8String.m +++ src/OFUTF8String.m @@ -1111,18 +1111,26 @@ - (OFArray *)componentsSeparatedByString: (OFString *)delimiter options: (int)options { void *pool; OFMutableArray *array; - const char *cString = delimiter.UTF8String; - size_t cStringLength = delimiter.UTF8StringLength; + const char *cString; + size_t cStringLength; bool skipEmpty = (options & OF_STRING_SKIP_EMPTY); size_t last; OFString *component; + if (delimiter == nil) + @throw [OFInvalidArgumentException exception]; + + if (delimiter.length == 0) + return [OFArray arrayWithObject: self]; + array = [OFMutableArray array]; pool = objc_autoreleasePoolPush(); + cString = delimiter.UTF8String; + cStringLength = delimiter.UTF8StringLength; if (cStringLength > _s->cStringLength) { [array addObject: [[self copy] autorelease]]; objc_autoreleasePoolPop(pool); Index: src/condition.h ================================================================== --- src/condition.h +++ src/condition.h @@ -50,21 +50,21 @@ #endif #ifdef __cplusplus extern "C" { #endif -extern bool of_condition_new(of_condition_t *condition); -extern bool of_condition_signal(of_condition_t *condition); -extern bool of_condition_broadcast(of_condition_t *condition); -extern bool of_condition_wait(of_condition_t *condition, of_mutex_t *mutex); -extern bool of_condition_timed_wait(of_condition_t *condition, +extern int of_condition_new(of_condition_t *condition); +extern int of_condition_signal(of_condition_t *condition); +extern int of_condition_broadcast(of_condition_t *condition); +extern int of_condition_wait(of_condition_t *condition, of_mutex_t *mutex); +extern int of_condition_timed_wait(of_condition_t *condition, of_mutex_t *mutex, of_time_interval_t timeout); #ifdef OF_AMIGAOS -extern bool of_condition_wait_or_signal(of_condition_t *condition, +extern int of_condition_wait_or_signal(of_condition_t *condition, of_mutex_t *mutex, ULONG *signalMask); -extern bool of_condition_timed_wait_or_signal(of_condition_t *condition, +extern int of_condition_timed_wait_or_signal(of_condition_t *condition, of_mutex_t *mutex, of_time_interval_t timeout, ULONG *signalMask); #endif -extern bool of_condition_free(of_condition_t *condition); +extern int of_condition_free(of_condition_t *condition); #ifdef __cplusplus } #endif Index: src/exceptions/OFException.m ================================================================== --- src/exceptions/OFException.m +++ src/exceptions/OFException.m @@ -34,11 +34,11 @@ #import "OFInitializationFailedException.h" #import "OFLockFailedException.h" #import "OFUnlockFailedException.h" -#if !defined(HAVE_STRERROR_R) && defined(OF_HAVE_THREADS) +#ifdef OF_HAVE_THREADS # import "mutex.h" #endif #if defined(OF_WINDOWS) && defined(OF_HAVE_SOCKETS) # include @@ -73,12 +73,16 @@ #if !defined(HAVE_STRERROR_R) && defined(OF_HAVE_THREADS) static of_mutex_t mutex; OF_CONSTRUCTOR() { - if (!of_mutex_new(&mutex)) - @throw [OFInitializationFailedException exception]; + OF_ENSURE(of_mutex_new(&mutex) == 0); +} + +OF_DESTRUCTOR() +{ + of_mutex_free(&mutex); } #endif OFString * of_strerror(int errNo) @@ -187,21 +191,21 @@ ret = [OFString stringWithCString: buffer encoding: [OFLocale encoding]]; #else # ifdef OF_HAVE_THREADS - if (!of_mutex_lock(&mutex)) + if (of_mutex_lock(&mutex) != 0) @throw [OFLockFailedException exception]; @try { # endif ret = [OFString stringWithCString: strerror(errNo) encoding: [OFLocale encoding]]; # ifdef OF_HAVE_THREADS } @finally { - if (!of_mutex_unlock(&mutex)) + if (of_mutex_unlock(&mutex) != 0) @throw [OFUnlockFailedException exception]; } # endif #endif Index: src/macros.h ================================================================== --- src/macros.h +++ src/macros.h @@ -148,10 +148,13 @@ # define OF_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) #else # define OF_GCC_VERSION 0 #endif +#define OF_STRINGIFY(s) OF_STRINGIFY2(s) +#define OF_STRINGIFY2(s) #s + #ifndef __has_feature # define __has_feature(x) 0 #endif #ifndef __has_attribute @@ -355,19 +358,29 @@ #endif #define OF_RETAIN_COUNT_MAX UINT_MAX #define OF_NOT_FOUND SIZE_MAX -#define OF_ENSURE(cond) \ +#ifdef OBJC_COMPILING_RUNTIME +# define OF_ENSURE(cond) \ + do { \ + if OF_UNLIKELY (!(cond)) \ + objc_error("ObjFWRT @ " __FILE__ ":" \ + OF_STRINGIFY(__LINE__), \ + "Failed to ensure condition:\n" #cond); \ + } while(0) +#else +# define OF_ENSURE(cond) \ do { \ - if (!(cond)) { \ + if OF_UNLIKELY (!(cond)) { \ fprintf(stderr, "Failed to ensure condition " \ "in " __FILE__ ":%d:\n" #cond "\n", \ __LINE__); \ abort(); \ } \ } while (0) +#endif #define OF_UNRECOGNIZED_SELECTOR of_method_not_found(self, _cmd); #if __has_feature(objc_arc) # define OF_INVALID_INIT_METHOD of_method_not_found(self, _cmd); #else Index: src/mutex.h ================================================================== --- src/mutex.h +++ src/mutex.h @@ -14,10 +14,12 @@ * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #include "objfw-defs.h" + +#include #include "platform.h" #if !defined(OF_HAVE_THREADS) || \ (!defined(OF_HAVE_PTHREADS) && !defined(OF_WINDOWS) && !defined(OF_AMIGAOS)) @@ -63,20 +65,20 @@ #endif #ifdef __cplusplus extern "C" { #endif -extern bool of_mutex_new(of_mutex_t *mutex); -extern bool of_mutex_lock(of_mutex_t *mutex); -extern bool of_mutex_trylock(of_mutex_t *mutex); -extern bool of_mutex_unlock(of_mutex_t *mutex); -extern bool of_mutex_free(of_mutex_t *mutex); -extern bool of_rmutex_new(of_rmutex_t *rmutex); -extern bool of_rmutex_lock(of_rmutex_t *rmutex); -extern bool of_rmutex_trylock(of_rmutex_t *rmutex); -extern bool of_rmutex_unlock(of_rmutex_t *rmutex); -extern bool of_rmutex_free(of_rmutex_t *rmutex); +extern int of_mutex_new(of_mutex_t *mutex); +extern int of_mutex_lock(of_mutex_t *mutex); +extern int of_mutex_trylock(of_mutex_t *mutex); +extern int of_mutex_unlock(of_mutex_t *mutex); +extern int of_mutex_free(of_mutex_t *mutex); +extern int of_rmutex_new(of_rmutex_t *rmutex); +extern int of_rmutex_lock(of_rmutex_t *rmutex); +extern int of_rmutex_trylock(of_rmutex_t *rmutex); +extern int of_rmutex_unlock(of_rmutex_t *rmutex); +extern int of_rmutex_free(of_rmutex_t *rmutex); #ifdef __cplusplus } #endif /* Spinlocks are inlined for performance. */ @@ -89,83 +91,83 @@ #elif defined(OF_WINDOWS) Sleep(0); #endif } -static OF_INLINE bool +static OF_INLINE int of_spinlock_new(of_spinlock_t *spinlock) { #if defined(OF_HAVE_ATOMIC_OPS) *spinlock = 0; - return true; + return 0; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) - return (pthread_spin_init(spinlock, 0) == 0); + return pthread_spin_init(spinlock, 0); #else return of_mutex_new(spinlock); #endif } -static OF_INLINE bool +static OF_INLINE int of_spinlock_trylock(of_spinlock_t *spinlock) { #if defined(OF_HAVE_ATOMIC_OPS) if (of_atomic_int_cmpswap(spinlock, 0, 1)) { of_memory_barrier_acquire(); - return true; + return 0; } - return false; + return EBUSY; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) - return (pthread_spin_trylock(spinlock) == 0); + return pthread_spin_trylock(spinlock); #else return of_mutex_trylock(spinlock); #endif } -static OF_INLINE bool +static OF_INLINE int of_spinlock_lock(of_spinlock_t *spinlock) { #if defined(OF_HAVE_ATOMIC_OPS) size_t i; for (i = 0; i < OF_SPINCOUNT; i++) - if (of_spinlock_trylock(spinlock)) - return true; + if (of_spinlock_trylock(spinlock) == 0) + return 0; - while (!of_spinlock_trylock(spinlock)) + while (of_spinlock_trylock(spinlock) == EBUSY) of_thread_yield(); - return true; + return 0; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) - return (pthread_spin_lock(spinlock) == 0); + return pthread_spin_lock(spinlock); #else return of_mutex_lock(spinlock); #endif } -static OF_INLINE bool +static OF_INLINE int of_spinlock_unlock(of_spinlock_t *spinlock) { #if defined(OF_HAVE_ATOMIC_OPS) bool ret = of_atomic_int_cmpswap(spinlock, 1, 0); of_memory_barrier_release(); - return ret; + return (ret ? 0 : EINVAL); #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) - return (pthread_spin_unlock(spinlock) == 0); + return pthread_spin_unlock(spinlock); #else return of_mutex_unlock(spinlock); #endif } -static OF_INLINE bool +static OF_INLINE int of_spinlock_free(of_spinlock_t *spinlock) { #if defined(OF_HAVE_ATOMIC_OPS) - return true; + return 0; #elif defined(OF_HAVE_PTHREAD_SPINLOCKS) - return (pthread_spin_destroy(spinlock) == 0); + return pthread_spin_destroy(spinlock); #else return of_mutex_free(spinlock); #endif } Index: src/objfw-defs.h.in ================================================================== --- src/objfw-defs.h.in +++ src/objfw-defs.h.in @@ -1,8 +1,5 @@ -#undef INFINITY -#undef LLONG_MAX -#undef LLONG_MIN #undef OF_APPLE_RUNTIME #undef OF_BIG_ENDIAN #undef OF_FLOAT_BIG_ENDIAN #undef OF_HAVE_ATOMIC_BUILTINS #undef OF_HAVE_ATOMIC_OPS @@ -45,9 +42,5 @@ #undef OF_NINTENDO_DS #undef OF_NO_SHARED #undef OF_OBJFW_RUNTIME #undef OF_UNIVERSAL #undef OF_WII -#undef SIZE_MAX -#undef UINTPTR_MAX -#undef ULLONG_MAX -#undef __have_longlong64 Index: src/platform.h ================================================================== --- src/platform.h +++ src/platform.h @@ -127,16 +127,12 @@ #elif defined(__HAIKU__) # define OF_HAIKU #elif defined(_AIX) # define OF_AIX #elif defined(__MORPHOS__) -# ifndef __ixemul__ -# define OF_MORPHOS -# define OF_AMIGAOS -# else -# define OF_MORPHOS_IXEMUL -# endif +# define OF_MORPHOS +# define OF_AMIGAOS #elif defined(__amigaos4__) # define OF_AMIGAOS4 # define OF_AMIGAOS #elif defined(__amigaos__) # define OF_AMIGAOS_M68K Index: src/platform/amiga/condition.m ================================================================== --- src/platform/amiga/condition.m +++ src/platform/amiga/condition.m @@ -25,44 +25,44 @@ #include #ifndef OF_AMIGAOS4 # include #endif -bool +int of_condition_new(of_condition_t *condition) { condition->waitingTasks = NULL; - return true; + return 0; } -bool +int of_condition_signal(of_condition_t *condition) { Forbid(); @try { if (condition->waitingTasks == NULL) - return true; + return 0; Signal(condition->waitingTasks->task, (1ul << condition->waitingTasks->sigBit)); condition->waitingTasks = condition->waitingTasks->next; } @finally { Permit(); } - return true; + return 0; } -bool +int of_condition_broadcast(of_condition_t *condition) { Forbid(); @try { if (condition->waitingTasks == NULL) - return true; + return 0; while (condition->waitingTasks != NULL) { Signal(condition->waitingTasks->task, (1ul << condition->waitingTasks->sigBit)); @@ -70,77 +70,73 @@ } } @finally { Permit(); } - return true; + return 0; } -bool +int of_condition_wait(of_condition_t *condition, of_mutex_t *mutex) { ULONG signalMask = 0; return of_condition_wait_or_signal(condition, mutex, &signalMask); } -bool +int of_condition_wait_or_signal(of_condition_t *condition, of_mutex_t *mutex, ULONG *signalMask) { struct of_condition_waiting_task waitingTask = { .task = FindTask(NULL), .sigBit = AllocSignal(-1) }; - bool ret; + int error = 0; ULONG mask; - if (waitingTask.sigBit == -1) { - errno = EAGAIN; - return false; - } + if (waitingTask.sigBit == -1) + return EAGAIN; Forbid(); - if (!of_mutex_unlock(mutex)) { + if ((error = of_mutex_unlock(mutex)) != 0) { FreeSignal(waitingTask.sigBit); - return false; + return error; } waitingTask.next = condition->waitingTasks; condition->waitingTasks = &waitingTask; mask = Wait((1ul << waitingTask.sigBit) | *signalMask); if (mask & (1ul << waitingTask.sigBit) || (*signalMask &= mask)) - ret = of_mutex_lock(mutex); - else { + error = of_mutex_lock(mutex); + else /* * This should not happen - it means something interrupted the * Wait(), so the best we can do is return EINTR. */ - ret = false; - errno = EINTR; - } + error = EINTR; FreeSignal(waitingTask.sigBit); Permit(); - return ret; + return error; } -bool +int of_condition_timed_wait(of_condition_t *condition, of_mutex_t *mutex, of_time_interval_t timeout) { ULONG signalMask = 0; return of_condition_timed_wait_or_signal(condition, mutex, timeout, &signalMask); } -bool +int of_condition_timed_wait_or_signal(of_condition_t *condition, of_mutex_t *mutex, of_time_interval_t timeout, ULONG *signalMask) { struct of_condition_waiting_task waitingTask = { .task = FindTask(NULL), @@ -180,29 +176,29 @@ .tv_sec = (ULONG)timeout, .tv_micro = (timeout - request.tr_time.tv_sec) * 1000000 #endif } }; + int error = 0; ULONG mask; - bool ret; NewList(&port.mp_MsgList); if (waitingTask.sigBit == -1 || port.mp_SigBit == -1) { - errno = EAGAIN; + error = EAGAIN; goto fail; } if (OpenDevice("timer.device", UNIT_MICROHZ, (struct IORequest *)&request, 0) != 0) { - errno = EAGAIN; + error = EAGAIN; goto fail; } Forbid(); - if (!of_mutex_unlock(mutex)) { + if ((error = of_mutex_unlock(mutex)) != 0) { Permit(); goto fail; } waitingTask.next = condition->waitingTasks; @@ -211,22 +207,19 @@ SendIO((struct IORequest *)&request); mask = Wait((1ul << waitingTask.sigBit) | (1ul << port.mp_SigBit) | *signalMask); if (mask & (1ul << waitingTask.sigBit) || (*signalMask &= mask)) - ret = of_mutex_lock(mutex); - else if (mask & (1ul << port.mp_SigBit)) { - ret = false; - errno = ETIMEDOUT; - } else { + error = of_mutex_lock(mutex); + else if (mask & (1ul << port.mp_SigBit)) + error = ETIMEDOUT; + else /* * This should not happen - it means something interrupted the * Wait(), so the best we can do is return EINTR. */ - ret = false; - errno = EINTR; - } + error = EINTR; condition->waitingTasks = waitingTask.next; if (!CheckIO((struct IORequest *)&request)) { AbortIO((struct IORequest *)&request); @@ -234,34 +227,27 @@ } CloseDevice((struct IORequest *)&request); Permit(); - FreeSignal(waitingTask.sigBit); - FreeSignal(port.mp_SigBit); - - return ret; - fail: if (waitingTask.sigBit != -1) FreeSignal(waitingTask.sigBit); if (port.mp_SigBit != -1) FreeSignal(port.mp_SigBit); - return false; + return error; } -bool +int of_condition_free(of_condition_t *condition) { Forbid(); @try { - if (condition->waitingTasks != NULL) { - errno = EBUSY; - return false; - } + if (condition->waitingTasks != NULL) + return EBUSY; } @finally { Permit(); } - return true; + return 0; } Index: src/platform/amiga/mutex.m ================================================================== --- src/platform/amiga/mutex.m +++ src/platform/amiga/mutex.m @@ -21,75 +21,73 @@ #import "mutex.h" #include -bool +int of_mutex_new(of_mutex_t *mutex) { InitSemaphore(mutex); - return true; + return 0; } -bool +int of_mutex_lock(of_mutex_t *mutex) { ObtainSemaphore(mutex); - return true; + return 0; } -bool +int of_mutex_trylock(of_mutex_t *mutex) { - if (!AttemptSemaphore(mutex)) { - errno = EBUSY; - return false; - } + if (!AttemptSemaphore(mutex)) + return EBUSY; - return true; + return 0; } -bool +int of_mutex_unlock(of_mutex_t *mutex) { ReleaseSemaphore(mutex); - return true; + return 0; } -bool +int of_mutex_free(of_mutex_t *mutex) { - return true; + return 0; } -bool +int of_rmutex_new(of_rmutex_t *rmutex) { return of_mutex_new(rmutex); } -bool +int of_rmutex_lock(of_rmutex_t *rmutex) { return of_mutex_lock(rmutex); } -bool +int of_rmutex_trylock(of_rmutex_t *rmutex) { return of_mutex_trylock(rmutex); } -bool +int of_rmutex_unlock(of_rmutex_t *rmutex) { return of_mutex_unlock(rmutex); } -bool +int of_rmutex_free(of_rmutex_t *rmutex) { return of_mutex_free(rmutex); } Index: src/platform/amiga/thread.m ================================================================== --- src/platform/amiga/thread.m +++ src/platform/amiga/thread.m @@ -34,20 +34,20 @@ #endif static of_tlskey_t threadKey; OF_CONSTRUCTOR() { - OF_ENSURE(of_tlskey_new(&threadKey)); + OF_ENSURE(of_tlskey_new(&threadKey) == 0); } static void functionWrapper(void) { bool detached = false; of_thread_t thread = (of_thread_t)((struct Process *)FindTask(NULL))->pr_ExitData; - OF_ENSURE(of_tlskey_set(threadKey, thread)); + OF_ENSURE(of_tlskey_set(threadKey, thread) == 0); thread->function(thread->object); ObtainSemaphore(&thread->semaphore); @try { @@ -67,29 +67,27 @@ if (detached) free(thread); } -bool +int of_thread_attr_init(of_thread_attr_t *attr) { attr->priority = 0; attr->stackSize = 0; - return true; + return 0; } -bool +int of_thread_new(of_thread_t *thread, const char *name, void (*function)(id), id object, const of_thread_attr_t *attr) { OFMutableData *tags = nil; - if ((*thread = calloc(1, sizeof(**thread))) == NULL) { - errno = ENOMEM; - return false; - } + if ((*thread = calloc(1, sizeof(**thread))) == NULL) + return ENOMEM; @try { (*thread)->function = function; (*thread)->object = object; InitSemaphore(&(*thread)->semaphore); @@ -122,14 +120,12 @@ ADD_TAG(NP_CloseInput, FALSE) ADD_TAG(NP_CloseOutput, FALSE) ADD_TAG(NP_CloseError, FALSE) if (attr != NULL && attr->priority != 0) { - if (attr->priority < 1 || attr->priority > 1) { - errno = EINVAL; - return false; - } + if (attr->priority < 1 || attr->priority > 1) + return EINVAL; /* * -1 should be -128 (lowest possible priority) while * +1 should be +127 (highest possible priority). */ @@ -147,51 +143,46 @@ #undef ADD_TAG (*thread)->task = (struct Task *)CreateNewProc(tags.items); if ((*thread)->task == NULL) { free(*thread); - errno = EAGAIN; - return false; + return EAGAIN; } } @catch (id e) { free(*thread); @throw e; } @finally { [tags release]; } - return true; + return 0; } of_thread_t of_thread_current(void) { return of_tlskey_get(threadKey); } -bool +int of_thread_join(of_thread_t thread) { ObtainSemaphore(&thread->semaphore); if (thread->done) { ReleaseSemaphore(&thread->semaphore); free(thread); - return true; + return 0; } @try { - if (thread->detached || thread->joinTask != NULL) { - errno = EINVAL; - return false; - } - - if ((thread->joinSigBit = AllocSignal(-1)) == -1) { - errno = EAGAIN; - return false; - } + if (thread->detached || thread->joinTask != NULL) + return EINVAL; + + if ((thread->joinSigBit = AllocSignal(-1)) == -1) + return EAGAIN; thread->joinTask = FindTask(NULL); } @finally { ReleaseSemaphore(&thread->semaphore); } @@ -200,14 +191,14 @@ FreeSignal(thread->joinSigBit); assert(thread->done); free(thread); - return true; + return 0; } -bool +int of_thread_detach(of_thread_t thread) { ObtainSemaphore(&thread->semaphore); if (thread->done) @@ -215,12 +206,12 @@ else thread->detached = true; ReleaseSemaphore(&thread->semaphore); - return true; + return 0; } void of_thread_set_name(const char *name) { } Index: src/platform/amiga/tlskey.m ================================================================== --- src/platform/amiga/tlskey.m +++ src/platform/amiga/tlskey.m @@ -50,11 +50,11 @@ InitSemaphore(&semaphore); semaphoreInitialized = true; } } -bool +int of_tlskey_new(of_tlskey_t *key) { if (!semaphoreInitialized) { /* * We might be called from another constructor, while ours has @@ -64,11 +64,11 @@ InitSemaphore(&semaphore); semaphoreInitialized = true; } if ((*key = malloc(sizeof(**key))) == NULL) - return false; + return ENOMEM; (*key)->table = NULL; ObtainSemaphore(&semaphore); @try { @@ -85,14 +85,14 @@ } @finally { ReleaseSemaphore(&semaphore); } /* We create the hash table lazily. */ - return true; + return 0; } -bool +int of_tlskey_free(of_tlskey_t key) { ObtainSemaphore(&semaphore); @try { if (key->previous != NULL) @@ -109,11 +109,11 @@ free(key); } @finally { ReleaseSemaphore(&semaphore); } - return true; + return 0; } void * of_tlskey_get(of_tlskey_t key) { @@ -130,11 +130,11 @@ } return ret; } -bool +int of_tlskey_set(of_tlskey_t key, void *ptr) { ObtainSemaphore(&semaphore); @try { struct Task *task = FindTask(NULL); @@ -144,17 +144,15 @@ if (ptr == NULL) objc_hashtable_delete(key->table, task); else objc_hashtable_set(key->table, task, ptr); - } @catch (id e) { - return false; } @finally { ReleaseSemaphore(&semaphore); } - return true; + return 0; } void of_tlskey_thread_exited(void) { Index: src/platform/morphos/tlskey.m ================================================================== --- src/platform/morphos/tlskey.m +++ src/platform/morphos/tlskey.m @@ -17,16 +17,21 @@ #include "config.h" #import "tlskey.h" -bool +int of_tlskey_new(of_tlskey_t *key) { - return ((*key = TLSAllocA(NULL)) != TLS_INVALID_INDEX); + *key = TLSAllocA(NULL); + + if (*key == TLS_INVALID_INDEX) + return EAGAIN; + + return 0; } -bool +int of_tlskey_free(of_tlskey_t key) { - return TLSFree(key); + return (TLSFree(key) ? 0 : EINVAL); } Index: src/platform/posix/condition.m ================================================================== --- src/platform/posix/condition.m +++ src/platform/posix/condition.m @@ -17,46 +17,46 @@ #include "config.h" #import "condition.h" -bool +int of_condition_new(of_condition_t *condition) { - return (pthread_cond_init(condition, NULL) == 0); + return pthread_cond_init(condition, NULL); } -bool +int of_condition_signal(of_condition_t *condition) { - return (pthread_cond_signal(condition) == 0); + return pthread_cond_signal(condition); } -bool +int of_condition_broadcast(of_condition_t *condition) { - return (pthread_cond_broadcast(condition) == 0); + return pthread_cond_broadcast(condition); } -bool +int of_condition_wait(of_condition_t *condition, of_mutex_t *mutex) { - return (pthread_cond_wait(condition, mutex) == 0); + return pthread_cond_wait(condition, mutex); } -bool +int of_condition_timed_wait(of_condition_t *condition, of_mutex_t *mutex, of_time_interval_t timeout) { struct timespec ts; ts.tv_sec = (time_t)timeout; ts.tv_nsec = (long)((timeout - ts.tv_sec) * 1000000000); - return (pthread_cond_timedwait(condition, mutex, &ts) == 0); + return pthread_cond_timedwait(condition, mutex, &ts); } -bool +int of_condition_free(of_condition_t *condition) { - return (pthread_cond_destroy(condition) == 0); + return pthread_cond_destroy(condition); } Index: src/platform/posix/mutex.m ================================================================== --- src/platform/posix/mutex.m +++ src/platform/posix/mutex.m @@ -17,171 +17,183 @@ #include "config.h" #import "mutex.h" -bool +int of_mutex_new(of_mutex_t *mutex) { - return (pthread_mutex_init(mutex, NULL) == 0); + return pthread_mutex_init(mutex, NULL); } -bool +int of_mutex_lock(of_mutex_t *mutex) { - return (pthread_mutex_lock(mutex) == 0); + return pthread_mutex_lock(mutex); } -bool +int of_mutex_trylock(of_mutex_t *mutex) { - return (pthread_mutex_trylock(mutex) == 0); + return pthread_mutex_trylock(mutex); } -bool +int of_mutex_unlock(of_mutex_t *mutex) { - return (pthread_mutex_unlock(mutex) == 0); + return pthread_mutex_unlock(mutex); } -bool +int of_mutex_free(of_mutex_t *mutex) { - return (pthread_mutex_destroy(mutex) == 0); + return pthread_mutex_destroy(mutex); } #ifdef OF_HAVE_RECURSIVE_PTHREAD_MUTEXES -bool +int of_rmutex_new(of_rmutex_t *rmutex) { + int error; pthread_mutexattr_t attr; - if (pthread_mutexattr_init(&attr) != 0) - return false; - - if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0) - return false; - - if (pthread_mutex_init(rmutex, &attr) != 0) - return false; - - if (pthread_mutexattr_destroy(&attr) != 0) - return false; - - return true; -} - -bool + if ((error = pthread_mutexattr_init(&attr)) != 0) + return error; + + if ((error = pthread_mutexattr_settype(&attr, + PTHREAD_MUTEX_RECURSIVE)) != 0) + return error; + + if ((error = pthread_mutex_init(rmutex, &attr)) != 0) + return error; + + if ((error = pthread_mutexattr_destroy(&attr)) != 0) + return error; + + return 0; +} + +int of_rmutex_lock(of_rmutex_t *rmutex) { return of_mutex_lock(rmutex); } -bool +int of_rmutex_trylock(of_rmutex_t *rmutex) { return of_mutex_trylock(rmutex); } -bool +int of_rmutex_unlock(of_rmutex_t *rmutex) { return of_mutex_unlock(rmutex); } -bool +int of_rmutex_free(of_rmutex_t *rmutex) { return of_mutex_free(rmutex); } #else -bool +int of_rmutex_new(of_rmutex_t *rmutex) { - if (!of_mutex_new(&rmutex->mutex)) - return false; + int error; + + if ((error = of_mutex_new(&rmutex->mutex)) != 0) + return error; - if (!of_tlskey_new(&rmutex->count)) - return false; + if ((error = of_tlskey_new(&rmutex->count)) != 0) + return error; - return true; + return 0; } -bool +int of_rmutex_lock(of_rmutex_t *rmutex) { uintptr_t count = (uintptr_t)of_tlskey_get(rmutex->count); - - if (count > 0) { - if (!of_tlskey_set(rmutex->count, (void *)(count + 1))) - return false; - - return true; - } - - if (!of_mutex_lock(&rmutex->mutex)) - return false; - - if (!of_tlskey_set(rmutex->count, (void *)1)) { - of_mutex_unlock(&rmutex->mutex); - return false; - } - - return true; -} - -bool + int error; + + if (count > 0) { + if ((error = of_tlskey_set(rmutex->count, + (void *)(count + 1))) != 0) + return error; + + return 0; + } + + if ((error = of_mutex_lock(&rmutex->mutex)) != 0) + return error; + + if ((error = of_tlskey_set(rmutex->count, (void *)1)) != 0) { + of_mutex_unlock(&rmutex->mutex); + return error; + } + + return 0; +} + +int of_rmutex_trylock(of_rmutex_t *rmutex) { uintptr_t count = (uintptr_t)of_tlskey_get(rmutex->count); - - if (count > 0) { - if (!of_tlskey_set(rmutex->count, (void *)(count + 1))) - return false; - - return true; - } - - if (!of_mutex_trylock(&rmutex->mutex)) - return false; - - if (!of_tlskey_set(rmutex->count, (void *)1)) { - of_mutex_unlock(&rmutex->mutex); - return false; - } - - return true; -} - -bool + int error; + + if (count > 0) { + if ((error = of_tlskey_set(rmutex->count, + (void *)(count + 1))) != 0) + return error; + + return 0; + } + + if ((error = of_mutex_trylock(&rmutex->mutex)) != 0) + return error; + + if ((error = of_tlskey_set(rmutex->count, (void *)1)) != 0) { + of_mutex_unlock(&rmutex->mutex); + return error; + } + + return 0; +} + +int of_rmutex_unlock(of_rmutex_t *rmutex) { uintptr_t count = (uintptr_t)of_tlskey_get(rmutex->count); - - if (count > 1) { - if (!of_tlskey_set(rmutex->count, (void *)(count - 1))) - return false; - - return true; - } - - if (!of_tlskey_set(rmutex->count, (void *)0)) - return false; - - if (!of_mutex_unlock(&rmutex->mutex)) - return false; - - return true; -} - -bool -of_rmutex_free(of_rmutex_t *rmutex) -{ - if (!of_mutex_free(&rmutex->mutex)) - return false; - - if (!of_tlskey_free(rmutex->count)) - return false; - - return true; + int error; + + if (count > 1) { + if ((error = of_tlskey_set(rmutex->count, + (void *)(count - 1))) != 0) + return error; + + return 0; + } + + if ((error = of_tlskey_set(rmutex->count, (void *)0)) != 0) + return error; + + if ((error = of_mutex_unlock(&rmutex->mutex)) != 0) + return error; + + return 0; +} + +int +of_rmutex_free(of_rmutex_t *rmutex) +{ + int error; + + if ((error = of_mutex_free(&rmutex->mutex)) != 0) + return error; + + if ((error = of_tlskey_free(rmutex->count)) != 0) + return error; + + return 0; } #endif Index: src/platform/posix/thread.m ================================================================== --- src/platform/posix/thread.m +++ src/platform/posix/thread.m @@ -85,55 +85,50 @@ pthread_cleanup_pop(1); return NULL; } -bool +int of_thread_attr_init(of_thread_attr_t *attr) { + int error; pthread_attr_t pattr; - if (pthread_attr_init(&pattr) != 0) - return false; - - @try { - attr->priority = 0; - - if (pthread_attr_getstacksize(&pattr, &attr->stackSize) != 0) - return false; - } @finally { - pthread_attr_destroy(&pattr); - } - - return true; -} - -bool + if ((error = pthread_attr_init(&pattr)) != 0) + return error; + + attr->priority = 0; + error = pthread_attr_getstacksize(&pattr, &attr->stackSize); + + pthread_attr_destroy(&pattr); + + return error; +} + +int of_thread_new(of_thread_t *thread, const char *name, void (*function)(id), id object, const of_thread_attr_t *attr) { - bool ret; + int error = 0; pthread_attr_t pattr; - if (pthread_attr_init(&pattr) != 0) - return false; + if ((error = pthread_attr_init(&pattr)) != 0) + return error; @try { struct thread_ctx *ctx; if (attr != NULL) { struct sched_param param; - if (attr->priority < -1 || attr->priority > 1) { - errno = EINVAL; - return false; - } + if (attr->priority < -1 || attr->priority > 1) + return EINVAL; #ifdef HAVE_PTHREAD_ATTR_SETINHERITSCHED - if (pthread_attr_setinheritsched(&pattr, - PTHREAD_EXPLICIT_SCHED) != 0) - return false; + if ((error = pthread_attr_setinheritsched(&pattr, + PTHREAD_EXPLICIT_SCHED)) != 0) + return error; #endif if (attr->priority < 0) { param.sched_priority = minPrio + (1.0f + attr->priority) * @@ -140,50 +135,48 @@ (normalPrio - minPrio); } else param.sched_priority = normalPrio + attr->priority * (maxPrio - normalPrio); - if (pthread_attr_setschedparam(&pattr, ¶m) != 0) - return false; + if ((error = pthread_attr_setschedparam(&pattr, + ¶m)) != 0) + return error; if (attr->stackSize > 0) { - if (pthread_attr_setstacksize(&pattr, - attr->stackSize) != 0) - return false; + if ((error = pthread_attr_setstacksize(&pattr, + attr->stackSize)) != 0) + return error; } } - if ((ctx = malloc(sizeof(*ctx))) == NULL) { - errno = ENOMEM; - return false; - } + if ((ctx = malloc(sizeof(*ctx))) == NULL) + return ENOMEM; ctx->function = function; ctx->object = object; ctx->name = name; - ret = (pthread_create(thread, &pattr, - functionWrapper, ctx) == 0); + error = pthread_create(thread, &pattr, functionWrapper, ctx); } @finally { pthread_attr_destroy(&pattr); } - return ret; + return error; } -bool +int of_thread_join(of_thread_t thread) { void *ret; - return (pthread_join(thread, &ret) == 0); + return pthread_join(thread, &ret); } -bool +int of_thread_detach(of_thread_t thread) { - return (pthread_detach(thread) == 0); + return pthread_detach(thread); } void of_thread_set_name(const char *name) { Index: src/platform/posix/tlskey.m ================================================================== --- src/platform/posix/tlskey.m +++ src/platform/posix/tlskey.m @@ -17,16 +17,16 @@ #include "config.h" #import "tlskey.h" -bool +int of_tlskey_new(of_tlskey_t *key) { - return (pthread_key_create(key, NULL) == 0); + return pthread_key_create(key, NULL); } -bool +int of_tlskey_free(of_tlskey_t key) { - return (pthread_key_delete(key) == 0); + return pthread_key_delete(key); } Index: src/platform/windows/condition.m ================================================================== --- src/platform/windows/condition.m +++ src/platform/windows/condition.m @@ -21,66 +21,63 @@ #import "condition.h" #include -bool +int of_condition_new(of_condition_t *condition) { condition->count = 0; - if ((condition->event = CreateEvent(NULL, FALSE, 0, NULL)) == NULL) { - errno = EAGAIN; - return false; - } + if ((condition->event = CreateEvent(NULL, FALSE, 0, NULL)) == NULL) + return EAGAIN; - return true; + return 0; } -bool +int of_condition_signal(of_condition_t *condition) { if (!SetEvent(condition->event)) { switch (GetLastError()) { case ERROR_INVALID_HANDLE: - errno = EINVAL; - return false; + return EINVAL; default: OF_ENSURE(0); } } - return true; + return 0; } -bool +int of_condition_broadcast(of_condition_t *condition) { int count = condition->count; for (int i = 0; i < count; i++) { if (!SetEvent(condition->event)) { switch (GetLastError()) { case ERROR_INVALID_HANDLE: - errno = EINVAL; - return false; + return EINVAL; default: OF_ENSURE(0); } } } - return true; + return 0; } -bool +int of_condition_wait(of_condition_t *condition, of_mutex_t *mutex) { + int error; DWORD status; - if (!of_mutex_unlock(mutex)) - return false; + if ((error = of_mutex_unlock(mutex)) != 0) + return error; of_atomic_int_inc(&condition->count); status = WaitForSingleObject(condition->event, INFINITE); of_atomic_int_dec(&condition->count); @@ -88,57 +85,53 @@ case WAIT_OBJECT_0: return of_mutex_lock(mutex); case WAIT_FAILED: switch (GetLastError()) { case ERROR_INVALID_HANDLE: - errno = EINVAL; - return false; + return EINVAL; default: OF_ENSURE(0); } default: OF_ENSURE(0); } } -bool +int of_condition_timed_wait(of_condition_t *condition, of_mutex_t *mutex, of_time_interval_t timeout) { + int error; DWORD status; - if (!of_mutex_unlock(mutex)) - return false; + if ((error = of_mutex_unlock(mutex)) != 0) + return error; of_atomic_int_inc(&condition->count); status = WaitForSingleObject(condition->event, timeout * 1000); of_atomic_int_dec(&condition->count); switch (status) { case WAIT_OBJECT_0: return of_mutex_lock(mutex); case WAIT_TIMEOUT: - errno = ETIMEDOUT; - return false; + return ETIMEDOUT; case WAIT_FAILED: switch (GetLastError()) { case ERROR_INVALID_HANDLE: - errno = EINVAL; - return false; + return EINVAL; default: OF_ENSURE(0); } default: OF_ENSURE(0); } } -bool +int of_condition_free(of_condition_t *condition) { - if (condition->count != 0) { - errno = EBUSY; - return false; - } + if (condition->count != 0) + return EBUSY; - return CloseHandle(condition->event); + return (CloseHandle(condition->event) ? 0 : EINVAL); } Index: src/platform/windows/mutex.m ================================================================== --- src/platform/windows/mutex.m +++ src/platform/windows/mutex.m @@ -21,77 +21,75 @@ #import "mutex.h" #include -bool +int of_mutex_new(of_mutex_t *mutex) { InitializeCriticalSection(mutex); - return true; + return 0; } -bool +int of_mutex_lock(of_mutex_t *mutex) { EnterCriticalSection(mutex); - return true; + return 0; } -bool +int of_mutex_trylock(of_mutex_t *mutex) { - if (!TryEnterCriticalSection(mutex)) { - errno = EBUSY; - return false; - } + if (!TryEnterCriticalSection(mutex)) + return EBUSY; - return true; + return 0; } -bool +int of_mutex_unlock(of_mutex_t *mutex) { LeaveCriticalSection(mutex); - return true; + return 0; } -bool +int of_mutex_free(of_mutex_t *mutex) { DeleteCriticalSection(mutex); - return true; + return 0; } -bool +int of_rmutex_new(of_rmutex_t *rmutex) { return of_mutex_new(rmutex); } -bool +int of_rmutex_lock(of_rmutex_t *rmutex) { return of_mutex_lock(rmutex); } -bool +int of_rmutex_trylock(of_rmutex_t *rmutex) { return of_mutex_trylock(rmutex); } -bool +int of_rmutex_unlock(of_rmutex_t *rmutex) { return of_mutex_unlock(rmutex); } -bool +int of_rmutex_free(of_rmutex_t *rmutex) { return of_mutex_free(rmutex); } Index: src/platform/windows/thread.m ================================================================== --- src/platform/windows/thread.m +++ src/platform/windows/thread.m @@ -35,32 +35,30 @@ context->function(context->object); free(context); } -bool +int of_thread_attr_init(of_thread_attr_t *attr) { attr->priority = 0; attr->stackSize = 0; - return true; + return 0; } -bool +int of_thread_new(of_thread_t *thread, const char *name, void (*function)(id), id object, const of_thread_attr_t *attr) { DWORD priority = THREAD_PRIORITY_NORMAL; struct thread_context *context; DWORD threadID; if (attr != NULL && attr->priority != 0) { - if (attr->priority < -1 || attr->priority > 1) { - errno = EINVAL; - return false; - } + if (attr->priority < -1 || attr->priority > 1) + return EINVAL; if (attr->priority < 0) priority = THREAD_PRIORITY_LOWEST + (1.0 + attr->priority) * (THREAD_PRIORITY_NORMAL - THREAD_PRIORITY_LOWEST); @@ -68,73 +66,69 @@ priority = THREAD_PRIORITY_NORMAL + attr->priority * (THREAD_PRIORITY_HIGHEST - THREAD_PRIORITY_NORMAL); } - if ((context = malloc(sizeof(*context))) == NULL) { - errno = ENOMEM; - return false; - } + if ((context = malloc(sizeof(*context))) == NULL) + return ENOMEM; context->function = function; context->object = object; *thread = CreateThread(NULL, (attr != NULL ? attr->stackSize : 0), (LPTHREAD_START_ROUTINE)functionWrapper, context, 0, &threadID); if (thread == NULL) { - int errNo; + int error; switch (GetLastError()) { case ERROR_NOT_ENOUGH_MEMORY: - errNo = ENOMEM; + error = ENOMEM; break; case ERROR_ACCESS_DENIED: - errNo = EACCES; + error = EACCES; break; default: OF_ENSURE(0); } free(context); - errno = errNo; - return false; + return error; } if (attr != NULL && attr->priority != 0) OF_ENSURE(!SetThreadPriority(*thread, priority)); - return true; + return 0; } -bool +int of_thread_join(of_thread_t thread) { switch (WaitForSingleObject(thread, INFINITE)) { case WAIT_OBJECT_0: CloseHandle(thread); - return true; + return 0; case WAIT_FAILED: switch (GetLastError()) { case ERROR_INVALID_HANDLE: - errno = EINVAL; - return false; + return EINVAL; default: OF_ENSURE(0); } default: OF_ENSURE(0); } } -bool +int of_thread_detach(of_thread_t thread) { CloseHandle(thread); - return true; + return 0; } void of_thread_set_name(const char *name) { } Index: src/platform/windows/tlskey.m ================================================================== --- src/platform/windows/tlskey.m +++ src/platform/windows/tlskey.m @@ -17,16 +17,21 @@ #include "config.h" #import "tlskey.h" -bool +int of_tlskey_new(of_tlskey_t *key) { - return ((*key = TlsAlloc()) != TLS_OUT_OF_INDEXES); + *key = TlsAlloc(); + + if (*key == TLS_OUT_OF_INDEXES) + return EAGAIN; + + return 0; } -bool +int of_tlskey_free(of_tlskey_t key) { - return TlsFree(key); + return (TlsFree(key) ? 0 : EINVAL); } Index: src/runtime/Makefile ================================================================== --- src/runtime/Makefile +++ src/runtime/Makefile @@ -56,11 +56,12 @@ ${CVINCLUDE_INLINE_H}: morphos.fd morphos-clib.h cvinclude.pl --quiet --fd=morphos.fd --clib=morphos-clib.h --inlines=$@ CPPFLAGS += -I. -I.. -I../.. \ + -DOBJC_COMPILING_RUNTIME \ -DOBJFWRT_AMIGA_LIB=\"${OBJFWRT_AMIGA_LIB}\" \ -DOBJFWRT_LIB_MAJOR=${OBJFWRT_LIB_MAJOR} \ -DOBJFWRT_LIB_MINOR=${OBJFWRT_LIB_MINOR} AMIGA_LIB_CFLAGS += -DOBJC_COMPILING_AMIGA_LIBRARY LD = ${OBJC} FRAMEWORK_LIBS = ${LIBS} Index: src/runtime/amiga-glue.m ================================================================== --- src/runtime/amiga-glue.m +++ src/runtime/amiga-glue.m @@ -27,11 +27,11 @@ #else # define PPC_PARAMS(...) (__VA_ARGS__) # define M68K_ARG(...) #endif -extern bool objc_init(unsigned int, struct objc_libc *, FILE *, FILE *); +extern bool objc_init(unsigned int, struct objc_libc *); #ifdef OF_MORPHOS /* All __saveds functions in this file need to use the SysV ABI */ __asm__ ( ".section .text\n" @@ -41,19 +41,16 @@ " blr\n" ); #endif bool __saveds -glue_objc_init PPC_PARAMS(unsigned int version, struct objc_libc *libc, - FILE *stdout_, FILE *stderr_) +glue_objc_init PPC_PARAMS(unsigned int version, struct objc_libc *libc) { M68K_ARG(unsigned int, version, d0) M68K_ARG(struct objc_libc *, libc, a0) - M68K_ARG(FILE *, stdout_, a1) - M68K_ARG(FILE *, stderr_, a2) - return objc_init(version, libc, stdout_, stderr_); + return objc_init(version, libc); } void __saveds glue___objc_exec_class PPC_PARAMS(struct objc_module *module) { Index: src/runtime/amiga-library.m ================================================================== --- src/runtime/amiga-library.m +++ src/runtime/amiga-library.m @@ -45,10 +45,17 @@ int _start() { return -1; } + +#ifdef OF_AMIGAOS_M68K +void +__init_eh(void) +{ +} +#endif struct ObjFWRTBase { struct Library library; void *segList; struct ObjFWRTBase *parent; @@ -156,12 +163,10 @@ #ifdef OF_MORPHOS const ULONG __abox__ = 1; #endif struct ExecBase *SysBase; struct objc_libc libc; -FILE *stdout; -FILE *stderr; #if defined(OF_AMIGAOS_M68K) __asm__ ( ".text\n" ".globl ___restore_a4\n" @@ -407,12 +412,11 @@ { return NULL; } bool -objc_init(unsigned int version, struct objc_libc *libc_, FILE *stdout_, - FILE *stderr_) +objc_init(unsigned int version, struct objc_libc *libc_) { #ifdef OF_AMIGAOS_M68K OBJC_M68K_ARG(struct ObjFWRTBase *, base, a6) #else register struct ObjFWRTBase *r12 __asm__("r12"); @@ -425,12 +429,10 @@ if (version > 1) return false; memcpy(&libc, libc_, sizeof(libc)); - stdout = stdout_; - stderr = stderr_; #ifdef OF_AMIGAOS_M68K if ((size_t)_EH_FRAME_BEGINS__ != (size_t)_EH_FRAME_OBJECTS__) return false; @@ -485,37 +487,10 @@ free(void *ptr) { libc.free(ptr); } -int -fprintf(FILE *restrict stream, const char *restrict fmt, ...) -{ - int ret; - va_list args; - - va_start(args, fmt); - ret = libc.vfprintf(stream, fmt, args); - va_end(args); - - return ret; -} - -int -fflush(FILE *restrict stream) -{ - return libc.fflush(stream); -} - -void -abort(void) -{ - libc.abort(); - - OF_UNREACHABLE -} - #ifdef HAVE_SJLJ_EXCEPTIONS int _Unwind_SjLj_RaiseException(void *ex) { return libc._Unwind_SjLj_RaiseException(ex); @@ -594,14 +569,44 @@ { libc._Unwind_Resume(ex); } #endif -int * -objc_get_errno(void) +#ifdef OF_AMIGAOS_M68K +int +snprintf(char *restrict str, size_t size, const char *restrict fmt, ...) +{ + va_list args; + int ret; + + va_start(args, fmt); + ret = vsnprintf(str, size, fmt, args); + va_end(args); + + return ret; +} + +int +vsnprintf(char *restrict str, size_t size, const char *restrict fmt, + va_list args) +{ + return libc.vsnprintf(str, size, fmt, args); +} +#endif + +int +atexit(void (*function)(void)) +{ + return libc.atexit(function); +} + +void +exit(int status) { - return libc.get_errno(); + libc.exit(status); + + OF_UNREACHABLE } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wpedantic" static CONST_APTR functionTable[] = { Index: src/runtime/amigaos3.sfd ================================================================== --- src/runtime/amigaos3.sfd +++ src/runtime/amigaos3.sfd @@ -2,11 +2,11 @@ ==basetype struct Library * ==libname objfwrt68k.library ==bias 30 ==public * The following function is only for the linklib. -bool glue_objc_init(unsigned int version, struct objc_libc *libc, FILE *stdout, FILE *stderr)(d0,a0,a1,a2) +bool glue_objc_init(unsigned int version, struct objc_libc *libc)(d0,a0) void glue___objc_exec_class(struct objc_module *_Nonnull module)(a0) IMP _Nonnull glue_objc_msg_lookup(id _Nullable object, SEL _Nonnull selector)(a0,a1) IMP _Nonnull glue_objc_msg_lookup_stret(id _Nullable object, SEL _Nonnull selector)(a0,a1) IMP _Nonnull glue_objc_msg_lookup_super(struct objc_super *_Nonnull super, SEL _Nonnull selector)(a0,a1) IMP _Nonnull glue_objc_msg_lookup_super_stret(struct objc_super *_Nonnull super, SEL _Nonnull selector)(a0,a1) Index: src/runtime/arc.m ================================================================== --- src/runtime/arc.m +++ src/runtime/arc.m @@ -49,12 +49,12 @@ OF_CONSTRUCTOR() { hashtable = objc_hashtable_new(hash, equal, 2); #ifdef OF_HAVE_THREADS - if (!of_spinlock_new(&spinlock)) - OBJC_ERROR("Failed to create spinlock!") + if (of_spinlock_new(&spinlock) != 0) + OBJC_ERROR("Failed to create spinlock!"); #endif } id objc_retain(id object) @@ -120,12 +120,12 @@ objc_storeWeak(id *object, id value) { struct weak_ref *old; #ifdef OF_HAVE_THREADS - if (!of_spinlock_lock(&spinlock)) - OBJC_ERROR("Failed to lock spinlock!") + if (of_spinlock_lock(&spinlock) != 0) + OBJC_ERROR("Failed to lock spinlock!"); #endif if (*object != nil && (old = objc_hashtable_get(hashtable, *object)) != NULL) { for (size_t i = 0; i < old->count; i++) { @@ -168,21 +168,21 @@ } if ((ref->locations = realloc(ref->locations, (ref->count + 1) * sizeof(id *))) == NULL) OBJC_ERROR("Not enough memory to allocate weak " - "reference!") + "reference!"); ref->locations[ref->count++] = object; } else value = nil; *object = value; #ifdef OF_HAVE_THREADS - if (!of_spinlock_unlock(&spinlock)) - OBJC_ERROR("Failed to unlock spinlock!") + if (of_spinlock_unlock(&spinlock) != 0) + OBJC_ERROR("Failed to unlock spinlock!"); #endif return value; } @@ -191,21 +191,21 @@ { id value = nil; struct weak_ref *ref; #ifdef OF_HAVE_THREADS - if (!of_spinlock_lock(&spinlock)) - OBJC_ERROR("Failed to lock spinlock!") + if (of_spinlock_lock(&spinlock) != 0) + OBJC_ERROR("Failed to lock spinlock!"); #endif if (*object != nil && (ref = objc_hashtable_get(hashtable, *object)) != NULL) value = *object; #ifdef OF_HAVE_THREADS - if (!of_spinlock_unlock(&spinlock)) - OBJC_ERROR("Failed to unlock spinlock!") + if (of_spinlock_unlock(&spinlock) != 0) + OBJC_ERROR("Failed to unlock spinlock!"); #endif if (class_respondsToSelector(object_getClass(value), @selector(retainWeakReference)) && [value retainWeakReference]) return value; @@ -242,12 +242,12 @@ objc_moveWeak(id *dest, id *src) { struct weak_ref *ref; #ifdef OF_HAVE_THREADS - if (!of_spinlock_lock(&spinlock)) - OBJC_ERROR("Failed to lock spinlock!") + if (of_spinlock_lock(&spinlock) != 0) + OBJC_ERROR("Failed to lock spinlock!"); #endif if (*src != nil && (ref = objc_hashtable_get(hashtable, *src)) != NULL) { for (size_t i = 0; i < ref->count; i++) { @@ -260,23 +260,23 @@ *dest = *src; *src = nil; #ifdef OF_HAVE_THREADS - if (!of_spinlock_unlock(&spinlock)) - OBJC_ERROR("Failed to unlock spinlock!") + if (of_spinlock_unlock(&spinlock) != 0) + OBJC_ERROR("Failed to unlock spinlock!"); #endif } void objc_zero_weak_references(id value) { struct weak_ref *ref; #ifdef OF_HAVE_THREADS - if (!of_spinlock_lock(&spinlock)) - OBJC_ERROR("Failed to lock spinlock!") + if (of_spinlock_lock(&spinlock) != 0) + OBJC_ERROR("Failed to lock spinlock!"); #endif if ((ref = objc_hashtable_get(hashtable, value)) != NULL) { for (size_t i = 0; i < ref->count; i++) *ref->locations[i] = nil; @@ -285,9 +285,9 @@ free(ref->locations); free(ref); } #ifdef OF_HAVE_THREADS - if (!of_spinlock_unlock(&spinlock)) - OBJC_ERROR("Failed to unlock spinlock!") + if (of_spinlock_unlock(&spinlock) != 0) + OBJC_ERROR("Failed to unlock spinlock!"); #endif } Index: src/runtime/autorelease.m ================================================================== --- src/runtime/autorelease.m +++ src/runtime/autorelease.m @@ -51,13 +51,13 @@ #endif #if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS) OF_CONSTRUCTOR() { - OF_ENSURE(of_tlskey_new(&objectsKey)); - OF_ENSURE(of_tlskey_new(&countKey)); - OF_ENSURE(of_tlskey_new(&sizeKey)); + OF_ENSURE(of_tlskey_new(&objectsKey) == 0); + OF_ENSURE(of_tlskey_new(&countKey) == 0); + OF_ENSURE(of_tlskey_new(&sizeKey) == 0); } #endif void * objc_autoreleasePoolPush() @@ -98,17 +98,17 @@ free(objects); objects = NULL; #if defined(OF_HAVE_COMPILER_TLS) || !defined(OF_HAVE_THREADS) size = 0; #else - OF_ENSURE(of_tlskey_set(objectsKey, objects)); - OF_ENSURE(of_tlskey_set(sizeKey, (void *)0)); + OF_ENSURE(of_tlskey_set(objectsKey, objects) == 0); + OF_ENSURE(of_tlskey_set(sizeKey, (void *)0) == 0); #endif } #if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS) - OF_ENSURE(of_tlskey_set(countKey, (void *)count)); + OF_ENSURE(of_tlskey_set(countKey, (void *)count) == 0); #endif } id _objc_rootAutorelease(id object) @@ -127,18 +127,18 @@ OF_ENSURE((objects = realloc(objects, size * sizeof(id))) != NULL); #if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS) - OF_ENSURE(of_tlskey_set(objectsKey, objects)); - OF_ENSURE(of_tlskey_set(sizeKey, (void *)size)); + OF_ENSURE(of_tlskey_set(objectsKey, objects) == 0); + OF_ENSURE(of_tlskey_set(sizeKey, (void *)size) == 0); #endif } objects[count++] = object; #if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS) - OF_ENSURE(of_tlskey_set(countKey, (void *)count)); + OF_ENSURE(of_tlskey_set(countKey, (void *)count) == 0); #endif return object; } Index: src/runtime/class.m ================================================================== --- src/runtime/class.m +++ src/runtime/class.m @@ -341,10 +341,17 @@ return; if (class->superclass) initializeClass(class->superclass); + /* + * Avoid double-initialization: One of the superclasses' +[initialize] + * might have called this class and hence it already got initialized. + */ + if (class->info & OBJC_CLASS_INFO_INITIALIZED) + return; + class->info |= OBJC_CLASS_INFO_DTABLE; class->isa->info |= OBJC_CLASS_INFO_DTABLE; objc_update_dtable(class); objc_update_dtable(class->isa); @@ -468,16 +475,16 @@ { struct objc_class *class, *metaclass; Class iter, rootclass = Nil; if (extraBytes > LONG_MAX) - OBJC_ERROR("extraBytes out of range!") + OBJC_ERROR("extraBytes out of range!"); if ((class = calloc(1, sizeof(*class))) == NULL || (metaclass = calloc(1, sizeof(*class))) == NULL) OBJC_ERROR("Not enough memory to allocate class pair for class " - "%s!", name) + "%s!", name); class->isa = metaclass; class->superclass = superclass; class->name = name; class->info = OBJC_CLASS_INFO_CLASS; Index: src/runtime/exception.m ================================================================== --- src/runtime/exception.m +++ src/runtime/exception.m @@ -246,12 +246,12 @@ #ifdef OF_HAVE_THREADS static of_spinlock_t emergencyExceptionsSpinlock; OF_CONSTRUCTOR() { - if (!of_spinlock_new(&emergencyExceptionsSpinlock)) - OBJC_ERROR("Cannot create spinlock!") + if (of_spinlock_new(&emergencyExceptionsSpinlock) != 0) + OBJC_ERROR("Cannot create spinlock!"); } #endif static uint64_t readULEB128(const uint8_t **ptr) @@ -308,11 +308,11 @@ case DW_EH_PE_textrel: return _Unwind_GetTextRelBase(ctx); #endif } - OBJC_ERROR("Unknown encoding!") + OBJC_ERROR("Unknown encoding!"); } static size_t sizeForEncoding(uint8_t enc) { @@ -328,20 +328,20 @@ return 4; case DW_EH_PE_udata8: return 8; } - OBJC_ERROR("Unknown encoding!") + OBJC_ERROR("Unknown encoding!"); } static uint64_t readValue(uint8_t enc, const uint8_t **ptr) { uint64_t value; if (enc == DW_EH_PE_aligned) - OBJC_ERROR("DW_EH_PE_aligned is not implemented!") + OBJC_ERROR("DW_EH_PE_aligned is not implemented!"); #define READ(type) \ { \ type tmp; \ memcpy(&tmp, *ptr, sizeof(type)); \ @@ -369,11 +369,11 @@ case DW_EH_PE_sdata4: READ(int32_t) case DW_EH_PE_sdata8: READ(int64_t) default: - OBJC_ERROR("Unknown encoding!") + OBJC_ERROR("Unknown encoding!"); } #undef READ return value; } @@ -558,11 +558,11 @@ return HANDLER_FOUND; } } else if (filter == 0) return CLEANUP_FOUND; else if (filter < 0) - OBJC_ERROR("Invalid filter!") + OBJC_ERROR("Invalid filter!"); } while (displacement != 0); return 0; } @@ -690,11 +690,12 @@ _Unwind_SetIP(ctx, landingpad); return _URC_INSTALL_CONTEXT; } - OBJC_ERROR("Neither _UA_SEARCH_PHASE nor _UA_CLEANUP_PHASE in actions!") + OBJC_ERROR( + "Neither _UA_SEARCH_PHASE nor _UA_CLEANUP_PHASE in actions!"); } static void cleanup(_Unwind_Reason_Code reason, struct _Unwind_Exception *ex) { @@ -704,18 +705,18 @@ static void emergencyExceptionCleanup(_Unwind_Reason_Code reason, struct _Unwind_Exception *ex) { #ifdef OF_HAVE_THREADS - if (!of_spinlock_lock(&emergencyExceptionsSpinlock)) + if (of_spinlock_lock(&emergencyExceptionsSpinlock) != 0) OBJC_ERROR("Cannot lock spinlock!"); #endif ex->class = 0; #ifdef OF_HAVE_THREADS - if (!of_spinlock_unlock(&emergencyExceptionsSpinlock)) + if (of_spinlock_unlock(&emergencyExceptionsSpinlock) != 0) OBJC_ERROR("Cannot unlock spinlock!"); #endif } void @@ -724,11 +725,11 @@ struct objc_exception *e = calloc(1, sizeof(*e)); bool emergency = false; if (e == NULL) { #ifdef OF_HAVE_THREADS - if (!of_spinlock_lock(&emergencyExceptionsSpinlock)) + if (of_spinlock_lock(&emergencyExceptionsSpinlock) != 0) OBJC_ERROR("Cannot lock spinlock!"); #endif for (uint_fast8_t i = 0; i < NUM_EMERGENCY_EXCEPTIONS; i++) { if (emergencyExceptions[i].exception.class == 0) { @@ -739,17 +740,17 @@ break; } } #ifdef OF_HAVE_THREADS - if (!of_spinlock_unlock(&emergencyExceptionsSpinlock)) + if (of_spinlock_unlock(&emergencyExceptionsSpinlock) != 0) OBJC_ERROR("Cannot lock spinlock!"); #endif } if (e == NULL) - OBJC_ERROR("Not enough memory to allocate exception!") + OBJC_ERROR("Not enough memory to allocate exception!"); e->exception.class = GNUCOBJC_EXCEPTION_CLASS; e->exception.cleanup = (emergency ? emergencyExceptionCleanup : cleanup); e->object = object; @@ -757,11 +758,11 @@ _Unwind_RaiseException(&e->exception); if (uncaughtExceptionHandler != NULL) uncaughtExceptionHandler(object); - OBJC_ERROR("_Unwind_RaiseException() returned!") + OBJC_ERROR("_Unwind_RaiseException() returned!"); } objc_uncaught_exception_handler_t objc_setUncaughtExceptionHandler(objc_uncaught_exception_handler_t handler) { Index: src/runtime/linklib/linklib.m ================================================================== --- src/runtime/linklib/linklib.m +++ src/runtime/linklib/linklib.m @@ -20,16 +20,16 @@ #import "ObjFWRT.h" #import "private.h" #import "macros.h" #include +#include struct ObjFWRTBase; #import "inline.h" -#include #include #include #if defined(OF_AMIGAOS_M68K) # include @@ -68,14 +68,30 @@ #endif struct Library *ObjFWRTBase; void *__objc_class_name_Protocol; -static int * -get_errno(void) +static void +error(const char *string, ULONG arg) { - return &errno; + struct Library *IntuitionBase = OpenLibrary("intuition.library", 0); + + if (IntuitionBase != NULL) { + struct EasyStruct easy = { + .es_StructSize = sizeof(easy), + .es_Flags = 0, + .es_Title = (void *)NULL, + .es_TextFormat = (void *)string, + (void *)"OK" + }; + + EasyRequest(NULL, &easy, NULL, arg); + + CloseLibrary(IntuitionBase); + } + + exit(EXIT_FAILURE); } static void __attribute__((__used__)) ctor(void) { @@ -83,13 +99,10 @@ struct objc_libc libc = { .malloc = malloc, .calloc = calloc, .realloc = realloc, .free = free, - .vfprintf = vfprintf, - .fflush = fflush, - .abort = abort, #ifdef HAVE_SJLJ_EXCEPTIONS ._Unwind_SjLj_RaiseException = _Unwind_SjLj_RaiseException, #else ._Unwind_RaiseException = _Unwind_RaiseException, #endif @@ -114,26 +127,27 @@ #endif #ifdef OF_MORPHOS .__register_frame = __register_frame, .__deregister_frame = __deregister_frame, #endif - .get_errno = get_errno, +#ifdef OF_AMIGAOS_M68K + .vsnprintf = vsnprintf, +#endif + .atexit = atexit, + .exit = exit, }; if (initialized) return; if ((ObjFWRTBase = OpenLibrary(OBJFWRT_AMIGA_LIB, - OBJFWRT_LIB_MINOR)) == NULL) { - fputs("Failed to open " OBJFWRT_AMIGA_LIB "!\n", stderr); - abort(); - } - - if (!glue_objc_init(1, &libc, stdout, stderr)) { - fputs("Failed to initialize " OBJFWRT_AMIGA_LIB "!\n", stderr); - abort(); - } + OBJFWRT_LIB_MINOR)) == NULL) + error("Failed to open " OBJFWRT_AMIGA_LIB " version %lu!", + OBJFWRT_LIB_MINOR); + + if (!glue_objc_init(1, &libc)) + error("Failed to initialize " OBJFWRT_AMIGA_LIB "!", 0); initialized = true; } static void __attribute__((__used__)) Index: src/runtime/misc.m ================================================================== --- src/runtime/misc.m +++ src/runtime/misc.m @@ -15,15 +15,31 @@ * file. */ #include "config.h" +#include #include #include #include "ObjFWRT.h" #include "private.h" + +#ifdef OF_WINDOWS +# include +#endif + +#ifdef OF_AMIGAOS +# define USE_INLINE_STDARG +# include +# include +# define __NOLIBBASE__ +# define Class IntuitionClass +# include +# undef Class +# undef __NOLIBBASE__ +#endif static objc_enumeration_mutation_handler_t enumerationMutationHandler = NULL; void objc_enumerationMutation(id object) @@ -37,5 +53,83 @@ void objc_setEnumerationMutationHandler(objc_enumeration_mutation_handler_t handler) { enumerationMutationHandler = handler; } + +void +objc_error(const char *title, const char *format, ...) +{ +#if defined(OF_WINDOWS) || defined(OF_AMIGAOS) +# define BUF_LEN 512 + char message[BUF_LEN]; + int status; + va_list args; + + va_start(args, format); + status = vsnprintf(message, BUF_LEN, format, args); + if (status <= 0 || status >= BUF_LEN) + message[0] = '\0'; + va_end(args); +# undef BUF_LEN +#endif + +#if defined(OF_WINDOWS) + fprintf(stderr, "[%s] %s\n", title, message); + fflush(stderr); + + MessageBoxA(NULL, message, title, + MB_OK | MB_SYSTEMMODAL | MB_ICONERROR); + + exit(EXIT_FAILURE); +#elif defined(OF_AMIGAOS) + struct Library *IntuitionBase; +# ifdef OF_AMIGAOS4 + struct IntuitionIFace *IIntuition; +# endif + struct EasyStruct easy; + +# ifndef OF_AMIGAOS4 + kprintf("[%s] %s\n", title, message); +# endif + + if ((IntuitionBase = OpenLibrary("intuition.library", 0)) == NULL) + exit(EXIT_FAILURE); + +# ifdef OF_AMIGAOS4 + if ((IIntuition = (struct IntuitionIFace *)GetInterface(IntuitionBase, + "main", 1, NULL)) == NULL) + exit(EXIT_FAILURE); +# endif + + easy.es_StructSize = sizeof(easy); + easy.es_Flags = 0; + easy.es_Title = (void *)title; + easy.es_TextFormat = (void *)"%s"; + easy.es_GadgetFormat = (void *)"OK"; + + EasyRequest(NULL, &easy, NULL, (ULONG)message); + +# ifdef OF_AMIGAOS4 + DropInterface((struct Interface *)IIntuition); +# endif + + CloseLibrary(IntuitionBase); + + exit(EXIT_FAILURE); +#else + va_list args; + + va_start(args, format); + + fprintf(stderr, "[%s] ", title); + vfprintf(stderr, format, args); + fprintf(stderr, "\n"); + fflush(stderr); + + va_end(args); + + abort(); +#endif + + OF_UNREACHABLE +} Index: src/runtime/morphos-clib.h ================================================================== --- src/runtime/morphos-clib.h +++ src/runtime/morphos-clib.h @@ -1,7 +1,7 @@ /* The following function is only for the linklib. */ -bool glue_objc_init(unsigned int, struct objc_libc *, FILE *, FILE *); +bool glue_objc_init(unsigned int, struct objc_libc *); void glue___objc_exec_class(struct objc_module *); IMP glue_objc_msg_lookup(id, SEL); IMP glue_objc_msg_lookup_stret(id, SEL); IMP glue_objc_msg_lookup_super(struct objc_super *, SEL); IMP glue_objc_msg_lookup_super_stret(struct objc_super *, SEL); Index: src/runtime/morphos.fd ================================================================== --- src/runtime/morphos.fd +++ src/runtime/morphos.fd @@ -1,10 +1,10 @@ ##base _ObjFWRTBase ##bias 30 ##public * The following function is only for the linklib. -glue_objc_init(version,libc,stdout,stderr)(sysv,r12base) +glue_objc_init(version,libc)(sysv,r12base) glue___objc_exec_class(module)(sysv,r12base) glue_objc_msg_lookup(object,selector)(sysv,r12base) glue_objc_msg_lookup_stret(object,selector)(sysv,r12base) glue_objc_msg_lookup_super(super,selector)(sysv,r12base) glue_objc_msg_lookup_super_stret(super,selector)(sysv,r12base) Index: src/runtime/private.h ================================================================== --- src/runtime/private.h +++ src/runtime/private.h @@ -223,13 +223,10 @@ struct objc_libc { void *_Nullable (*_Nonnull malloc)(size_t); void *_Nullable (*_Nonnull calloc)(size_t, size_t); void *_Nullable (*_Nonnull realloc)(void *_Nullable, size_t); void (*_Nonnull free)(void *_Nullable); - int (*_Nonnull vfprintf)(FILE *_Nonnull, const char *_Nonnull, va_list); - int (*_Nonnull fflush)(FILE *_Nonnull); - void (*_Nonnull abort)(void); # ifdef HAVE_SJLJ_EXCEPTIONS int (*_Nonnull _Unwind_SjLj_RaiseException)(void *_Nonnull); # else int (*_Nonnull _Unwind_RaiseException)(void *_Nonnull); # endif @@ -255,11 +252,16 @@ # endif # ifdef OF_MORPHOS void (*_Nonnull __register_frame)(void *_Nonnull); void (*_Nonnull __deregister_frame)(void *_Nonnull); # endif - int *_Nonnull (*_Nonnull get_errno)(void); +# ifdef OF_AMIGAOS_M68K + int (*_Nonnull vsnprintf)(char *restrict _Nonnull str, size_t size, + const char *_Nonnull restrict fmt, va_list args); +# endif + int (*_Nonnull atexit)(void (*_Nonnull)(void)); + void (*_Nonnull exit)(int); }; #endif #ifdef OBJC_COMPILING_AMIGA_LIBRARY # if defined(__MORPHOS__) @@ -268,16 +270,10 @@ # else # define OBJC_M68K_ARG(type, name, reg) \ register type reg_##name __asm__(#reg); \ type name = reg_##name; # endif -# undef stdout -# undef stderr -# undef errno -extern FILE *_Nonnull stdout, *_Nonnull stderr; -extern int *_Nonnull objc_get_errno(void); -# define errno (*objc_get_errno()) #endif extern void objc_register_all_categories(struct objc_symtab *_Nonnull); extern struct objc_category *_Nullable *_Nullable objc_categories_for_class(Class _Nonnull); @@ -344,10 +340,16 @@ uint8_t j = idx; return dtable->buckets[i]->buckets[j]; #endif } + +extern void OF_NO_RETURN_FUNC objc_error(const char *_Nonnull title, + const char *_Nonnull format, ...); +#define OBJC_ERROR(...) \ + objc_error("ObjFWRT @ " __FILE__ ":" OF_STRINGIFY(__LINE__), \ + __VA_ARGS__) #if defined(OF_ELF) # if defined(OF_X86_64) || defined(OF_X86) || defined(OF_POWERPC) || \ defined(OF_ARM64) || defined(OF_ARM) || \ defined(OF_MIPS64_N64) || defined(OF_MIPS) || \ @@ -358,20 +360,10 @@ # if defined(OF_X86_64) || defined(OF_X86) # define OF_ASM_LOOKUP # endif #endif -#define OBJC_ERROR(...) \ - { \ - fprintf(stderr, "[objc @ " __FILE__ ":%d] ", __LINE__); \ - fprintf(stderr, __VA_ARGS__); \ - fprintf(stderr, "\n"); \ - fflush(stderr); \ - abort(); \ - OF_UNREACHABLE \ - } - @interface DummyObject { Class _Nonnull isa; } Index: src/runtime/property.m ================================================================== --- src/runtime/property.m +++ src/runtime/property.m @@ -31,12 +31,12 @@ #ifdef OF_HAVE_THREADS OF_CONSTRUCTOR() { for (size_t i = 0; i < NUM_SPINLOCKS; i++) - if (!of_spinlock_new(&spinlocks[i])) - OBJC_ERROR("Failed to initialize spinlocks!") + if (of_spinlock_new(&spinlocks[i]) != 0) + OBJC_ERROR("Failed to initialize spinlocks!"); } #endif id objc_getProperty(id self, SEL _cmd, ptrdiff_t offset, bool atomic) @@ -44,15 +44,15 @@ if (atomic) { id *ptr = (id *)(void *)((char *)self + offset); #ifdef OF_HAVE_THREADS unsigned hash = SPINLOCK_HASH(ptr); - OF_ENSURE(of_spinlock_lock(&spinlocks[hash])); + OF_ENSURE(of_spinlock_lock(&spinlocks[hash]) == 0); @try { return [[*ptr retain] autorelease]; } @finally { - OF_ENSURE(of_spinlock_unlock(&spinlocks[hash])); + OF_ENSURE(of_spinlock_unlock(&spinlocks[hash]) == 0); } #else return [[*ptr retain] autorelease]; #endif } @@ -67,11 +67,11 @@ if (atomic) { id *ptr = (id *)(void *)((char *)self + offset); #ifdef OF_HAVE_THREADS unsigned hash = SPINLOCK_HASH(ptr); - OF_ENSURE(of_spinlock_lock(&spinlocks[hash])); + OF_ENSURE(of_spinlock_lock(&spinlocks[hash]) == 0); @try { #endif id old = *ptr; switch (copy) { @@ -86,11 +86,11 @@ } [old release]; #ifdef OF_HAVE_THREADS } @finally { - OF_ENSURE(of_spinlock_unlock(&spinlocks[hash])); + OF_ENSURE(of_spinlock_unlock(&spinlocks[hash]) == 0); } #endif return; } @@ -119,15 +119,15 @@ { if (atomic) { #ifdef OF_HAVE_THREADS unsigned hash = SPINLOCK_HASH(src); - OF_ENSURE(of_spinlock_lock(&spinlocks[hash])); + OF_ENSURE(of_spinlock_lock(&spinlocks[hash]) == 0); #endif memcpy(dest, src, size); #ifdef OF_HAVE_THREADS - OF_ENSURE(of_spinlock_unlock(&spinlocks[hash])); + OF_ENSURE(of_spinlock_unlock(&spinlocks[hash]) == 0); #endif return; } @@ -140,15 +140,15 @@ { if (atomic) { #ifdef OF_HAVE_THREADS unsigned hash = SPINLOCK_HASH(src); - OF_ENSURE(of_spinlock_lock(&spinlocks[hash])); + OF_ENSURE(of_spinlock_lock(&spinlocks[hash]) == 0); #endif memcpy(dest, src, size); #ifdef OF_HAVE_THREADS - OF_ENSURE(of_spinlock_unlock(&spinlocks[hash])); + OF_ENSURE(of_spinlock_unlock(&spinlocks[hash]) == 0); #endif return; } Index: src/runtime/synchronized.m ================================================================== --- src/runtime/synchronized.m +++ src/runtime/synchronized.m @@ -35,12 +35,12 @@ static of_mutex_t mutex; OF_CONSTRUCTOR() { - if (!of_mutex_new(&mutex)) - OBJC_ERROR("Failed to create mutex!") + if (of_mutex_new(&mutex) != 0) + OBJC_ERROR("Failed to create mutex!"); } #endif int objc_sync_enter(id object) @@ -49,46 +49,46 @@ return 0; #ifdef OF_HAVE_THREADS struct lock_s *lock; - if (!of_mutex_lock(&mutex)) + if (of_mutex_lock(&mutex) != 0) OBJC_ERROR("Failed to lock mutex!"); /* Look if we already have a lock */ for (lock = locks; lock != NULL; lock = lock->next) { if (lock->object != object) continue; lock->count++; - if (!of_mutex_unlock(&mutex)) + if (of_mutex_unlock(&mutex) != 0) OBJC_ERROR("Failed to unlock mutex!"); - if (!of_rmutex_lock(&lock->rmutex)) + if (of_rmutex_lock(&lock->rmutex) != 0) OBJC_ERROR("Failed to lock mutex!"); return 0; } /* Create a new lock */ if ((lock = malloc(sizeof(*lock))) == NULL) OBJC_ERROR("Failed to allocate memory for mutex!"); - if (!of_rmutex_new(&lock->rmutex)) + if (of_rmutex_new(&lock->rmutex) != 0) OBJC_ERROR("Failed to create mutex!"); lock->object = object; lock->count = 1; lock->next = locks; locks = lock; - if (!of_mutex_unlock(&mutex)) + if (of_mutex_unlock(&mutex) != 0) OBJC_ERROR("Failed to unlock mutex!"); - if (!of_rmutex_lock(&lock->rmutex)) + if (of_rmutex_lock(&lock->rmutex) != 0) OBJC_ERROR("Failed to lock mutex!"); #endif return 0; } @@ -100,24 +100,24 @@ return 0; #ifdef OF_HAVE_THREADS struct lock_s *lock, *last = NULL; - if (!of_mutex_lock(&mutex)) + if (of_mutex_lock(&mutex) != 0) OBJC_ERROR("Failed to lock mutex!"); for (lock = locks; lock != NULL; lock = lock->next) { if (lock->object != object) { last = lock; continue; } - if (!of_rmutex_unlock(&lock->rmutex)) + if (of_rmutex_unlock(&lock->rmutex) != 0) OBJC_ERROR("Failed to unlock mutex!"); if (--lock->count == 0) { - if (!of_rmutex_free(&lock->rmutex)) + if (of_rmutex_free(&lock->rmutex) != 0) OBJC_ERROR("Failed to destroy mutex!"); if (last != NULL) last->next = lock->next; if (locks == lock) @@ -124,11 +124,11 @@ locks = lock->next; free(lock); } - if (!of_mutex_unlock(&mutex)) + if (of_mutex_unlock(&mutex) != 0) OBJC_ERROR("Failed to unlock mutex!"); return 0; } Index: src/runtime/threading.m ================================================================== --- src/runtime/threading.m +++ src/runtime/threading.m @@ -28,25 +28,25 @@ static of_rmutex_t globalMutex; static void init(void) { - if (!of_rmutex_new(&globalMutex)) + if (of_rmutex_new(&globalMutex) != 0) OBJC_ERROR("Failed to create global mutex!"); } void objc_global_mutex_lock(void) { static of_once_t once_control = OF_ONCE_INIT; of_once(&once_control, init); - if (!of_rmutex_lock(&globalMutex)) + if (of_rmutex_lock(&globalMutex) != 0) OBJC_ERROR("Failed to lock global mutex!"); } void objc_global_mutex_unlock(void) { - if (!of_rmutex_unlock(&globalMutex)) + if (of_rmutex_unlock(&globalMutex) != 0) OBJC_ERROR("Failed to unlock global mutex!"); } Index: src/socket.h ================================================================== --- src/socket.h +++ src/socket.h @@ -79,14 +79,10 @@ typedef long socklen_t; typedef u_char sa_family_t; typedef u_short in_port_t; #endif -#ifdef OF_MORPHOS_IXEMUL -typedef int socklen_t; -#endif - /** * @brief A socket address family. */ typedef enum { /** An unknown address family. */ Index: src/socket.m ================================================================== --- src/socket.m +++ src/socket.m @@ -24,10 +24,13 @@ #include #import "OFArray.h" #import "OFCharacterSet.h" #import "OFLocale.h" +#ifdef OF_HAVE_THREADS +# import "OFMutex.h" +#endif #import "OFString.h" #import "OFException.h" /* For some E* -> WSAE* defines */ #import "OFInitializationFailedException.h" #import "OFInvalidArgumentException.h" @@ -36,15 +39,11 @@ #import "OFUnlockFailedException.h" #import "socket.h" #import "socket_helpers.h" #ifdef OF_HAVE_THREADS -# if !defined(OF_AMIGAOS) || defined(OF_MORPHOS) -# import "mutex.h" -# else -# import "tlskey.h" -# endif +# import "tlskey.h" #endif #import "once.h" #ifdef OF_AMIGAOS # include @@ -54,11 +53,17 @@ # include <3ds/types.h> # include <3ds/services/soc.h> #endif #if defined(OF_HAVE_THREADS) && (!defined(OF_AMIGAOS) || defined(OF_MORPHOS)) -static of_mutex_t mutex; +static OFMutex *mutex; + +static void +releaseMutex(void) +{ + [mutex release]; +} #endif #if !defined(OF_AMIGAOS) || defined(OF_MORPHOS) || !defined(OF_HAVE_THREADS) static bool initSuccessful = false; #endif @@ -77,15 +82,15 @@ #endif #if defined(OF_HAVE_THREADS) && defined(OF_AMIGAOS) && !defined(OF_MORPHOS) OF_CONSTRUCTOR() { - if (!of_tlskey_new(&of_socket_base_key)) + if (of_tlskey_new(&of_socket_base_key) != 0) @throw [OFInitializationFailedException exception]; # ifdef OF_AMIGAOS4 - if (!of_tlskey_new(&of_socket_interface_key)) + if (of_tlskey_new(&of_socket_interface_key) != 0) @throw [OFInitializationFailedException exception]; # endif } #endif @@ -123,34 +128,34 @@ atexit((void (*)(void))socExit); # endif # if defined(OF_HAVE_THREADS) && (!defined(OF_AMIGAOS) || defined(OF_MORPHOS)) - if (!of_mutex_new(&mutex)) - return; + mutex = [[OFMutex alloc] init]; + atexit(releaseMutex); # ifdef OF_WII - if (!of_spinlock_new(&spinlock)) + if (of_spinlock_new(&spinlock) != 0) return; # endif # endif initSuccessful = true; } -# ifdef OF_AMIGAOS OF_DESTRUCTOR() { +# ifdef OF_AMIGAOS # ifdef OF_AMIGAOS4 if (ISocket != NULL) DropInterface((struct Interface *)ISocket); # endif if (SocketBase != NULL) CloseLibrary(SocketBase); -} # endif +} #endif bool of_socket_init(void) { @@ -181,20 +186,20 @@ CloseLibrary(socketBase); return false; } # endif - if (!of_tlskey_set(of_socket_base_key, socketBase)) { + if (of_tlskey_set(of_socket_base_key, socketBase) != 0) { CloseLibrary(socketBase); # ifdef OF_AMIGAOS4 DropInterface((struct Interface *)socketInterface); # endif return false; } # ifdef OF_AMIGAOS4 - if (!of_tlskey_set(of_socket_interface_key, socketInterface)) { + if (of_tlskey_set(of_socket_interface_key, socketInterface) != 0) { CloseLibrary(socketBase); DropInterface((struct Interface *)socketInterface); return false; } # endif @@ -327,20 +332,15 @@ socklen_t *restrict addrLen) { int ret; # if defined(OF_HAVE_THREADS) && (!defined(OF_AMIGAOS) || defined(OF_MORPHOS)) - if (!of_mutex_lock(&mutex)) - @throw [OFLockFailedException exception]; - + [mutex lock]; # endif - ret = getsockname(sock, addr, addrLen); - # if defined(OF_HAVE_THREADS) && (!defined(OF_AMIGAOS) || defined(OF_MORPHOS)) - if (!of_mutex_unlock(&mutex)) - @throw [OFUnlockFailedException exception]; + [mutex unlock]; # endif return ret; } #endif Index: src/socket_helpers.h ================================================================== --- src/socket_helpers.h +++ src/socket_helpers.h @@ -71,14 +71,10 @@ # endif #elif !defined(OF_WINDOWS) && !defined(OF_WII) # define closesocket(sock) close(sock) #endif -#ifdef OF_MORPHOS_IXEMUL -typedef uint32_t in_addr_t; -#endif - #ifdef OF_WII # define accept(sock, addr, addrlen) net_accept(sock, addr, addrlen) # define bind(sock, addr, addrlen) net_bind(sock, addr, addrlen) # define closesocket(sock) net_close(sock) # define connect(sock, addr, addrlen) \ Index: src/thread.h ================================================================== --- src/thread.h +++ src/thread.h @@ -63,14 +63,14 @@ #endif #ifdef __cplusplus extern "C" { #endif -extern bool of_thread_attr_init(of_thread_attr_t *attr); -extern bool of_thread_new(of_thread_t *thread, const char *name, +extern int of_thread_attr_init(of_thread_attr_t *attr); +extern int of_thread_new(of_thread_t *thread, const char *name, void (*function)(id), id object, const of_thread_attr_t *attr); extern void of_thread_set_name(const char *name); -extern bool of_thread_join(of_thread_t thread); -extern bool of_thread_detach(of_thread_t thread); +extern int of_thread_join(of_thread_t thread); +extern int of_thread_detach(of_thread_t thread); #ifdef __cplusplus } #endif Index: src/tlskey.h ================================================================== --- src/tlskey.h +++ src/tlskey.h @@ -14,10 +14,12 @@ * LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this * file. */ #include "objfw-defs.h" + +#include #include "platform.h" #if !defined(OF_HAVE_THREADS) || \ (!defined(OF_HAVE_PTHREADS) && !defined(OF_WINDOWS) && !defined(OF_AMIGAOS)) @@ -43,12 +45,12 @@ #endif #ifdef __cplusplus extern "C" { #endif -extern bool of_tlskey_new(of_tlskey_t *key); -extern bool of_tlskey_free(of_tlskey_t key); +extern int of_tlskey_new(of_tlskey_t *key); +extern int of_tlskey_free(of_tlskey_t key); #ifdef __cplusplus } #endif /* TLS keys are inlined for performance. */ @@ -58,45 +60,45 @@ of_tlskey_get(of_tlskey_t key) { return pthread_getspecific(key); } -static OF_INLINE bool +static OF_INLINE int of_tlskey_set(of_tlskey_t key, void *ptr) { - return (pthread_setspecific(key, ptr) == 0); + return pthread_setspecific(key, ptr); } #elif defined(OF_WINDOWS) static OF_INLINE void * of_tlskey_get(of_tlskey_t key) { return TlsGetValue(key); } -static OF_INLINE bool +static OF_INLINE int of_tlskey_set(of_tlskey_t key, void *ptr) { - return TlsSetValue(key, ptr); + return (TlsSetValue(key, ptr) ? 0 : EINVAL); } #elif defined(OF_MORPHOS) static OF_INLINE void * of_tlskey_get(of_tlskey_t key) { return (void *)TLSGetValue(key); } -static OF_INLINE bool +static OF_INLINE int of_tlskey_set(of_tlskey_t key, void *ptr) { - return TLSSetValue(key, (APTR)ptr); + return (TLSSetValue(key, (APTR)ptr) ? 0 : EINVAL); } #elif defined(OF_AMIGAOS) /* Those are too big too inline. */ # ifdef __cplusplus extern "C" { # endif extern void *of_tlskey_get(of_tlskey_t key); -extern bool of_tlskey_set(of_tlskey_t key, void *ptr); +extern int of_tlskey_set(of_tlskey_t key, void *ptr); # ifdef __cplusplus } # endif #endif Index: tests/OFStringTests.m ================================================================== --- tests/OFStringTests.m +++ tests/OFStringTests.m @@ -24,10 +24,14 @@ #import "TestsAppDelegate.h" #import "OFString.h" #import "OFMutableUTF8String.h" #import "OFUTF8String.h" + +#ifndef INFINITY +# define INFINITY __builtin_inf() +#endif static OFString *module = nil; static OFString *whitespace[] = { @" \r \t\n\t \tasd \t \t\t\r\n", @" \t\t \t\t \t \t" @@ -599,11 +603,14 @@ [[a objectAtIndex: i++] isEqual: @"bar"] && [[a objectAtIndex: i++] isEqual: @""] && [[a objectAtIndex: i++] isEqual: @"baz"] && [[a objectAtIndex: i++] isEqual: @""] && [[a objectAtIndex: i++] isEqual: @""] && - a.count == i) + a.count == i && + (a = [C(@"foo") componentsSeparatedByString: @""]) && + [[a objectAtIndex: 0] isEqual: @"foo"] && + a.count == 1) i = 0; TEST(@"-[componentsSeparatedByString:options:]", (a = [C(@"fooXXbarXXXXbazXXXX") componentsSeparatedByString: @"XX" Index: utils/ofhttp/OFHTTP.m ================================================================== --- utils/ofhttp/OFHTTP.m +++ utils/ofhttp/OFHTTP.m @@ -64,10 +64,11 @@ size_t _URLIndex; int _errorCode; OFString *_outputPath, *_currentFileName; bool _continue, _force, _detectFileName, _detectFileNameRequest; bool _detectedFileName, _quiet, _verbose, _insecure, _ignoreStatus; + bool _useUnicode; OFStream *_body; of_http_request_method_t _method; OFMutableDictionary *_clientHeaders; OFHTTPClient *_HTTPClient; char *_buffer; @@ -575,10 +576,12 @@ } if (_insecure) _HTTPClient.allowsInsecureRedirects = true; + _useUnicode = ([OFLocale encoding] == OF_STRING_ENCODING_UTF_8); + [self performSelector: @selector(downloadNextURL) afterDelay: 0]; } - (void)client: (OFHTTPClient *)client @@ -626,12 +629,16 @@ key, object]; objc_autoreleasePoolPop(pool); } - if (!_quiet) - [of_stdout writeFormat: @"☇ %@", URL.string]; + if (!_quiet) { + if (_useUnicode) + [of_stdout writeFormat: @"☇ %@", URL.string]; + else + [of_stdout writeFormat: @"< %@", URL.string]; + } _length = 0; return true; } @@ -708,11 +715,14 @@ if (!_quiet) { OFString *lengthString = [headers objectForKey: @"Content-Length"]; OFString *type = [headers objectForKey: @"Content-Type"]; - [of_stdout writeFormat: @" ➜ %hd\n", statusCode]; + if (_useUnicode) + [of_stdout writeFormat: @" ➜ %hd\n", statusCode]; + else + [of_stdout writeFormat: @" -> %hd\n", statusCode]; if (type == nil) type = OF_LOCALIZED(@"type_unknown", @"unknown"); if (lengthString != nil) { @@ -961,11 +971,12 @@ } if (!_quiet) { _progressBar = [[ProgressBar alloc] initWithLength: _length - resumedFrom: _resumedFrom]; + resumedFrom: _resumedFrom + useUnicode: _useUnicode]; [_progressBar setReceived: _received]; [_progressBar draw]; } [_currentFileName release]; @@ -1024,12 +1035,16 @@ } clientHeaders = [[_clientHeaders mutableCopy] autorelease]; if (_detectFileName && !_detectedFileName) { - if (!_quiet) - [of_stdout writeFormat: @"⠒ %@", URL.string]; + if (!_quiet) { + if (_useUnicode) + [of_stdout writeFormat: @"⠒ %@", URL.string]; + else + [of_stdout writeFormat: @"? %@", URL.string]; + } request = [OFHTTPRequest requestWithURL: URL]; request.headers = clientHeaders; request.method = OF_HTTP_REQUEST_METHOD_HEAD; @@ -1068,12 +1083,16 @@ forKey: @"Range"]; } @catch (OFRetrieveItemAttributesFailedException *e) { } } - if (!_quiet) - [of_stdout writeFormat: @"⇣ %@", URL.string]; + if (!_quiet) { + if (_useUnicode) + [of_stdout writeFormat: @"⇣ %@", URL.string]; + else + [of_stdout writeFormat: @"< %@", URL.string]; + } request = [OFHTTPRequest requestWithURL: URL]; request.headers = clientHeaders; request.method = _method; Index: utils/ofhttp/ProgressBar.h ================================================================== --- utils/ofhttp/ProgressBar.h +++ utils/ofhttp/ProgressBar.h @@ -22,10 +22,11 @@ #define BPS_WINDOW_SIZE 10 @interface ProgressBar: OFObject { + bool _useUnicode; unsigned long long _received, _lastReceived, _length, _resumedFrom; OFDate *_startDate, *_lastReceivedDate; OFTimer *_drawTimer, *_BPSTimer; bool _stopped; float _BPS; @@ -33,11 +34,12 @@ float _BPSWindow[BPS_WINDOW_SIZE]; size_t _BPSWindowIndex, _BPSWindowLength; } - (instancetype)initWithLength: (unsigned long long)length - resumedFrom: (unsigned long long)resumedFrom; + resumedFrom: (unsigned long long)resumedFrom + useUnicode: (bool)useUnicode OF_DESIGNATED_INITIALIZER; - (void)setReceived: (unsigned long long)received; - (void)draw; - (void)calculateBPSAndETA; - (void)stop; @end Index: utils/ofhttp/ProgressBar.m ================================================================== --- utils/ofhttp/ProgressBar.m +++ utils/ofhttp/ProgressBar.m @@ -33,16 +33,18 @@ #define UPDATE_INTERVAL 0.1 @implementation ProgressBar - (instancetype)initWithLength: (unsigned long long)length resumedFrom: (unsigned long long)resumedFrom + useUnicode: (bool)useUnicode { self = [super init]; @try { void *pool = objc_autoreleasePoolPush(); + _useUnicode = useUnicode; _length = length; _resumedFrom = resumedFrom; _startDate = [[OFDate alloc] init]; _lastReceivedDate = [[OFDate alloc] init]; _drawTimer = [[OFTimer @@ -99,39 +101,63 @@ bars = (float)(_resumedFrom + _received) / (float)(_resumedFrom + _length) * barWidth; percent = (float)(_resumedFrom + _received) / (float)(_resumedFrom + _length) * 100; - [of_stdout writeString: @"\r ▕"]; - - for (size_t i = 0; i < (size_t)bars; i++) - [of_stdout writeString: @"█"]; - if (bars < barWidth) { - float rem = bars - truncf(bars); - - if (rem >= 0.875) - [of_stdout writeString: @"▉"]; - else if (rem >= 0.75) - [of_stdout writeString: @"▊"]; - else if (rem >= 0.625) - [of_stdout writeString: @"▋"]; - else if (rem >= 0.5) - [of_stdout writeString: @"▌"]; - else if (rem >= 0.375) - [of_stdout writeString: @"▍"]; - else if (rem >= 0.25) - [of_stdout writeString: @"▎"]; - else if (rem >= 0.125) - [of_stdout writeString: @"▏"]; - else - [of_stdout writeString: @" "]; - - for (size_t i = 0; i < barWidth - (size_t)bars - 1; i++) - [of_stdout writeString: @" "]; - } - - [of_stdout writeFormat: @"▏ %,6.2f%% ", percent]; + if (_useUnicode) { + [of_stdout writeString: @"\r ▕"]; + + for (size_t i = 0; i < (size_t)bars; i++) + [of_stdout writeString: @"█"]; + if (bars < barWidth) { + float rem = bars - truncf(bars); + + if (rem >= 0.875) + [of_stdout writeString: @"▉"]; + else if (rem >= 0.75) + [of_stdout writeString: @"▊"]; + else if (rem >= 0.625) + [of_stdout writeString: @"▋"]; + else if (rem >= 0.5) + [of_stdout writeString: @"▌"]; + else if (rem >= 0.375) + [of_stdout writeString: @"▍"]; + else if (rem >= 0.25) + [of_stdout writeString: @"▎"]; + else if (rem >= 0.125) + [of_stdout writeString: @"▏"]; + else + [of_stdout writeString: @" "]; + + for (size_t i = 0; i < barWidth - (size_t)bars - 1; i++) + [of_stdout writeString: @" "]; + } + + [of_stdout writeFormat: @"▏ %,6.2f%% ", percent]; + } else { + [of_stdout writeString: @"\r ["]; + + for (size_t i = 0; i < (size_t)bars; i++) + [of_stdout writeString: @"#"]; + if (bars < barWidth) { + float rem = bars - truncf(bars); + + if (rem >= 0.75) + [of_stdout writeString: @"O"]; + else if (rem >= 0.5) + [of_stdout writeString: @"o"]; + else if (rem >= 0.25) + [of_stdout writeString: @"."]; + else + [of_stdout writeString: @" "]; + + for (size_t i = 0; i < barWidth - (size_t)bars - 1; i++) + [of_stdout writeString: @" "]; + } + + [of_stdout writeFormat: @"] %,6.2f%% ", percent]; + } if (percent == 100) { double timeInterval = -_startDate.timeIntervalSinceNow; _BPS = (float)_received / (float)timeInterval;