rlwrap-0.42/ 0000755 0001751 0000144 00000000000 12431413017 007740 5 0000000 0000000 rlwrap-0.42/PLEA 0000644 0001751 0000144 00000002562 12404151311 010325 0000000 0000000 By now, rlwrap is a rather widely used utility; it can be found in
most free software distros (Most of the Linux flavours, FreeBSD,
cygwin, Fink)
I do my best to make rlwrap as portable as possible, and it should
*almost* compile out of the box on any reasonably modern Unix-like
system.
However, on any untested system there will be at least *one* little
quirk. Many of those are real bugs in rlwrap, which somehow don't show
up on other systems - a header file may simply live in an unusual
place, but there can also be some race condition that only shows up on
your particular system, or pseudo terminals behave a little
differently on your box.
I don't have the time and motivation to do all the testing myself,
life is too short (and enjoyable) for that.
So, what tends to happen is that package maintainers notice a quirk,
or ugly bug, repair it, put the patch in their package and happily
announce a shiny new rlwrap version.
They forget that other people might profit from their contribution,
that it possibly repairs a bug on many more systems, and that even on
their own platform people actually compile software from source
(gasp!!) instead of using a package from a distribution.
So, please:
Report any problems, and your fixes/patches to me
(hlub@knoware.nl). It will eventually make rlwrap a better piece of
software for everybody, not just for your own community.
Hans. rlwrap-0.42/tools/ 0000755 0001751 0000144 00000000000 12431413017 011100 5 0000000 0000000 rlwrap-0.42/tools/config.sub 0000755 0001751 0000144 00000105770 12404151432 013015 0000000 0000000 #! /bin/sh
# Configuration validation subroutine script.
# Copyright 1992-2014 Free Software Foundation, Inc.
timestamp='2014-01-01'
# 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.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see .
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that
# program. This Exception is an additional permission under section 7
# of the GNU General Public License, version 3 ("GPLv3").
# Please send patches with a ChangeLog entry to config-patches@gnu.org.
#
# Configuration subroutine to validate and canonicalize a configuration type.
# Supply the specified configuration type as an argument.
# If it is invalid, we print an error message on stderr and exit with code 1.
# Otherwise, we print the canonical config type on stdout and succeed.
# You can get the latest version of this script from:
# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
# This file is supposed to be the same for all GNU packages
# and recognize all the CPU types, system types and aliases
# that are meaningful with *any* GNU software.
# Each package is responsible for reporting which valid configurations
# it does not support. The user should be able to distinguish
# a failure to support a valid configuration from a meaningless
# configuration.
# The goal of this file is to map all the various variations of a given
# machine specification into a single specification in the form:
# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
# or in some cases, the newer four-part form:
# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
# It is wrong to echo any other type of specification.
me=`echo "$0" | sed -e 's,.*/,,'`
usage="\
Usage: $0 [OPTION] CPU-MFR-OPSYS
$0 [OPTION] ALIAS
Canonicalize a configuration name.
Operation modes:
-h, --help print this help, then exit
-t, --time-stamp print date of last modification, then exit
-v, --version print version number, then exit
Report bugs and patches to ."
version="\
GNU config.sub ($timestamp)
Copyright 1992-2014 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="
Try \`$me --help' for more information."
# Parse command line
while test $# -gt 0 ; do
case $1 in
--time-stamp | --time* | -t )
echo "$timestamp" ; exit ;;
--version | -v )
echo "$version" ; exit ;;
--help | --h* | -h )
echo "$usage"; exit ;;
-- ) # Stop option processing
shift; break ;;
- ) # Use stdin as input.
break ;;
-* )
echo "$me: invalid option $1$help"
exit 1 ;;
*local*)
# First pass through any local machine types.
echo $1
exit ;;
* )
break ;;
esac
done
case $# in
0) echo "$me: missing argument$help" >&2
exit 1;;
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* | \
kopensolaris*-gnu* | \
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/'`
;;
-windowsnt*)
os=`echo $os | sed -e 's/windowsnt/winnt/'`
;;
-psos*)
os=-psos
;;
-mint | -mint[0-9]*)
basic_machine=m68k-atari
os=-mint
;;
esac
# Decode aliases for certain CPU-COMPANY combinations.
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 \
| 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 \
| be32 | be64 \
| bfin \
| c4x | c8051 | clipper \
| d10v | d30v | dlx | dsp16xx | dvp \
| epiphany \
| fido | fr30 | frv \
| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
| hexagon \
| i370 | i860 | i960 | 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 \
| mipsisa64 | mipsisa64el \
| mipsisa64r2 | mipsisa64r2el \
| mipsisa64sb1 | mipsisa64sb1el \
| mipsisa64sr71k | mipsisa64sr71kel \
| mipsr5900 | mipsr5900el \
| mipstx39 | mipstx39el \
| mn10200 | mn10300 \
| moxie \
| mt \
| msp430 \
| nds32 | nds32le | nds32be \
| nios | nios2 | nios2eb | nios2el \
| ns16k | ns32k \
| open8 \
| or1k | or32 \
| pdp10 | pdp11 | pj | pjl \
| powerpc | powerpc64 | powerpc64le | powerpcle \
| pyramid \
| rl78 | rx \
| score \
| 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 \
| spu \
| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
| ubicom32 \
| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
| we32k \
| 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
;;
m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
basic_machine=$basic_machine-unknown
os=-none
;;
m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k)
;;
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
;;
# We use `pc' rather than `unknown'
# because (1) that's what they normally are, and
# (2) the word "unknown" tends to confuse beginning users.
i*86 | x86_64)
basic_machine=$basic_machine-pc
;;
# Object if more than one company name word.
*-*-*)
echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
exit 1
;;
# Recognize the basic CPU types with company name.
580-* \
| a29k-* \
| aarch64-* | aarch64_be-* \
| 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-* \
| be32-* | be64-* \
| bfin-* | bs2000-* \
| c[123]* | c30-* | [cjt]90-* | c4x-* \
| c8051-* | clipper-* | craynv-* | cydra-* \
| d10v-* | d30v-* | dlx-* \
| elxsi-* \
| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
| h8300-* | h8500-* \
| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
| hexagon-* \
| i*86-* | i860-* | i960-* | 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-* \
| mipsisa64-* | mipsisa64el-* \
| mipsisa64r2-* | mipsisa64r2el-* \
| mipsisa64sb1-* | mipsisa64sb1el-* \
| mipsisa64sr71k-* | mipsisa64sr71kel-* \
| mipsr5900-* | mipsr5900el-* \
| mipstx39-* | mipstx39el-* \
| mmix-* \
| mt-* \
| msp430-* \
| nds32-* | nds32le-* | nds32be-* \
| nios-* | nios2-* | nios2eb-* | nios2el-* \
| none-* | np1-* | ns16k-* | ns32k-* \
| open8-* \
| orion-* \
| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
| pyramid-* \
| 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-* \
| 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-unknown
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
;;
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
;;
aux)
basic_machine=m68k-apple
os=-aux
;;
balance)
basic_machine=ns32k-sequent
os=-dynix
;;
blackfin)
basic_machine=bfin-unknown
os=-linux
;;
blackfin-*)
basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
os=-linux
;;
bluegene*)
basic_machine=powerpc-ibm
os=-cnk
;;
c54x-*)
basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
c55x-*)
basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
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* | dpx2*-bull)
basic_machine=m68k-bull
os=-sysv3
;;
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
;;
hppa-next)
os=-nextstep3
;;
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
;;
i386-vsta | 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
;;
m68knommu)
basic_machine=m68k-unknown
os=-linux
;;
m68knommu-*)
basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
os=-linux
;;
m88k-omron*)
basic_machine=m88k-omron
;;
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
;;
mipsEE* | ee | ps2)
basic_machine=mips64r5900el-scei
case $os in
-linux*)
;;
*)
os=-elf
;;
esac
;;
iop)
basic_machine=mipsel-scei
os=-irx
;;
dvp)
basic_machine=dvp-scei
os=-elf
;;
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
;;
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
;;
neo-tandem)
basic_machine=neo-tandem
;;
nse-tandem)
basic_machine=nse-tandem
;;
nsr-tandem)
basic_machine=nsr-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 | ppc-le | powerpc-little)
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 | ppc64-le | powerpc64-little)
basic_machine=powerpc64le-unknown
;;
ppc64le-* | powerpc64little-*)
basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'`
;;
ps2)
basic_machine=i386-ibm
;;
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
;;
sh)
basic_machine=sh-hitachi
os=-hms
;;
sh5el)
basic_machine=sh5le-unknown
;;
sh64)
basic_machine=sh64-unknown
;;
sparclite-wrs | 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
;;
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
;;
z8k-*-coff)
basic_machine=z8k-unknown
os=-sim
;;
z80-*-coff)
basic_machine=z80-unknown
os=-sim
;;
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
;;
pdp10)
# there are many clones, so DEC is not a safe bet
basic_machine=pdp10-unknown
;;
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
;;
sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
basic_machine=sparc-sun
;;
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.
;;
*)
echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
exit 1
;;
esac
# Here we canonicalize certain aliases for manufacturers.
case $basic_machine in
*-digital*)
basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
;;
*-commodore*)
basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
;;
*)
;;
esac
# Decode manufacturer-specific aliases for certain operating systems.
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
;;
-solaris1 | -solaris1.*)
os=`echo $os | sed -e 's|solaris1|sunos4|'`
;;
-solaris)
os=-solaris2
;;
-svr4*)
os=-sysv4
;;
-unixware*)
os=-sysv4.2uw
;;
-gnu/linux*)
os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'`
;;
# First 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* \
| -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
| -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
| -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
| -bitrig* | -openbsd* | -solidbsd* \
| -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
| -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
| -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
| -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
| -chorusos* | -chorusrdb* | -cegcc* \
| -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
| -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
| -linux-newlib* | -linux-musl* | -linux-uclibc* \
| -uxpv* | -beos* | -mpeix* | -udk* \
| -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
| -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
| -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* | -irx* \
| -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
| -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
| -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
| -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*)
# Remember, each alternative MUST END IN *, to match a version number.
;;
-qnx*)
case $basic_machine in
x86-* | i*86-*)
;;
*)
os=-nto$os
;;
esac
;;
-nto-qnx*)
;;
-nto*)
os=`echo $os | sed -e 's|nto|nto-qnx|'`
;;
-sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \
| -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \
| -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*)
;;
-mac*)
os=`echo $os | sed -e 's|mac|macos|'`
;;
-linux-dietlibc)
os=-linux-dietlibc
;;
-linux*)
os=`echo $os | sed -e 's|linux|linux-gnu|'`
;;
-sunos5*)
os=`echo $os | sed -e 's|sunos5|solaris2|'`
;;
-sunos6*)
os=`echo $os | sed -e 's|sunos6|solaris3|'`
;;
-opened*)
os=-openedition
;;
-os400*)
os=-os400
;;
-wince*)
os=-wince
;;
-osfrose*)
os=-osfrose
;;
-osf*)
os=-osf
;;
-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.*)
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
;;
-es1800*)
os=-ose
;;
-xenix)
os=-xenix
;;
-*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*)
os=-mint
;;
-aros*)
os=-aros
;;
-zvmoe)
os=-zvmoe
;;
-dicos*)
os=-dicos
;;
-nacl*)
;;
-none)
;;
*)
# 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
# Here we handle the default operating systems that come with various machines.
# The value should be what the vendor currently ships out the door with their
# machine or put another way, the most popular os provided with the machine.
# Note that if you're going to try to match "-MANUFACTURER" here (say,
# "-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
score-*)
os=-elf
;;
spu-*)
os=-elf
;;
*-acorn)
os=-riscix1.2
;;
arm*-rebel)
os=-linux
;;
arm*-semi)
os=-aout
;;
c4x-* | tic4x-*)
os=-coff
;;
c8051-*)
os=-elf
;;
hexagon-*)
os=-elf
;;
tic54x-*)
os=-coff
;;
tic55x-*)
os=-coff
;;
tic6x-*)
os=-coff
;;
# This must come before the *-dec entry.
pdp10-*)
os=-tops20
;;
pdp11-*)
os=-none
;;
*-dec | vax-*)
os=-ultrix4.2
;;
m68*-apollo)
os=-domain
;;
i386-sun)
os=-sunos4.0.2
;;
m68000-sun)
os=-sunos3
;;
m68*-cisco)
os=-aout
;;
mep-*)
os=-elf
;;
mips*-cisco)
os=-elf
;;
mips*-*)
os=-elf
;;
or1k-*)
os=-elf
;;
or32-*)
os=-coff
;;
*-tti) # must be before sparc entry or we get the wrong os.
os=-sysv3
;;
sparc-* | *-sun)
os=-sunos4.1.1
;;
*-be)
os=-beos
;;
*-haiku)
os=-haiku
;;
*-ibm)
os=-aix
;;
*-knuth)
os=-mmixware
;;
*-wec)
os=-proelf
;;
*-winbond)
os=-proelf
;;
*-oki)
os=-proelf
;;
*-hp)
os=-hpux
;;
*-hitachi)
os=-hiux
;;
i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
os=-sysv
;;
*-cbm)
os=-amigaos
;;
*-dg)
os=-dgux
;;
*-dolphin)
os=-sysv3
;;
m68k-ccur)
os=-rtu
;;
m88k-omron*)
os=-luna
;;
*-next )
os=-nextstep
;;
*-sequent)
os=-ptx
;;
*-crds)
os=-unos
;;
*-ns)
os=-genix
;;
i370-*)
os=-mvs
;;
*-next)
os=-nextstep3
;;
*-gould)
os=-sysv
;;
*-highlevel)
os=-bsd
;;
*-encore)
os=-bsd
;;
*-sgi)
os=-irix
;;
*-siemens)
os=-sysv4
;;
*-masscomp)
os=-rtu
;;
f30[01]-fujitsu | f700-fujitsu)
os=-uxpv
;;
*-rom68k)
os=-coff
;;
*-*bug)
os=-coff
;;
*-apple)
os=-macos
;;
*-atari*)
os=-mint
;;
*)
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 $os in
-riscix*)
vendor=acorn
;;
-sunos*)
vendor=sun
;;
-cnk*|-aix*)
vendor=ibm
;;
-beos*)
vendor=be
;;
-hpux*)
vendor=hp
;;
-mpeix*)
vendor=hp
;;
-hiux*)
vendor=hitachi
;;
-unos*)
vendor=crds
;;
-dgux*)
vendor=dg
;;
-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*)
vendor=stratus
;;
esac
basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
;;
esac
echo $basic_machine$os
exit
# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "timestamp='"
# time-stamp-format: "%:y-%02m-%02d"
# time-stamp-end: "'"
# End:
rlwrap-0.42/tools/test-driver 0000755 0001751 0000144 00000010277 12404151432 013225 0000000 0000000 #! /bin/sh
# test-driver - basic testsuite driver script.
scriptversion=2013-07-13.22; # UTC
# Copyright (C) 2011-2013 Free Software Foundation, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# This file is maintained in Automake, please report
# bugs to or send patches to
# .
# Make unconditional expansion of undefined variables an error. This
# helps a lot in preventing typo-related bugs.
set -u
usage_error ()
{
echo "$0: $*" >&2
print_usage >&2
exit 2
}
print_usage ()
{
cat <$log_file 2>&1
estatus=$?
if test $enable_hard_errors = no && test $estatus -eq 99; then
estatus=1
fi
case $estatus:$expect_failure in
0:yes) col=$red res=XPASS recheck=yes gcopy=yes;;
0:*) col=$grn res=PASS recheck=no gcopy=no;;
77:*) col=$blu res=SKIP recheck=no gcopy=yes;;
99:*) col=$mgn res=ERROR recheck=yes gcopy=yes;;
*:yes) col=$lgn res=XFAIL recheck=no gcopy=yes;;
*:*) col=$red res=FAIL recheck=yes gcopy=yes;;
esac
# Report outcome to console.
echo "${col}${res}${std}: $test_name"
# Register the test result, and other relevant metadata.
echo ":test-result: $res" > $trs_file
echo ":global-test-result: $res" >> $trs_file
echo ":recheck: $recheck" >> $trs_file
echo ":copy-in-global-log: $gcopy" >> $trs_file
# Local Variables:
# mode: shell-script
# sh-indentation: 2
# 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:
rlwrap-0.42/tools/install-sh 0000755 0001751 0000144 00000033255 12404151432 013034 0000000 0000000 #!/bin/sh
# install - install a program, script, or datafile
scriptversion=2011-11-20.07; # 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.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# '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.
nl='
'
IFS=" "" $nl"
# set DOITPROG to echo to test this script
# Don't use :- since 4.3BSD and earlier shells don't like it.
doit=${DOITPROG-}
if test -z "$doit"; then
doit_exec=exec
else
doit_exec=$doit
fi
# 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_glob='?'
initialize_posix_glob='
test "$posix_glob" != "?" || {
if (set -f) 2>/dev/null; then
posix_glob=
else
posix_glob=:
fi
}
'
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
no_target_directory=
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
*' '* | *' '* | *'
'* | *'*'* | *'?'* | *'['*)
echo "$0: invalid mode: $mode" >&2
exit 1;;
esac
shift;;
-o) chowncmd="$chownprog $2"
shift;;
-s) stripcmd=$stripprog;;
-t) dst_arg=$2
# Protect names problematic for 'test' and other utilities.
case $dst_arg in
-* | [=\(\)!]) dst_arg=./$dst_arg;;
esac
shift;;
-T) no_target_directory=true;;
--version) echo "$0 $scriptversion"; exit $?;;
--) shift
break;;
-*) echo "$0: invalid option: $1" >&2
exit 1;;
*) break;;
esac
shift
done
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
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 -n "$no_target_directory"; then
echo "$0: $dst_arg: Is a directory" >&2
exit 1
fi
dstdir=$dst
dst=$dstdir/`basename "$src"`
dstdir_status=0
else
# Prefer dirname, but fall back on a substitute if dirname fails.
dstdir=`
(dirname "$dst") 2>/dev/null ||
expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
X"$dst" : 'X\(//\)[^/]' \| \
X"$dst" : 'X\(//\)$' \| \
X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
echo X"$dst" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
}
/^X\(\/\/\)[^/].*/{
s//\1/
q
}
/^X\(\/\/\)$/{
s//\1/
q
}
/^X\(\/\).*/{
s//\1/
q
}
s/.*/./; q'
`
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
eval "$initialize_posix_glob"
oIFS=$IFS
IFS=/
$posix_glob set -f
set fnord $dstdir
shift
$posix_glob 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` &&
eval "$initialize_posix_glob" &&
$posix_glob set -f &&
set X $old && old=:$2:$4:$5:$6 &&
set X $new && new=:$2:$4:$5:$6 &&
$posix_glob 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:
rlwrap-0.42/tools/missing 0000755 0001751 0000144 00000015330 12404151432 012421 0000000 0000000 #! /bin/sh
# Common wrapper for a few potentially missing GNU programs.
scriptversion=2013-10-28.13; # UTC
# Copyright (C) 1996-2013 Free Software Foundation, Inc.
# Originally written by Fran,cois Pinard , 1996.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
if test $# -eq 0; then
echo 1>&2 "Try '$0 --help' for more information"
exit 1
fi
case $1 in
--is-lightweight)
# Used by our autoconf macros to check whether the available missing
# script is modern enough.
exit 0
;;
--run)
# Back-compat with the calling convention used by older automake.
shift
;;
-h|--h|--he|--hel|--help)
echo "\
$0 [OPTION]... PROGRAM [ARGUMENT]...
Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due
to PROGRAM being missing or too old.
Options:
-h, --help display this help and exit
-v, --version output version information and exit
Supported PROGRAM values:
aclocal autoconf autoheader autom4te automake makeinfo
bison yacc flex lex help2man
Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
'g' are ignored when checking the name.
Send bug reports to ."
exit $?
;;
-v|--v|--ve|--ver|--vers|--versi|--versio|--version)
echo "missing $scriptversion (GNU Automake)"
exit $?
;;
-*)
echo 1>&2 "$0: unknown '$1' option"
echo 1>&2 "Try '$0 --help' for more information"
exit 1
;;
esac
# Run the given program, remember its exit status.
"$@"; st=$?
# If it succeeded, we are done.
test $st -eq 0 && exit 0
# Also exit now if we it failed (or wasn't found), and '--version' was
# passed; such an option is passed most likely to detect whether the
# program is present and works.
case $2 in --version|--help) exit $st;; esac
# Exit code 63 means version mismatch. This often happens when the user
# tries to use an ancient version of a tool on a file that requires a
# minimum version.
if test $st -eq 63; then
msg="probably too old"
elif test $st -eq 127; then
# Program was missing.
msg="missing on your system"
else
# Program was found and executed, but failed. Give up.
exit $st
fi
perl_URL=http://www.perl.org/
flex_URL=http://flex.sourceforge.net/
gnu_software_URL=http://www.gnu.org/software
program_details ()
{
case $1 in
aclocal|automake)
echo "The '$1' program is part of the GNU Automake package:"
echo "<$gnu_software_URL/automake>"
echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
echo "<$gnu_software_URL/autoconf>"
echo "<$gnu_software_URL/m4/>"
echo "<$perl_URL>"
;;
autoconf|autom4te|autoheader)
echo "The '$1' program is part of the GNU Autoconf package:"
echo "<$gnu_software_URL/autoconf/>"
echo "It also requires GNU m4 and Perl in order to run:"
echo "<$gnu_software_URL/m4/>"
echo "<$perl_URL>"
;;
esac
}
give_advice ()
{
# Normalize program name to check for.
normalized_program=`echo "$1" | sed '
s/^gnu-//; t
s/^gnu//; t
s/^g//; t'`
printf '%s\n' "'$1' is $msg."
configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
case $normalized_program in
autoconf*)
echo "You should only need it if you modified 'configure.ac',"
echo "or m4 files included by it."
program_details 'autoconf'
;;
autoheader*)
echo "You should only need it if you modified 'acconfig.h' or"
echo "$configure_deps."
program_details 'autoheader'
;;
automake*)
echo "You should only need it if you modified 'Makefile.am' or"
echo "$configure_deps."
program_details 'automake'
;;
aclocal*)
echo "You should only need it if you modified 'acinclude.m4' or"
echo "$configure_deps."
program_details 'aclocal'
;;
autom4te*)
echo "You might have modified some maintainer files that require"
echo "the 'autom4te' program to be rebuilt."
program_details 'autom4te'
;;
bison*|yacc*)
echo "You should only need it if you modified a '.y' file."
echo "You may want to install the GNU Bison package:"
echo "<$gnu_software_URL/bison/>"
;;
lex*|flex*)
echo "You should only need it if you modified a '.l' file."
echo "You may want to install the Fast Lexical Analyzer package:"
echo "<$flex_URL>"
;;
help2man*)
echo "You should only need it if you modified a dependency" \
"of a man page."
echo "You may want to install the GNU Help2man package:"
echo "<$gnu_software_URL/help2man/>"
;;
makeinfo*)
echo "You should only need it if you modified a '.texi' file, or"
echo "any other file indirectly affecting the aspect of the manual."
echo "You might want to install the Texinfo package:"
echo "<$gnu_software_URL/texinfo/>"
echo "The spurious makeinfo call might also be the consequence of"
echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
echo "want to install GNU make:"
echo "<$gnu_software_URL/make/>"
;;
*)
echo "You might have modified some files without having the proper"
echo "tools for further handling them. Check the 'README' file, it"
echo "often tells you about the needed prerequisites for installing"
echo "this package. You may also peek at any GNU archive site, in"
echo "case some other package contains this missing '$1' program."
;;
esac
}
give_advice "$1" | sed -e '1s/^/WARNING: /' \
-e '2,$s/^/ /' >&2
# Propagate the correct exit status (expected to be 127 for a program
# not found, 63 for a program that failed due to version mismatch).
exit $st
# 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:
rlwrap-0.42/tools/config.guess 0000755 0001751 0000144 00000124257 12404151432 013353 0000000 0000000 #! /bin/sh
# Attempt to guess a canonical system name.
# Copyright 1992-2014 Free Software Foundation, Inc.
timestamp='2014-02-12'
# 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.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see .
#
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that
# program. This Exception is an additional permission under section 7
# of the GNU General Public License, version 3 ("GPLv3").
#
# Originally written by Per Bothner.
#
# You can get the latest version of this script from:
# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
#
# Please send patches with a ChangeLog entry to config-patches@gnu.org.
me=`echo "$0" | sed -e 's,.*/,,'`
usage="\
Usage: $0 [OPTION]
Output the configuration name of the system \`$me' is run on.
Operation modes:
-h, --help print this help, then exit
-t, --time-stamp print date of last modification, then exit
-v, --version print version number, then exit
Report bugs and patches to ."
version="\
GNU config.guess ($timestamp)
Originally written by Per Bothner.
Copyright 1992-2014 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="
Try \`$me --help' for more information."
# Parse command line
while test $# -gt 0 ; do
case $1 in
--time-stamp | --time* | -t )
echo "$timestamp" ; exit ;;
--version | -v )
echo "$version" ; exit ;;
--help | --h* | -h )
echo "$usage"; exit ;;
-- ) # Stop option processing
shift; break ;;
- ) # Use stdin as input.
break ;;
-* )
echo "$me: invalid option $1$help" >&2
exit 1 ;;
* )
break ;;
esac
done
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.
# 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= ;'
# 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
PATH=$PATH:/.attbin ; export PATH
fi
UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
case "${UNAME_SYSTEM}" in
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
cat <<-EOF > $dummy.c
#include
#if defined(__UCLIBC__)
LIBC=uclibc
#elif defined(__dietlibc__)
LIBC=dietlibc
#else
LIBC=gnu
#endif
EOF
eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`
;;
esac
# Note: order is significant - the case branches are not exclusive.
case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
*:NetBSD:*:*)
# NetBSD (nbsd) targets should (where applicable) match one or
# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
# *-*-netbsdecoff* and *-*-netbsd*. For targets that recently
# switched to ELF, *-*-netbsd* would select the old
# object file format. This provides both forward
# compatibility and a consistent mechanism for selecting the
# object file format.
#
# Note: NetBSD doesn't particularly care about the vendor
# portion of the name. We always set it to "unknown".
sysctl="sysctl -n hw.machine_arch"
UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
/usr/sbin/$sysctl 2>/dev/null || echo unknown)`
case "${UNAME_MACHINE_ARCH}" in
armeb) machine=armeb-unknown ;;
arm*) machine=arm-unknown ;;
sh3el) machine=shl-unknown ;;
sh3eb) machine=sh-unknown ;;
sh5el) machine=sh5le-unknown ;;
*) machine=${UNAME_MACHINE_ARCH}-unknown ;;
esac
# The Operating System including object format, if it has switched
# to ELF recently, or will in the future.
case "${UNAME_MACHINE_ARCH}" in
arm*|i386|m68k|ns32k|sh3*|sparc|vax)
eval $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?
os=netbsd
else
os=netbsdelf
fi
;;
*)
os=netbsd
;;
esac
# The OS release
# Debian GNU/NetBSD machines have a different userland, and
# thus, need a distinct triplet. However, they do not need
# kernel version information, so it can be replaced with a
# suitable tag, in the style of linux-gnu.
case "${UNAME_VERSION}" in
Debian*)
release='-gnu'
;;
*)
release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
;;
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}"
exit ;;
*:Bitrig:*:*)
UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
exit ;;
*:OpenBSD:*:*)
UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
exit ;;
*:ekkoBSD:*:*)
echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
exit ;;
*:SolidBSD:*:*)
echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
exit ;;
macppc:MirBSD:*:*)
echo powerpc-unknown-mirbsd${UNAME_RELEASE}
exit ;;
*:MirBSD:*:*)
echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
exit ;;
alpha:OSF1:*:*)
case $UNAME_RELEASE in
*4.0)
UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
;;
*5.*)
UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
;;
esac
# According to Compaq, /usr/sbin/psrinfo has been available on
# OSF/1 and Tru64 systems produced since 1995. I hope that
# covers most systems running today. This code pipes the CPU
# types through head -n 1, so we only detect the type of CPU 0.
ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1`
case "$ALPHA_CPU_TYPE" in
"EV4 (21064)")
UNAME_MACHINE="alpha" ;;
"EV4.5 (21064)")
UNAME_MACHINE="alpha" ;;
"LCA4 (21066/21068)")
UNAME_MACHINE="alpha" ;;
"EV5 (21164)")
UNAME_MACHINE="alphaev5" ;;
"EV5.6 (21164A)")
UNAME_MACHINE="alphaev56" ;;
"EV5.6 (21164PC)")
UNAME_MACHINE="alphapca56" ;;
"EV5.7 (21164PC)")
UNAME_MACHINE="alphapca57" ;;
"EV6 (21264)")
UNAME_MACHINE="alphaev6" ;;
"EV6.7 (21264A)")
UNAME_MACHINE="alphaev67" ;;
"EV6.8CB (21264C)")
UNAME_MACHINE="alphaev68" ;;
"EV6.8AL (21264B)")
UNAME_MACHINE="alphaev68" ;;
"EV6.8CX (21264D)")
UNAME_MACHINE="alphaev68" ;;
"EV6.9A (21264/EV69A)")
UNAME_MACHINE="alphaev69" ;;
"EV7 (21364)")
UNAME_MACHINE="alphaev7" ;;
"EV7.9 (21364A)")
UNAME_MACHINE="alphaev79" ;;
esac
# A Pn.n version is a patched version.
# A Vn.n version is a released version.
# A Tn.n version is a released field test version.
# A Xn.n version is an unreleased experimental baselevel.
# 1.2 uses "1.2" for uname -r.
echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
exitcode=$?
trap '' 0
exit $exitcode ;;
Alpha\ *:Windows_NT*:*)
# How do we know it's Interix rather than the generic POSIX subsystem?
# Should we change UNAME_MACHINE based on the output of uname instead
# of the specific Alpha model?
echo alpha-pc-interix
exit ;;
21064:Windows_NT:50:3)
echo alpha-dec-winnt3.5
exit ;;
Amiga*:UNIX_System_V:4.0:*)
echo m68k-unknown-sysv4
exit ;;
*:[Aa]miga[Oo][Ss]:*:*)
echo ${UNAME_MACHINE}-unknown-amigaos
exit ;;
*:[Mm]orph[Oo][Ss]:*:*)
echo ${UNAME_MACHINE}-unknown-morphos
exit ;;
*:OS/390:*:*)
echo i370-ibm-openedition
exit ;;
*:z/VM:*:*)
echo s390-ibm-zvmoe
exit ;;
*:OS400:*:*)
echo powerpc-ibm-os400
exit ;;
arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*)
echo arm-acorn-riscix${UNAME_RELEASE}
exit ;;
arm*:riscos:*:*|arm*:RISCOS:*:*)
echo arm-unknown-riscos
exit ;;
SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
echo hppa1.1-hitachi-hiuxmpp
exit ;;
Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
if test "`(/bin/universe) 2>/dev/null`" = att ; then
echo pyramid-pyramid-sysv3
else
echo pyramid-pyramid-bsd
fi
exit ;;
NILE*:*:*:dcosx)
echo pyramid-pyramid-svr4
exit ;;
DRS?6000:unix:4.0:6*)
echo sparc-icl-nx6
exit ;;
DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
case `/usr/bin/uname -p` in
sparc) echo sparc-icl-nx7; exit ;;
esac ;;
s390x:SunOS:*:*)
echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
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/[^.]*//'`
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
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
if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
grep IS_64BIT_ARCH >/dev/null
then
SUN_ARCH="x86_64"
fi
fi
echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
exit ;;
sun4*:SunOS:6*:*)
# According to config.sub, this is the proper way to canonicalize
# SunOS6. Hard to guess exactly what SunOS6 will be like, but
# it's likely to be more like Solaris than SunOS4.
echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
exit ;;
sun4*:SunOS:*:*)
case "`/usr/bin/arch -k`" in
Series*|S4*)
UNAME_RELEASE=`uname -v`
;;
esac
# Japanese Language versions have a version number like `4.1.3-JL'.
echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
exit ;;
sun3*:SunOS:*:*)
echo m68k-sun-sunos${UNAME_RELEASE}
exit ;;
sun*:*:4.2BSD:*)
UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
case "`/bin/arch`" in
sun3)
echo m68k-sun-sunos${UNAME_RELEASE}
;;
sun4)
echo sparc-sun-sunos${UNAME_RELEASE}
;;
esac
exit ;;
aushp:SunOS:*:*)
echo sparc-auspex-sunos${UNAME_RELEASE}
exit ;;
# The situation for MiNT is a little confusing. The machine name
# can be virtually everything (everything which is not
# "atarist" or "atariste" at least should have a processor
# > m68000). The system name ranges from "MiNT" over "FreeMiNT"
# to the lowercase version "mint" (or "freemint"). Finally
# the system name "TOS" denotes a system which is actually not
# MiNT. But MiNT is downward compatible to TOS, so this should
# be no problem.
atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*)
echo m68k-atari-mint${UNAME_RELEASE}
exit ;;
atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*)
echo m68k-atari-mint${UNAME_RELEASE}
exit ;;
*falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
echo m68k-atari-mint${UNAME_RELEASE}
exit ;;
milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
echo m68k-milan-mint${UNAME_RELEASE}
exit ;;
hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
echo m68k-hades-mint${UNAME_RELEASE}
exit ;;
*:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
echo m68k-unknown-mint${UNAME_RELEASE}
exit ;;
m68k:machten:*:*)
echo m68k-apple-machten${UNAME_RELEASE}
exit ;;
powerpc:machten:*:*)
echo powerpc-apple-machten${UNAME_RELEASE}
exit ;;
RISC*:Mach:*:*)
echo mips-dec-mach_bsd4.3
exit ;;
RISC*:ULTRIX:*:*)
echo mips-dec-ultrix${UNAME_RELEASE}
exit ;;
VAX*:ULTRIX*:*:*)
echo vax-dec-ultrix${UNAME_RELEASE}
exit ;;
2020:CLIX:*:* | 2430:CLIX:*:*)
echo clipper-intergraph-clix${UNAME_RELEASE}
exit ;;
mips:*:*:UMIPS | mips:*:*:RISCos)
eval $set_cc_for_build
sed 's/^ //' << EOF >$dummy.c
#ifdef __cplusplus
#include /* for printf() prototype */
int main (int argc, char *argv[]) {
#else
int main (argc, argv) int argc; char *argv[]; {
#endif
#if defined (host_mips) && defined (MIPSEB)
#if defined (SYSTYPE_SYSV)
printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0);
#endif
#if defined (SYSTYPE_SVR4)
printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0);
#endif
#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0);
#endif
#endif
exit (-1);
}
EOF
$CC_FOR_BUILD -o $dummy $dummy.c &&
dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` &&
SYSTEM_NAME=`$dummy $dummyarg` &&
{ echo "$SYSTEM_NAME"; exit; }
echo mips-mips-riscos${UNAME_RELEASE}
exit ;;
Motorola:PowerMAX_OS:*:*)
echo powerpc-motorola-powermax
exit ;;
Motorola:*:4.3:PL8-*)
echo powerpc-harris-powermax
exit ;;
Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
echo powerpc-harris-powermax
exit ;;
Night_Hawk:Power_UNIX:*:*)
echo powerpc-harris-powerunix
exit ;;
m88k:CX/UX:7*:*)
echo m88k-harris-cxux7
exit ;;
m88k:*:4*:R4*)
echo m88k-motorola-sysv4
exit ;;
m88k:*:3*:R3*)
echo m88k-motorola-sysv3
exit ;;
AViiON:dgux:*:*)
# DG/UX returns AViiON for all architectures
UNAME_PROCESSOR=`/usr/bin/uname -p`
if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ]
then
if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \
[ ${TARGET_BINARY_INTERFACE}x = x ]
then
echo m88k-dg-dgux${UNAME_RELEASE}
else
echo m88k-dg-dguxbcs${UNAME_RELEASE}
fi
else
echo i586-dg-dgux${UNAME_RELEASE}
fi
exit ;;
M88*:DolphinOS:*:*) # DolphinOS (SVR3)
echo m88k-dolphin-sysv3
exit ;;
M88*:*:R3*:*)
# Delta 88k system running SVR3
echo m88k-motorola-sysv3
exit ;;
XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
echo m88k-tektronix-sysv3
exit ;;
Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
echo m68k-tektronix-bsd
exit ;;
*:IRIX*:*:*)
echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
exit ;;
????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id
exit ;; # Note that: echo "'`uname -s`'" gives 'AIX '
i*86:AIX:*:*)
echo i386-ibm-aix
exit ;;
ia64:AIX:*:*)
if [ -x /usr/bin/oslevel ] ; then
IBM_REV=`/usr/bin/oslevel`
else
IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
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
sed 's/^ //' << EOF >$dummy.c
#include
main()
{
if (!__power_pc())
exit(1);
puts("powerpc-ibm-aix3.2.5");
exit(0);
}
EOF
if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
then
echo "$SYSTEM_NAME"
else
echo rs6000-ibm-aix3.2.5
fi
elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
echo rs6000-ibm-aix3.2.4
else
echo rs6000-ibm-aix3.2
fi
exit ;;
*:AIX:*:[4567])
IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
IBM_ARCH=rs6000
else
IBM_ARCH=powerpc
fi
if [ -x /usr/bin/oslevel ] ; then
IBM_REV=`/usr/bin/oslevel`
else
IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
fi
echo ${IBM_ARCH}-ibm-aix${IBM_REV}
exit ;;
*:AIX:*:*)
echo rs6000-ibm-aix
exit ;;
ibmrt:4.4BSD:*|romp-ibm:BSD:*)
echo romp-ibm-bsd4.4
exit ;;
ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and
echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to
exit ;; # report: romp-ibm BSD 4.3
*:BOSX:*:*)
echo rs6000-bull-bosx
exit ;;
DPX/2?00:B.O.S.:*:*)
echo m68k-bull-sysv3
exit ;;
9000/[34]??:4.3bsd:1.*:*)
echo m68k-hp-bsd
exit ;;
hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*)
echo m68k-hp-bsd4.4
exit ;;
9000/[34678]??:HP-UX:*:*)
HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'`
case "${UNAME_MACHINE}" in
9000/31? ) HP_ARCH=m68000 ;;
9000/[34]?? ) HP_ARCH=m68k ;;
9000/[678][0-9][0-9])
if [ -x /usr/bin/getconf ]; then
sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
case "${sc_cpu_version}" in
523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
532) # CPU_PA_RISC2_0
case "${sc_kernel_bits}" in
32) HP_ARCH="hppa2.0n" ;;
64) HP_ARCH="hppa2.0w" ;;
'') HP_ARCH="hppa2.0" ;; # HP-UX 10.20
esac ;;
esac
fi
if [ "${HP_ARCH}" = "" ]; then
eval $set_cc_for_build
sed 's/^ //' << EOF >$dummy.c
#define _HPUX_SOURCE
#include
#include
int main ()
{
#if defined(_SC_KERNEL_BITS)
long bits = sysconf(_SC_KERNEL_BITS);
#endif
long cpu = sysconf (_SC_CPU_VERSION);
switch (cpu)
{
case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
case CPU_PA_RISC2_0:
#if defined(_SC_KERNEL_BITS)
switch (bits)
{
case 64: puts ("hppa2.0w"); break;
case 32: puts ("hppa2.0n"); break;
default: puts ("hppa2.0"); break;
} break;
#else /* !defined(_SC_KERNEL_BITS) */
puts ("hppa2.0"); break;
#endif
default: puts ("hppa1.0"); break;
}
exit (0);
}
EOF
(CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
test -z "$HP_ARCH" && HP_ARCH=hppa
fi ;;
esac
if [ ${HP_ARCH} = "hppa2.0w" ]
then
eval $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:
#
# $ CC_FOR_BUILD=cc ./config.guess
# => hppa2.0w-hp-hpux11.23
# $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
# => hppa64-hp-hpux11.23
if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
grep -q __LP64__
then
HP_ARCH="hppa2.0w"
else
HP_ARCH="hppa64"
fi
fi
echo ${HP_ARCH}-hp-hpux${HPUX_REV}
exit ;;
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
sed 's/^ //' << EOF >$dummy.c
#include
int
main ()
{
long cpu = sysconf (_SC_CPU_VERSION);
/* The order matters, because CPU_IS_HP_MC68K erroneously returns
true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct
results, however. */
if (CPU_IS_PA_RISC (cpu))
{
switch (cpu)
{
case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
default: puts ("hppa-hitachi-hiuxwe2"); break;
}
}
else if (CPU_IS_HP_MC68K (cpu))
puts ("m68k-hitachi-hiuxwe2");
else puts ("unknown-hitachi-hiuxwe2");
exit (0);
}
EOF
$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
{ echo "$SYSTEM_NAME"; exit; }
echo unknown-hitachi-hiuxwe2
exit ;;
9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* )
echo hppa1.1-hp-bsd
exit ;;
9000/8??:4.3bsd:*:*)
echo hppa1.0-hp-bsd
exit ;;
*9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
echo hppa1.0-hp-mpeix
exit ;;
hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* )
echo hppa1.1-hp-osf
exit ;;
hp8??:OSF1:*:*)
echo hppa1.0-hp-osf
exit ;;
i*86:OSF1:*:*)
if [ -x /usr/sbin/sysversion ] ; then
echo ${UNAME_MACHINE}-unknown-osf1mk
else
echo ${UNAME_MACHINE}-unknown-osf1
fi
exit ;;
parisc*:Lites*:*:*)
echo hppa1.1-hp-lites
exit ;;
C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
echo c1-convex-bsd
exit ;;
C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
if getsysinfo -f scalar_acc
then echo c32-convex-bsd
else echo c2-convex-bsd
fi
exit ;;
C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
echo c34-convex-bsd
exit ;;
C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
echo c38-convex-bsd
exit ;;
C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
echo c4-convex-bsd
exit ;;
CRAY*Y-MP:*:*:*)
echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
exit ;;
CRAY*[A-Z]90:*:*:*)
echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
| sed -e 's/CRAY.*\([A-Z]90\)/\1/' \
-e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
-e 's/\.[^.]*$/.X/'
exit ;;
CRAY*TS:*:*:*)
echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
exit ;;
CRAY*T3E:*:*:*)
echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
exit ;;
CRAY*SV1:*:*:*)
echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
exit ;;
*:UNICOS/mp:*:*)
echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/'
exit ;;
F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
exit ;;
5000:UNIX_System_V:4.*:*)
FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
exit ;;
i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
exit ;;
sparc*:BSD/OS:*:*)
echo sparc-unknown-bsdi${UNAME_RELEASE}
exit ;;
*:BSD/OS:*:*)
echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
exit ;;
*:FreeBSD:*:*)
UNAME_PROCESSOR=`/usr/bin/uname -p`
case ${UNAME_PROCESSOR} in
amd64)
echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
*)
echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;;
esac
exit ;;
i*:CYGWIN*:*)
echo ${UNAME_MACHINE}-pc-cygwin
exit ;;
*:MINGW64*:*)
echo ${UNAME_MACHINE}-pc-mingw64
exit ;;
*:MINGW*:*)
echo ${UNAME_MACHINE}-pc-mingw32
exit ;;
i*:MSYS*:*)
echo ${UNAME_MACHINE}-pc-msys
exit ;;
i*:windows32*:*)
# uname -m includes "-pc" on this system.
echo ${UNAME_MACHINE}-mingw32
exit ;;
i*:PW*:*)
echo ${UNAME_MACHINE}-pc-pw32
exit ;;
*:Interix*:*)
case ${UNAME_MACHINE} in
x86)
echo i586-pc-interix${UNAME_RELEASE}
exit ;;
authenticamd | genuineintel | EM64T)
echo x86_64-unknown-interix${UNAME_RELEASE}
exit ;;
IA64)
echo ia64-unknown-interix${UNAME_RELEASE}
exit ;;
esac ;;
[345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*)
echo i${UNAME_MACHINE}-pc-mks
exit ;;
8664:Windows_NT:*)
echo x86_64-pc-mks
exit ;;
i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
# How do we know it's Interix rather than the generic POSIX subsystem?
# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
# UNAME_MACHINE based on the output of uname instead of i386?
echo i586-pc-interix
exit ;;
i*:UWIN*:*)
echo ${UNAME_MACHINE}-pc-uwin
exit ;;
amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
echo x86_64-unknown-cygwin
exit ;;
p*:CYGWIN*:*)
echo powerpcle-unknown-cygwin
exit ;;
prep*:SunOS:5.*:*)
echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'`
exit ;;
*:GNU:*:*)
# the GNU system
echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
exit ;;
*:GNU/*:*:*)
# other systems with GNU libc and userland
echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-${LIBC}
exit ;;
i*86:Minix:*:*)
echo ${UNAME_MACHINE}-pc-minix
exit ;;
aarch64:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
aarch64_be:Linux:*:*)
UNAME_MACHINE=aarch64_be
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
alpha:Linux:*:*)
case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
EV5) UNAME_MACHINE=alphaev5 ;;
EV56) UNAME_MACHINE=alphaev56 ;;
PCA56) UNAME_MACHINE=alphapca56 ;;
PCA57) UNAME_MACHINE=alphapca56 ;;
EV6) UNAME_MACHINE=alphaev6 ;;
EV67) UNAME_MACHINE=alphaev67 ;;
EV68*) UNAME_MACHINE=alphaev68 ;;
esac
objdump --private-headers /bin/sh | grep -q ld.so.1
if test "$?" = 0 ; then LIBC="gnulibc1" ; fi
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
arc:Linux:*:* | arceb:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
arm*:Linux:*:*)
eval $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
if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
| grep -q __ARM_PCS_VFP
then
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
else
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
fi
fi
exit ;;
avr32*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
cris:Linux:*:*)
echo ${UNAME_MACHINE}-axis-linux-${LIBC}
exit ;;
crisv32:Linux:*:*)
echo ${UNAME_MACHINE}-axis-linux-${LIBC}
exit ;;
frv:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
hexagon:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
i*86:Linux:*:*)
echo ${UNAME_MACHINE}-pc-linux-${LIBC}
exit ;;
ia64:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
m32r*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
m68*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
mips:Linux:*:* | mips64:Linux:*:*)
eval $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)
CPU=${UNAME_MACHINE}el
#else
#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
CPU=${UNAME_MACHINE}
#else
CPU=
#endif
#endif
EOF
eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
;;
or1k:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
or32:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
padre:Linux:*:*)
echo sparc-unknown-linux-${LIBC}
exit ;;
parisc64:Linux:*:* | hppa64:Linux:*:*)
echo hppa64-unknown-linux-${LIBC}
exit ;;
parisc:Linux:*:* | hppa:Linux:*:*)
# Look for CPU level
case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
*) echo hppa-unknown-linux-${LIBC} ;;
esac
exit ;;
ppc64:Linux:*:*)
echo powerpc64-unknown-linux-${LIBC}
exit ;;
ppc:Linux:*:*)
echo powerpc-unknown-linux-${LIBC}
exit ;;
ppc64le:Linux:*:*)
echo powerpc64le-unknown-linux-${LIBC}
exit ;;
ppcle:Linux:*:*)
echo powerpcle-unknown-linux-${LIBC}
exit ;;
s390:Linux:*:* | s390x:Linux:*:*)
echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
exit ;;
sh64*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
sh*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
sparc:Linux:*:* | sparc64:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
tile*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
vax:Linux:*:*)
echo ${UNAME_MACHINE}-dec-linux-${LIBC}
exit ;;
x86_64:Linux:*:*)
eval $set_cc_for_build
X86_64_ABI=
# If there is a compiler, see if it is configured for 32-bit objects.
if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then
if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \
(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
grep IS_X32 >/dev/null
then
X86_64_ABI=x32
fi
fi
echo x86_64-unknown-linux-gnu${X86_64_ABI}
exit ;;
xtensa*:Linux:*:*)
echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
exit ;;
i*86:DYNIX/ptx:4*:*)
# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
# earlier versions are messed up and put the nodename in both
# sysname and nodename.
echo i386-sequent-sysv4
exit ;;
i*86:UNIX_SV:4.2MP:2.*)
# Unixware is an offshoot of SVR4, but it has its own version
# number series starting with 2...
# I am not positive that other SVR4 systems won't match this,
# I just have to hope. -- rms.
# Use sysv4.2uw... so that sysv4* matches it.
echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
exit ;;
i*86:OS/2:*:*)
# If we were able to find `uname', then EMX Unix compatibility
# is probably installed.
echo ${UNAME_MACHINE}-pc-os2-emx
exit ;;
i*86:XTS-300:*:STOP)
echo ${UNAME_MACHINE}-unknown-stop
exit ;;
i*86:atheos:*:*)
echo ${UNAME_MACHINE}-unknown-atheos
exit ;;
i*86:syllable:*:*)
echo ${UNAME_MACHINE}-pc-syllable
exit ;;
i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*)
echo i386-unknown-lynxos${UNAME_RELEASE}
exit ;;
i*86:*DOS:*:*)
echo ${UNAME_MACHINE}-pc-msdosdjgpp
exit ;;
i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
else
echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
fi
exit ;;
i*86:*:5:[678]*)
# UnixWare 7.x, OpenUNIX and OpenServer 6.
case `/bin/uname -X | grep "^Machine"` in
*486*) UNAME_MACHINE=i486 ;;
*Pentium) UNAME_MACHINE=i586 ;;
*Pent*|*Celeron) UNAME_MACHINE=i686 ;;
esac
echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
exit ;;
i*86:*:3.2:*)
if test -f /usr/options/cb.name; then
UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then
UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
&& UNAME_MACHINE=i586
(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
&& UNAME_MACHINE=i686
(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
&& UNAME_MACHINE=i686
echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
else
echo ${UNAME_MACHINE}-pc-sysv32
fi
exit ;;
pc:*:*:*)
# Left here for compatibility:
# uname -m prints for DJGPP always 'pc', but it prints nothing about
# the processor, so we play safe by assuming i586.
# Note: whatever this is, it MUST be the same as what config.sub
# prints for the "djgpp" host, or else GDB configury will decide that
# this is a cross-build.
echo i586-pc-msdosdjgpp
exit ;;
Intel:Mach:3*:*)
echo i386-pc-mach3
exit ;;
paragon:*:*:*)
echo i860-intel-osf1
exit ;;
i860:*:4.*:*) # i860-SVR4
if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
else # Add other i860-SVR4 vendors below as they are discovered.
echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4
fi
exit ;;
mini*:CTIX:SYS*5:*)
# "miniframe"
echo m68010-convergent-sysv
exit ;;
mc68k:UNIX:SYSTEM5:3.51m)
echo m68k-convergent-sysv
exit ;;
M680?0:D-NIX:5.3:*)
echo m68k-diab-dnix
exit ;;
M68*:*:R3V[5678]*:*)
test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
OS_REL=''
test -r /etc/.relid \
&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
&& { echo i486-ncr-sysv4.3${OS_REL}; exit; }
/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
&& { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*)
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
&& { echo i486-ncr-sysv4; exit; } ;;
NCR*:*:4.2:* | MPRAS*:*:4.2:*)
OS_REL='.3'
test -r /etc/.relid \
&& OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid`
/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
&& { echo i486-ncr-sysv4.3${OS_REL}; exit; }
/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
&& { echo i586-ncr-sysv4.3${OS_REL}; exit; }
/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
&& { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
echo m68k-unknown-lynxos${UNAME_RELEASE}
exit ;;
mc68030:UNIX_System_V:4.*:*)
echo m68k-atari-sysv4
exit ;;
TSUNAMI:LynxOS:2.*:*)
echo sparc-unknown-lynxos${UNAME_RELEASE}
exit ;;
rs6000:LynxOS:2.*:*)
echo rs6000-unknown-lynxos${UNAME_RELEASE}
exit ;;
PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*)
echo powerpc-unknown-lynxos${UNAME_RELEASE}
exit ;;
SM[BE]S:UNIX_SV:*:*)
echo mips-dde-sysv${UNAME_RELEASE}
exit ;;
RM*:ReliantUNIX-*:*:*)
echo mips-sni-sysv4
exit ;;
RM*:SINIX-*:*:*)
echo mips-sni-sysv4
exit ;;
*:SINIX-*:*:*)
if uname -p 2>/dev/null >/dev/null ; then
UNAME_MACHINE=`(uname -p) 2>/dev/null`
echo ${UNAME_MACHINE}-sni-sysv4
else
echo ns32k-sni-sysv
fi
exit ;;
PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
# says
echo i586-unisys-sysv4
exit ;;
*:UNIX_System_V:4*:FTX*)
# From Gerald Hewes .
# How about differentiating between stratus architectures? -djm
echo hppa1.1-stratus-sysv4
exit ;;
*:*:*:FTX*)
# From seanf@swdc.stratus.com.
echo i860-stratus-sysv4
exit ;;
i*86:VOS:*:*)
# From Paul.Green@stratus.com.
echo ${UNAME_MACHINE}-stratus-vos
exit ;;
*:VOS:*:*)
# From Paul.Green@stratus.com.
echo hppa1.1-stratus-vos
exit ;;
mc68*:A/UX:*:*)
echo m68k-apple-aux${UNAME_RELEASE}
exit ;;
news*:NEWS-OS:6*:*)
echo mips-sony-newsos6
exit ;;
R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
if [ -d /usr/nec ]; then
echo mips-nec-sysv${UNAME_RELEASE}
else
echo mips-unknown-sysv${UNAME_RELEASE}
fi
exit ;;
BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only.
echo powerpc-be-beos
exit ;;
BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only.
echo powerpc-apple-beos
exit ;;
BePC:BeOS:*:*) # BeOS running on Intel PC compatible.
echo i586-pc-beos
exit ;;
BePC:Haiku:*:*) # Haiku running on Intel PC compatible.
echo i586-pc-haiku
exit ;;
x86_64:Haiku:*:*)
echo x86_64-unknown-haiku
exit ;;
SX-4:SUPER-UX:*:*)
echo sx4-nec-superux${UNAME_RELEASE}
exit ;;
SX-5:SUPER-UX:*:*)
echo sx5-nec-superux${UNAME_RELEASE}
exit ;;
SX-6:SUPER-UX:*:*)
echo sx6-nec-superux${UNAME_RELEASE}
exit ;;
SX-7:SUPER-UX:*:*)
echo sx7-nec-superux${UNAME_RELEASE}
exit ;;
SX-8:SUPER-UX:*:*)
echo sx8-nec-superux${UNAME_RELEASE}
exit ;;
SX-8R:SUPER-UX:*:*)
echo sx8r-nec-superux${UNAME_RELEASE}
exit ;;
Power*:Rhapsody:*:*)
echo powerpc-apple-rhapsody${UNAME_RELEASE}
exit ;;
*:Rhapsody:*:*)
echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
exit ;;
*:Darwin:*:*)
UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
eval $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
if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
grep IS_64BIT_ARCH >/dev/null
then
case $UNAME_PROCESSOR in
i386) UNAME_PROCESSOR=x86_64 ;;
powerpc) UNAME_PROCESSOR=powerpc64 ;;
esac
fi
fi
elif test "$UNAME_PROCESSOR" = i386 ; then
# Avoid executing cc on OS X 10.9, as it ships with a stub
# that puts up a graphical alert prompting to install
# developer tools. Any system running Mac OS X 10.7 or
# later (Darwin 11 and later) is required to have a 64-bit
# processor. This is not true of the ARM version of Darwin
# that Apple uses in portable devices.
UNAME_PROCESSOR=x86_64
fi
echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
exit ;;
*:procnto*:*:* | *:QNX:[0123456789]*:*)
UNAME_PROCESSOR=`uname -p`
if test "$UNAME_PROCESSOR" = "x86"; then
UNAME_PROCESSOR=i386
UNAME_MACHINE=pc
fi
echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
exit ;;
*:QNX:*:4*)
echo i386-pc-qnx
exit ;;
NEO-?:NONSTOP_KERNEL:*:*)
echo neo-tandem-nsk${UNAME_RELEASE}
exit ;;
NSE-*:NONSTOP_KERNEL:*:*)
echo nse-tandem-nsk${UNAME_RELEASE}
exit ;;
NSR-?:NONSTOP_KERNEL:*:*)
echo nsr-tandem-nsk${UNAME_RELEASE}
exit ;;
*:NonStop-UX:*:*)
echo mips-compaq-nonstopux
exit ;;
BS2000:POSIX*:*:*)
echo bs2000-siemens-sysv
exit ;;
DS/*:UNIX_System_V:*:*)
echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
exit ;;
*:Plan9:*:*)
# "uname -m" is not consistent, so use $cputype instead. 386
# is converted to i386 for consistency with other x86
# operating systems.
if test "$cputype" = "386"; then
UNAME_MACHINE=i386
else
UNAME_MACHINE="$cputype"
fi
echo ${UNAME_MACHINE}-unknown-plan9
exit ;;
*:TOPS-10:*:*)
echo pdp10-unknown-tops10
exit ;;
*:TENEX:*:*)
echo pdp10-unknown-tenex
exit ;;
KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
echo pdp10-dec-tops20
exit ;;
XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
echo pdp10-xkl-tops20
exit ;;
*:TOPS-20:*:*)
echo pdp10-unknown-tops20
exit ;;
*:ITS:*:*)
echo pdp10-unknown-its
exit ;;
SEI:*:*:SEIUX)
echo mips-sei-seiux${UNAME_RELEASE}
exit ;;
*:DragonFly:*:*)
echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`
exit ;;
*:*VMS:*:*)
UNAME_MACHINE=`(uname -p) 2>/dev/null`
case "${UNAME_MACHINE}" in
A*) echo alpha-dec-vms ; exit ;;
I*) echo ia64-dec-vms ; exit ;;
V*) echo vax-dec-vms ; exit ;;
esac ;;
*:XENIX:*:SysV)
echo i386-pc-xenix
exit ;;
i*86:skyos:*:*)
echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
exit ;;
i*86:rdos:*:*)
echo ${UNAME_MACHINE}-pc-rdos
exit ;;
i*86:AROS:*:*)
echo ${UNAME_MACHINE}-pc-aros
exit ;;
x86_64:VMkernel:*:*)
echo ${UNAME_MACHINE}-unknown-esx
exit ;;
esac
cat >&2 < in order to provide the needed
information to handle your system.
config.guess timestamp = $timestamp
uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
/bin/uname -X = `(/bin/uname -X) 2>/dev/null`
hostinfo = `(hostinfo) 2>/dev/null`
/bin/universe = `(/bin/universe) 2>/dev/null`
/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null`
/bin/arch = `(/bin/arch) 2>/dev/null`
/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
UNAME_MACHINE = ${UNAME_MACHINE}
UNAME_RELEASE = ${UNAME_RELEASE}
UNAME_SYSTEM = ${UNAME_SYSTEM}
UNAME_VERSION = ${UNAME_VERSION}
EOF
exit 1
# Local variables:
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "timestamp='"
# time-stamp-format: "%:y-%02m-%02d"
# time-stamp-end: "'"
# End:
rlwrap-0.42/tools/compile 0000755 0001751 0000144 00000016245 12404151431 012405 0000000 0000000 #! /bin/sh
# Wrapper for compilers which do not understand '-c -o'.
scriptversion=2012-10-14.11; # UTC
# Copyright (C) 1999-2013 Free Software Foundation, Inc.
# Written by Tom Tromey .
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# This file is maintained in Automake, please report
# bugs to or send patches to
# .
nl='
'
# We need space, tab and new line, in precisely that order. Quoting is
# there to prevent tools from complaining about whitespace usage.
IFS=" "" $nl"
file_conv=
# func_file_conv build_file lazy
# Convert a $build file to $host form and store it in $file
# Currently only supports Windows hosts. If the determined conversion
# type is listed in (the comma separated) LAZY, no conversion will
# take place.
func_file_conv ()
{
file=$1
case $file in
/ | /[!/]*) # absolute file, and not a UNC file
if test -z "$file_conv"; then
# lazily determine how to convert abs files
case `uname -s` in
MINGW*)
file_conv=mingw
;;
CYGWIN*)
file_conv=cygwin
;;
*)
file_conv=wine
;;
esac
fi
case $file_conv/,$2, in
*,$file_conv,*)
;;
mingw/*)
file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
;;
cygwin/*)
file=`cygpath -m "$file" || echo "$file"`
;;
wine/*)
file=`winepath -w "$file" || echo "$file"`
;;
esac
;;
esac
}
# func_cl_dashL linkdir
# Make cl look for libraries in LINKDIR
func_cl_dashL ()
{
func_file_conv "$1"
if test -z "$lib_path"; then
lib_path=$file
else
lib_path="$lib_path;$file"
fi
linker_opts="$linker_opts -LIBPATH:$file"
}
# func_cl_dashl library
# Do a library search-path lookup for cl
func_cl_dashl ()
{
lib=$1
found=no
save_IFS=$IFS
IFS=';'
for dir in $lib_path $LIB
do
IFS=$save_IFS
if $shared && test -f "$dir/$lib.dll.lib"; then
found=yes
lib=$dir/$lib.dll.lib
break
fi
if test -f "$dir/$lib.lib"; then
found=yes
lib=$dir/$lib.lib
break
fi
if test -f "$dir/lib$lib.a"; then
found=yes
lib=$dir/lib$lib.a
break
fi
done
IFS=$save_IFS
if test "$found" != yes; then
lib=$lib.lib
fi
}
# func_cl_wrapper cl arg...
# Adjust compile command to suit cl
func_cl_wrapper ()
{
# Assume a capable shell
lib_path=
shared=:
linker_opts=
for arg
do
if test -n "$eat"; then
eat=
else
case $1 in
-o)
# configure might choose to run compile as 'compile cc -o foo foo.c'.
eat=1
case $2 in
*.o | *.[oO][bB][jJ])
func_file_conv "$2"
set x "$@" -Fo"$file"
shift
;;
*)
func_file_conv "$2"
set x "$@" -Fe"$file"
shift
;;
esac
;;
-I)
eat=1
func_file_conv "$2" mingw
set x "$@" -I"$file"
shift
;;
-I*)
func_file_conv "${1#-I}" mingw
set x "$@" -I"$file"
shift
;;
-l)
eat=1
func_cl_dashl "$2"
set x "$@" "$lib"
shift
;;
-l*)
func_cl_dashl "${1#-l}"
set x "$@" "$lib"
shift
;;
-L)
eat=1
func_cl_dashL "$2"
;;
-L*)
func_cl_dashL "${1#-L}"
;;
-static)
shared=false
;;
-Wl,*)
arg=${1#-Wl,}
save_ifs="$IFS"; IFS=','
for flag in $arg; do
IFS="$save_ifs"
linker_opts="$linker_opts $flag"
done
IFS="$save_ifs"
;;
-Xlinker)
eat=1
linker_opts="$linker_opts $2"
;;
-*)
set x "$@" "$1"
shift
;;
*.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
func_file_conv "$1"
set x "$@" -Tp"$file"
shift
;;
*.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
func_file_conv "$1" mingw
set x "$@" "$file"
shift
;;
*)
set x "$@" "$1"
shift
;;
esac
fi
shift
done
if test -n "$linker_opts"; then
linker_opts="-link$linker_opts"
fi
exec "$@" $linker_opts
exit 1
}
eat=
case $1 in
'')
echo "$0: No command. Try '$0 --help' for more information." 1>&2
exit 1;
;;
-h | --h*)
cat <<\EOF
Usage: compile [--help] [--version] PROGRAM [ARGS]
Wrapper for compilers which do not understand '-c -o'.
Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
arguments, and rename the output as expected.
If you are trying to build a whole package this is not the
right script to run: please start by reading the file 'INSTALL'.
Report bugs to .
EOF
exit $?
;;
-v | --v*)
echo "compile $scriptversion"
exit $?
;;
cl | *[/\\]cl | cl.exe | *[/\\]cl.exe )
func_cl_wrapper "$@" # Doesn't return...
;;
esac
ofile=
cfile=
for arg
do
if test -n "$eat"; then
eat=
else
case $1 in
-o)
# configure might choose to run compile as 'compile cc -o foo foo.c'.
# So we strip '-o arg' only if arg is an object.
eat=1
case $2 in
*.o | *.obj)
ofile=$2
;;
*)
set x "$@" -o "$2"
shift
;;
esac
;;
*.c)
cfile=$1
set x "$@" "$1"
shift
;;
*)
set x "$@" "$1"
shift
;;
esac
fi
shift
done
if test -z "$ofile" || test -z "$cfile"; then
# If no '-o' option was seen then we might have been invoked from a
# pattern rule where we don't need one. That is ok -- this is a
# normal compilation that the losing compiler can handle. If no
# '.c' file was seen then we are probably linking. That is also
# ok.
exec "$@"
fi
# Name of file we expect compiler to create.
cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
# Create the lock directory.
# Note: use '[/\\:.-]' here to ensure that we don't use the same name
# that we are using for the .o file. Also, base the name on the expected
# object file name, since that is what matters with a parallel build.
lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
while true; do
if mkdir "$lockdir" >/dev/null 2>&1; then
break
fi
sleep 1
done
# FIXME: race condition here if user kills between mkdir and trap.
trap "rmdir '$lockdir'; exit 1" 1 2 15
# Run the compile.
"$@"
ret=$?
if test -f "$cofile"; then
test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
elif test -f "${cofile}bj"; then
test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
fi
rmdir "$lockdir"
exit $ret
# Local Variables:
# mode: shell-script
# sh-indentation: 2
# 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:
rlwrap-0.42/tools/depcomp 0000755 0001751 0000144 00000056016 12404151432 012405 0000000 0000000 #! /bin/sh
# depcomp - compile a program generating dependencies as side-effects
scriptversion=2013-05-30.07; # UTC
# Copyright (C) 1999-2013 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# Originally written by Alexandre Oliva .
case $1 in
'')
echo "$0: No command. Try '$0 --help' for more information." 1>&2
exit 1;
;;
-h | --h*)
cat <<\EOF
Usage: depcomp [--help] [--version] PROGRAM [ARGS]
Run PROGRAMS ARGS to compile a file, generating dependencies
as side-effects.
Environment variables:
depmode Dependency tracking mode.
source Source file read by 'PROGRAMS ARGS'.
object Object file output by 'PROGRAMS ARGS'.
DEPDIR directory where to store dependencies.
depfile Dependency file to output.
tmpdepfile Temporary file to use when outputting dependencies.
libtool Whether libtool is used (yes/no).
Report bugs to .
EOF
exit $?
;;
-v | --v*)
echo "depcomp $scriptversion"
exit $?
;;
esac
# Get the directory component of the given path, and save it in the
# global variables '$dir'. Note that this directory component will
# be either empty or ending with a '/' character. This is deliberate.
set_dir_from ()
{
case $1 in
*/*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;;
*) dir=;;
esac
}
# Get the suffix-stripped basename of the given path, and save it the
# global variable '$base'.
set_base_from ()
{
base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'`
}
# If no dependency file was actually created by the compiler invocation,
# we still have to create a dummy depfile, to avoid errors with the
# Makefile "include basename.Plo" scheme.
make_dummy_depfile ()
{
echo "#dummy" > "$depfile"
}
# Factor out some common post-processing of the generated depfile.
# Requires the auxiliary global variable '$tmpdepfile' to be set.
aix_post_process_depfile ()
{
# If the compiler actually managed to produce a dependency file,
# post-process it.
if test -f "$tmpdepfile"; then
# Each line is of the form 'foo.o: dependency.h'.
# Do two passes, one to just change these to
# $object: dependency.h
# and one to simply output
# dependency.h:
# which is needed to avoid the deleted-header problem.
{ sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile"
sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile"
} > "$depfile"
rm -f "$tmpdepfile"
else
make_dummy_depfile
fi
}
# A tabulation character.
tab=' '
# A newline character.
nl='
'
# Character ranges might be problematic outside the C locale.
# These definitions help.
upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
lower=abcdefghijklmnopqrstuvwxyz
digits=0123456789
alpha=${upper}${lower}
if test -z "$depmode" || test -z "$source" || test -z "$object"; then
echo "depcomp: Variables source, object and depmode must be set" 1>&2
exit 1
fi
# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
depfile=${depfile-`echo "$object" |
sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
rm -f "$tmpdepfile"
# Avoid interferences from the environment.
gccflag= dashmflag=
# Some modes work just like other modes, but use different flags. We
# parameterize here, but still list the modes in the big case below,
# to make depend.m4 easier to write. Note that we *cannot* use a case
# here, because this file can only contain one case statement.
if test "$depmode" = hp; then
# HP compiler uses -M and no extra arg.
gccflag=-M
depmode=gcc
fi
if test "$depmode" = dashXmstdout; then
# This is just like dashmstdout with a different argument.
dashmflag=-xM
depmode=dashmstdout
fi
cygpath_u="cygpath -u -f -"
if test "$depmode" = msvcmsys; then
# This is just like msvisualcpp but w/o cygpath translation.
# Just convert the backslash-escaped backslashes to single forward
# slashes to satisfy depend.m4
cygpath_u='sed s,\\\\,/,g'
depmode=msvisualcpp
fi
if test "$depmode" = msvc7msys; then
# This is just like msvc7 but w/o cygpath translation.
# Just convert the backslash-escaped backslashes to single forward
# slashes to satisfy depend.m4
cygpath_u='sed s,\\\\,/,g'
depmode=msvc7
fi
if test "$depmode" = xlc; then
# IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
gccflag=-qmakedep=gcc,-MF
depmode=gcc
fi
case "$depmode" in
gcc3)
## gcc 3 implements dependency tracking that does exactly what
## we want. Yay! Note: for some reason libtool 1.4 doesn't like
## it if -MD -MP comes after the -MF stuff. Hmm.
## Unfortunately, FreeBSD c89 acceptance of flags depends upon
## the command line argument order; so add the flags where they
## appear in depend2.am. Note that the slowdown incurred here
## affects only configure: in makefiles, %FASTDEP% shortcuts this.
for arg
do
case $arg in
-c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
*) set fnord "$@" "$arg" ;;
esac
shift # fnord
shift # $arg
done
"$@"
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
mv "$tmpdepfile" "$depfile"
;;
gcc)
## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
## (see the conditional assignment to $gccflag above).
## There are various ways to get dependency output from gcc. Here's
## why we pick this rather obscure method:
## - Don't want to use -MD because we'd like the dependencies to end
## up in a subdir. Having to rename by hand is ugly.
## (We might end up doing this anyway to support other compilers.)
## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
## -MM, not -M (despite what the docs say). Also, it might not be
## supported by the other compilers which use the 'gcc' depmode.
## - Using -M directly means running the compiler twice (even worse
## than renaming).
if test -z "$gccflag"; then
gccflag=-MD,
fi
"$@" -Wp,"$gccflag$tmpdepfile"
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
echo "$object : \\" > "$depfile"
# The second -e expression handles DOS-style file names with drive
# letters.
sed -e 's/^[^:]*: / /' \
-e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
## This next piece of magic avoids the "deleted header file" problem.
## The problem is that when a header file which appears in a .P file
## is deleted, the dependency causes make to die (because there is
## typically no way to rebuild the header). We avoid this by adding
## dummy dependencies for each header file. Too bad gcc doesn't do
## this for us directly.
## Some versions of gcc put a space before the ':'. On the theory
## that the space means something, we add a space to the output as
## well. hp depmode also adds that space, but also prefixes the VPATH
## to the object. Take care to not repeat it in the output.
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly. Breaking it into two sed invocations is a workaround.
tr ' ' "$nl" < "$tmpdepfile" \
| sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
| sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
hp)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
sgi)
if test "$libtool" = yes; then
"$@" "-Wp,-MDupdate,$tmpdepfile"
else
"$@" -MDupdate "$tmpdepfile"
fi
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files
echo "$object : \\" > "$depfile"
# Clip off the initial element (the dependent). Don't try to be
# clever and replace this with sed code, as IRIX sed won't handle
# lines with more than a fixed number of characters (4096 in
# IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines;
# the IRIX cc adds comments like '#:fec' to the end of the
# dependency line.
tr ' ' "$nl" < "$tmpdepfile" \
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
| tr "$nl" ' ' >> "$depfile"
echo >> "$depfile"
# The second pass generates a dummy entry for each header file.
tr ' ' "$nl" < "$tmpdepfile" \
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
>> "$depfile"
else
make_dummy_depfile
fi
rm -f "$tmpdepfile"
;;
xlc)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
aix)
# The C for AIX Compiler uses -M and outputs the dependencies
# in a .u file. In older versions, this file always lives in the
# current directory. Also, the AIX compiler puts '$object:' at the
# start of each line; $object doesn't have directory information.
# Version 6 uses the directory in both cases.
set_dir_from "$object"
set_base_from "$object"
if test "$libtool" = yes; then
tmpdepfile1=$dir$base.u
tmpdepfile2=$base.u
tmpdepfile3=$dir.libs/$base.u
"$@" -Wc,-M
else
tmpdepfile1=$dir$base.u
tmpdepfile2=$dir$base.u
tmpdepfile3=$dir$base.u
"$@" -M
fi
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
exit $stat
fi
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
do
test -f "$tmpdepfile" && break
done
aix_post_process_depfile
;;
tcc)
# tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
# FIXME: That version still under development at the moment of writing.
# Make that this statement remains true also for stable, released
# versions.
# It will wrap lines (doesn't matter whether long or short) with a
# trailing '\', as in:
#
# foo.o : \
# foo.c \
# foo.h \
#
# It will put a trailing '\' even on the last line, and will use leading
# spaces rather than leading tabs (at least since its commit 0394caf7
# "Emit spaces for -MD").
"$@" -MD -MF "$tmpdepfile"
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
# Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
# We have to change lines of the first kind to '$object: \'.
sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
# And for each line of the second kind, we have to emit a 'dep.h:'
# dummy dependency, to avoid the deleted-header problem.
sed -n -e 's|^ *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
rm -f "$tmpdepfile"
;;
## The order of this option in the case statement is important, since the
## shell code in configure will try each of these formats in the order
## listed in this file. A plain '-MD' option would be understood by many
## compilers, so we must ensure this comes after the gcc and icc options.
pgcc)
# Portland's C compiler understands '-MD'.
# Will always output deps to 'file.d' where file is the root name of the
# source file under compilation, even if file resides in a subdirectory.
# The object file name does not affect the name of the '.d' file.
# pgcc 10.2 will output
# foo.o: sub/foo.c sub/foo.h
# and will wrap long lines using '\' :
# foo.o: sub/foo.c ... \
# sub/foo.h ... \
# ...
set_dir_from "$object"
# Use the source, not the object, to determine the base name, since
# that's sadly what pgcc will do too.
set_base_from "$source"
tmpdepfile=$base.d
# For projects that build the same source file twice into different object
# files, the pgcc approach of using the *source* file root name can cause
# problems in parallel builds. Use a locking strategy to avoid stomping on
# the same $tmpdepfile.
lockdir=$base.d-lock
trap "
echo '$0: caught signal, cleaning up...' >&2
rmdir '$lockdir'
exit 1
" 1 2 13 15
numtries=100
i=$numtries
while test $i -gt 0; do
# mkdir is a portable test-and-set.
if mkdir "$lockdir" 2>/dev/null; then
# This process acquired the lock.
"$@" -MD
stat=$?
# Release the lock.
rmdir "$lockdir"
break
else
# If the lock is being held by a different process, wait
# until the winning process is done or we timeout.
while test -d "$lockdir" && test $i -gt 0; do
sleep 1
i=`expr $i - 1`
done
fi
i=`expr $i - 1`
done
trap - 1 2 13 15
if test $i -le 0; then
echo "$0: failed to acquire lock after $numtries attempts" >&2
echo "$0: check lockdir '$lockdir'" >&2
exit 1
fi
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
# Each line is of the form `foo.o: dependent.h',
# or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
# Do two passes, one to just change these to
# `$object: dependent.h' and one to simply `dependent.h:'.
sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
# Some versions of the HPUX 10.20 sed can't process this invocation
# correctly. Breaking it into two sed invocations is a workaround.
sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
| sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
hp2)
# The "hp" stanza above does not work with aCC (C++) and HP's ia64
# compilers, which have integrated preprocessors. The correct option
# to use with these is +Maked; it writes dependencies to a file named
# 'foo.d', which lands next to the object file, wherever that
# happens to be.
# Much of this is similar to the tru64 case; see comments there.
set_dir_from "$object"
set_base_from "$object"
if test "$libtool" = yes; then
tmpdepfile1=$dir$base.d
tmpdepfile2=$dir.libs/$base.d
"$@" -Wc,+Maked
else
tmpdepfile1=$dir$base.d
tmpdepfile2=$dir$base.d
"$@" +Maked
fi
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile1" "$tmpdepfile2"
exit $stat
fi
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
do
test -f "$tmpdepfile" && break
done
if test -f "$tmpdepfile"; then
sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile"
# Add 'dependent.h:' lines.
sed -ne '2,${
s/^ *//
s/ \\*$//
s/$/:/
p
}' "$tmpdepfile" >> "$depfile"
else
make_dummy_depfile
fi
rm -f "$tmpdepfile" "$tmpdepfile2"
;;
tru64)
# The Tru64 compiler uses -MD to generate dependencies as a side
# effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
# At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
# dependencies in 'foo.d' instead, so we check for that too.
# Subdirectories are respected.
set_dir_from "$object"
set_base_from "$object"
if test "$libtool" = yes; then
# Libtool generates 2 separate objects for the 2 libraries. These
# two compilations output dependencies in $dir.libs/$base.o.d and
# in $dir$base.o.d. We have to check for both files, because
# one of the two compilations can be disabled. We should prefer
# $dir$base.o.d over $dir.libs/$base.o.d because the latter is
# automatically cleaned when .libs/ is deleted, while ignoring
# the former would cause a distcleancheck panic.
tmpdepfile1=$dir$base.o.d # libtool 1.5
tmpdepfile2=$dir.libs/$base.o.d # Likewise.
tmpdepfile3=$dir.libs/$base.d # Compaq CCC V6.2-504
"$@" -Wc,-MD
else
tmpdepfile1=$dir$base.d
tmpdepfile2=$dir$base.d
tmpdepfile3=$dir$base.d
"$@" -MD
fi
stat=$?
if test $stat -ne 0; then
rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
exit $stat
fi
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
do
test -f "$tmpdepfile" && break
done
# Same post-processing that is required for AIX mode.
aix_post_process_depfile
;;
msvc7)
if test "$libtool" = yes; then
showIncludes=-Wc,-showIncludes
else
showIncludes=-showIncludes
fi
"$@" $showIncludes > "$tmpdepfile"
stat=$?
grep -v '^Note: including file: ' "$tmpdepfile"
if test $stat -ne 0; then
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
echo "$object : \\" > "$depfile"
# The first sed program below extracts the file names and escapes
# backslashes for cygpath. The second sed program outputs the file
# name when reading, but also accumulates all include files in the
# hold buffer in order to output them again at the end. This only
# works with sed implementations that can handle large buffers.
sed < "$tmpdepfile" -n '
/^Note: including file: *\(.*\)/ {
s//\1/
s/\\/\\\\/g
p
}' | $cygpath_u | sort -u | sed -n '
s/ /\\ /g
s/\(.*\)/'"$tab"'\1 \\/p
s/.\(.*\) \\/\1:/
H
$ {
s/.*/'"$tab"'/
G
p
}' >> "$depfile"
echo >> "$depfile" # make sure the fragment doesn't end with a backslash
rm -f "$tmpdepfile"
;;
msvc7msys)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
#nosideeffect)
# This comment above is used by automake to tell side-effect
# dependency tracking mechanisms from slower ones.
dashmstdout)
# Important note: in order to support this mode, a compiler *must*
# always write the preprocessed file to stdout, regardless of -o.
"$@" || exit $?
# Remove the call to Libtool.
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
# Remove '-o $object'.
IFS=" "
for arg
do
case $arg in
-o)
shift
;;
$object)
shift
;;
*)
set fnord "$@" "$arg"
shift # fnord
shift # $arg
;;
esac
done
test -z "$dashmflag" && dashmflag=-M
# Require at least two characters before searching for ':'
# in the target name. This is to cope with DOS-style filenames:
# a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
"$@" $dashmflag |
sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile"
rm -f "$depfile"
cat < "$tmpdepfile" > "$depfile"
# Some versions of the HPUX 10.20 sed can't process this sed invocation
# correctly. Breaking it into two sed invocations is a workaround.
tr ' ' "$nl" < "$tmpdepfile" \
| sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
| sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
dashXmstdout)
# This case only exists to satisfy depend.m4. It is never actually
# run, as this mode is specially recognized in the preamble.
exit 1
;;
makedepend)
"$@" || exit $?
# Remove any Libtool call
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
# X makedepend
shift
cleared=no eat=no
for arg
do
case $cleared in
no)
set ""; shift
cleared=yes ;;
esac
if test $eat = yes; then
eat=no
continue
fi
case "$arg" in
-D*|-I*)
set fnord "$@" "$arg"; shift ;;
# Strip any option that makedepend may not understand. Remove
# the object too, otherwise makedepend will parse it as a source file.
-arch)
eat=yes ;;
-*|$object)
;;
*)
set fnord "$@" "$arg"; shift ;;
esac
done
obj_suffix=`echo "$object" | sed 's/^.*\././'`
touch "$tmpdepfile"
${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
rm -f "$depfile"
# makedepend may prepend the VPATH from the source file name to the object.
# No need to regex-escape $object, excess matching of '.' is harmless.
sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile"
# Some versions of the HPUX 10.20 sed can't process the last invocation
# correctly. Breaking it into two sed invocations is a workaround.
sed '1,2d' "$tmpdepfile" \
| tr ' ' "$nl" \
| sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
| sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile" "$tmpdepfile".bak
;;
cpp)
# Important note: in order to support this mode, a compiler *must*
# always write the preprocessed file to stdout.
"$@" || exit $?
# Remove the call to Libtool.
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
# Remove '-o $object'.
IFS=" "
for arg
do
case $arg in
-o)
shift
;;
$object)
shift
;;
*)
set fnord "$@" "$arg"
shift # fnord
shift # $arg
;;
esac
done
"$@" -E \
| sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
-e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
| sed '$ s: \\$::' > "$tmpdepfile"
rm -f "$depfile"
echo "$object : \\" > "$depfile"
cat < "$tmpdepfile" >> "$depfile"
sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
msvisualcpp)
# Important note: in order to support this mode, a compiler *must*
# always write the preprocessed file to stdout.
"$@" || exit $?
# Remove the call to Libtool.
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
IFS=" "
for arg
do
case "$arg" in
-o)
shift
;;
$object)
shift
;;
"-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
set fnord "$@"
shift
shift
;;
*)
set fnord "$@" "$arg"
shift
shift
;;
esac
done
"$@" -E 2>/dev/null |
sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
rm -f "$depfile"
echo "$object : \\" > "$depfile"
sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile"
echo "$tab" >> "$depfile"
sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
rm -f "$tmpdepfile"
;;
msvcmsys)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
none)
exec "$@"
;;
*)
echo "Unknown depmode $depmode" 1>&2
exit 1
;;
esac
exit 0
# Local Variables:
# mode: shell-script
# sh-indentation: 2
# 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:
rlwrap-0.42/NEWS 0000644 0001751 0000144 00000046011 12431100550 010354 0000000 0000000 0.42 Added --mirror-arguments (-U) option
On SunOS tcgetattr(slave pty) failed with "Invalid argument"
If the completion list contained two words, one of which a
prefix of the other (e.g. "sea" and "seagull") the shorter one would
be skipped when displaying a list of completions
reading completion files (with the -f option, or from
$RLWRAP_HOME/_completions) could fail with an incorrect
ENOENT ("No such file or directory")
rlwrap -z listing wouldn't list filters
When both master and slave pty are unfit for sensing slave
commands terminal settings, rlwrap now bails out with an error
"cannot determine terminal mode of slave command"
0.41 Slightly late SIGCHLD could cause an I/O error on master pty
Added -W (-polling) option to poll slave pty for changes in its
interrupt character and ISIG flag.
if $TERM is not found in termcap/terminfo database, use vt100
0.40 configure will now find tgetent() in libtinfo
compiling with gcc -O2 made rlwrap hang after CTRL-D on empty line
HP-UX 11 has weird tgetent() return values, confusing rlwrap
On Solaris, rlwrap would sometimes fail with "TIOCSWINSZ failed on
slave pty"
Single quote ' is now word-breaking by default
multi-line edit would mangle upper ASCII and UTF-8 (and still does
that to UTF16 :( )
added --extra-char-after-completion and -multi-line-ext options
rlwrap now recognises the 'rmcup' and 'rmkx' character sequences used by
programs that use an alternate screen (like editors and pagers) to return
from it.
configure will now correctly determine pty type on SCO OpenServer
rlwrap --no-children would leak file descriptors to /proc//wchan
non-ASCII characters in multi-line input are no longer replaced
by spaces after calling an external editor
running rlwrap within emacs would crash (division by zero).
rlwrap now bails out whenever terminal width == 0
added --enable-proc-mountpoint config option to use alternate linux-like
proc filesystems (like in FreeBSD) for finding s working dir (-c option)
and kernel function in which is sleeping (-N option)
added prototype for copy_without_ignore_markers, fixing a segfault on NetBSD/amd64
commands final output before dying was lost on FreeBSD
Filters now get complete echo lines even if the echo comes back in chunks
0.37 Commands that emit "status lines" using backspaces and carriage
returns could confuse rlwrap
removed test program kaboom.c that triggered an internal
gcc error on armel platforms.
rlwrap uses C strings internally, and thus cannot cope with
command output that contains zero bytes (padding). It used to
replace these with spaces, now the zero bytes are removed.
if the RLWRAP_HOME is set, but $RLWRAP_HOME doesn't exist, rlwrap
will create it
typo: SIGERR instead of SIG_ERR in signals.c
0.36 Entering a line from vi command mode would echo the input twice
Output from very busy commands would not always be printed on time
When rlwrap kills itself after a command crash it will not dump
core, in order to avoid clobbering command's much more interesting
core dump.
Premature filter death is now reported properly (it used to only
say: "EOF reading from filter" or "Broken pipe writing to filter")
0.35 config.{guess,sub} have been updated to version 2009-12-13
Corrected array bounds error in my_putstr("") (which could make
rlwrap write an extra newline when exiting, but might even crash
on some systems)
Many small improvements and fixes for multi-line input:
Multi-line inputs are now written to the inferior command one
line at a time, so that command's response (e.g. a continuation
prompt) can be interleaved with the echo'ed (multi-line) input.
Calling an external editor will no longer obliterate the prompt,
and line/column positions are now correct.
After a multi-line edit in vi-mode, the cursor will no longer
end up one line too high.
CTRL-D on an empty line was handed directly to command, but also
(erroneously) put in readline's input buffer
Many small fixes and improvements in signal handling:
SIGSEGV, and other "error" signals like SIGFPE, are now unblocked
all of the time, so that rlwrap can always clean up after a crash.
Since version 0.25 rlrwap's transparency extends to signals: if
the inferior command segfaults, rlwrap will kill itself with a
SIGSEGV. In order to get the bug reports where they belong,
rlwrap now reports explicitly that it has not crashed itself.
rlwrap's call to sigaction forgot to set the signal mask (!)
Continuing after CTRL-Z on QNX now wakes up command
Added --one-shot (-o) and --only-cook (-O) options
debug log is now in a format that works well with emacs' grep-mode
rlwrap's bindable readline function names (like rlwrap-call-editor) are
now in hyphen-style instead of underscore_style (use of the
old_style_names will now be flagged as an error)
Filters can now prevent a prompt from being cooked by "rejecting" it.
Rlwrapfilter.pm would set $_ incorrectly in echo and output handlers.
RlwrapFilter.pm manpage is now created by newer (and less buggy)
version of pod2man
Added EXAMPLES section and -t option to rlwrap manpage
0.34 Binding wide (e.g. utf-8) chars in .inputrc now works
prefix arguments are now correctly reset (M-5 a b now
yields aaaaab instead of aaaaabbbbb)
0.33 rlwrap incorrectly fed terminfo-style capnames ("dl1") instead of
termcap codes ("dl") into tgetstr(). On newer Debian systems this
exposed a bug where random garbage would be printed by rlwrap
Hyphens in rlwrap manpage are now all properly escaped
RlwrapFilter.pm now only re-sets $filter->cumulative_output when an
INPUT message is received
0.32 Major new feature: filtering. Filters sit between rlwrap and the
wrapped command, re-writing command output, input, prompts,
history, and completion word lists.
System-wide filters live in DATADIR/rlwrap/filters (where DATADIR =
/usr/local/share by default, installation-dependent) Because of this,
completions now live in DATADIR/rlwrap/completions (until now:
DATADIR/rlwrap)
To make filter writing easy, a perl module RlwrapFilter.pm has
been added. It doesn't become part of your perl installation, but lives
in DATADIR/rlwrap/filters
rlwrap didn't properly check errno after reading from inferior pty.
This could lead to a spurious "read error on master pty"
Instead of using crusty old signal(), signal handlers are now set
by sigaction() without SA_RESTART (BSD semantics) Different
syscall-restarting behaviour among systems caused hard-to-trace
bugs
Now copies inferior pty's c_oflags to stdout before
output. (some editors like joe would mess up the screen)
prompt handling logic has been streamlined. Coloured prompt handling is
reliable now, even for long prompts.
At program exit, rlwrap now outputs a newline only when the client
didn't.
Added -g, -I, -N, -S, -w and -z options
Removed -F option (and added a filter to replace it)
-p option now takes colour names (-pYellow)
rlwrap (and readline) uses C strings internally, which could cause problems
with commands that output '\0' bytes. In direct mode, such
characters are left untouched, but in readline mode they are
replaced by spaces.
the tools directory has been updated, so that configure will
feel at home even on newer systems
tested on SunOS, AIX, FreeBSD, HP/UX, QNX (thanks to polarhome.com), as
well as cygwin and linux
0.30 rlwrap can now use putenv() on machines that don't have
setenv() (like some Solaris systems)
EOF on stdin (e.g. by pressing CTRL-D) would end prompt colouring.
added -q option
0.29 added -A option to handle (ANSI-)coloured prompts
added -p option to colourise uncoloured prompts
added -t option to set terminal type for client command
rlwrap now copies its terminal settings from the client
even when this has put its terminal in single-keypress
(uncooked) mode. A rlwrapped emacs will now respond to CTRL-C
and CTRL-G as it should.
fixed a long-standing bug where long output lines with the -r option
would put mutilated words into the completion list. Drawback:
prompts are not put into the completion list anymore (bug or feature?).
rlwrap now handles output to the client before input from the
client, and only handles keyboard input when all client I/O has
been handled. This will make rlwrap a little better behaved when
handling large chunks of (pasted) input, especially with colourised
prompts
error messages and warnings now include the rlwrap version number
rlwrap now prints a warning when started in vi mode when the
terminal is too dumb to support upwards cursor movement
added a very simple custom malloc/free debugger for use with the
--debug option. Rather fragile and not well tested, use with care.
Whenever TERM is not set, rlwrap assumes vt100. Set TERM=dumb if
you really have a dumb terminal.
rlwrap now leaves the handling of multi-line prompts and edit
buffers to readline (except when in horizontal-scroll mode or when
configured with --enable-homegrown-redisplay).
whenever --always-readline is set, SIGWINCH not passed to
client command immediately, but only *after* accepting a line.
multi-byte prompts and input no longer confuse rlwrap (provided
your readline lib supports multi-byte characters)
--spy-on-readline now enabled by default
the configure script will now find term.h on cygwin
dropped the assumption that tgetent() and friends are only ever
declared in term.h; rlwrap now has proper terminal handling also
under SunOS.
the rlwrap source should again be fit for consumption by older
(C91 compliant) compilers
0.28 fixed rlwrap bug that caused termcap problems on Fedora Core 6
(thanks Tung Nguyen)
0.27 when stdin is not a terminal, rlwrap will now exec() the
specified command instead of complaining
when stdout or stderr is not a terminal, rlwrap will re-open
it to /dev/tty (the users terminal) after forking off the
specified command (so "rlwrap cat > file" will work as a
quick and dirty line editor)
rlwrap now remembers inputs of length 1
-D option to tell rlwrap how agressively it should weed out
duplicate history entries
-H option added (history format string)
Added temporary fix for termcap weirdness on Fedora Core 6
new -t option for a quick check of terminal capabilities
(requires configuration with --enable-debug)
rlwrap -s 0 will now zap history
fixed broken reporting of unrecognised options
0.26 configure on FreeBSD 6.0 still didn't find libutil
some files were unnecessarily kept open (thanks Stephan Springl)
on each platform, rlwrap -h now accurately reflects whether
rlwrap can use long options or optional arguments
0.25 rlwrap would print input twice when in vi-mode
rlwrap under FreeBSD 6.0 now uses openpty() from libutil (config
script fixed)
-P option added (one-shot rlwrap with pre-given prompt)
Until now, whem the underlying command was killed by a signal,
rlwrap would just exit with exit code 0. Now rlwrap will
cleanup, reset its signal handlers and then send the same signal
to itself - so that rlwraps parent (usually a shell) doesn't see
the difference with an un-rlwrapped command
0.24 rlwrap -r would mess up commands output (strtok() strikes again!)
-i option added to make completion case-insensitive
-m option added in order to handle multi-line input
rlwrap now writes to underlying command using non-blocking writes
and select(). This prevents deadlocks which could occur with very
large inputs.
corrected some manpage clumsiness
0.23 Completion word lists are now kept in red-black trees
(cf. http://libredblack.sourceforge.net/), dramatically speeding up
startup with large completion lists.
rlwrap copies terminal settings from client, so that wrapping
programs that manipulate their terminal (like emacs and vim)
should be transparent.
rlwrap -C1 is now accepted
0.22 Added key binding to enter a line while keeping it out of the
history list (Control+O by default)
0.21 Added --history-filename option.
Negative history size now means: don't write or truncate history
Updated helper scripts (like config.sub) in ./tools
multiple -f options again work correctly
--enable-homegrown-redisplay configuration option added
(kludge to circumvent display problems like sometimes
reported on Solaris)
All unsafe string handling functions (strcpy, sprintf,..) replaced
by their safe equivalents - using strlcat and consorts when available.
--enable-spy-on-readline configuration option to keep display tidy
when resizing terminal
0.19 Fixed pty type finding code in configure.ac (newer FreeBSD's
were recognised as cygwin)
Helper scripts moved to separate ./tools directory
0.18 rlwrap could hang when trying to run a non-existent command.
0.17 EOF on stdin would send rlwrap into infinite loop.
Small bugfixes in testclient, which now works with perl 5.8 and
cygwin.
0.16 ptys can be found and correctly opend on many more systems
(thanks to code taken from rxvt).
Makefiles now generated by automake.
Much beter debugging, -d option now takes optional bitmask
to report only certain events.
System-wide completion files now in $datadir/rlwrap
(normally /usr/local/share/rlwrap).
-C and -n options added, -a option can take an argument (to
prevent password logging when using this option).
assert() macro used for run-time consistency checks.
CTRL-D on empty line now sends EOF to client even on SunOS.
manpage displays correctly even when using troff instead of groff.
Long options now in --dash-style instead of --underscore_style.
0.15 Fixed a bug where rlwrap would segfault with -f option.
0.14 Fixed a few portability problems.
0.13 Duplicate history entries are avoided at all times, even across
invocations.
Tries to chdir into the slave command's working directory before
attempting filename completion (only on OS'es where this is found
under /proc//cwd, like linux and SunOS).
Now honours 'set horizontal-scroll-mode off' in .inputrc.
Slave pty is never closed in parent (even after slave's death),
preventing long timeouts in OSes with streams-based pty IO.
Lots of small fixes to adapt to gcc 3.x's more finicky behaviour
(e.g. avoiding multi-line strings, not automaticaly including system
includes in Makefile.in).
configure rewrites manpage to reflect rlwraps capabilities on each
platform.
history searching with CTRL-R (backwards-search-history) now works,
!-completion is cleaned up (could even segfault in previous versions).
SIGSEGV is now caught in order to reset terminal.
0.12 When slave pty's ECHO flag is unset (e.g. when entering a password)
rlwrap now displays asterisks for every input character like this:
Password: ******
Better handling of very long prompts, or very narrow terminal windows.
If the prompt is wider than the current terminal, rlwrap assumes
that it has wrapped around and uses the last (wrapped) line of
it as the new prompt.
Slave pty is opened (and remains open) in parent, allowing slave side
to be monitored instead of master.
testclient (a perl script) has been added, uncovering quite a few
embarassing bugs.
system-wide completion word lists (in $sysconfdir/rlwrap) can be used.
0.11 If the tcgetattr() call to determine the pty's echo mode fails at
startup, rlwrap now sleeps for 1 second before trying again
once. (on FreeBSD, the first call will normally fail, but (most of
the time) not the second, due to a race condition that
ought to be fixed by some form of synchronisation between parent
and child)
--libdir and --includedir for configure now work, as well as
LDFLAGS=xxxx ./configure.
Filename completion now works again (when -c option is set).
User input is now echoed correctly when the pty's echo mode cannot be
determined (in that case a warning is printed at startup that
passwords will be saved in the history file).
0.10: logging (-l option) implemented.
history_filename and completion_filename now live on the heap
instead of in fixed-length buffers.
0.07: Readline mode is entered (by registering callback) with the
first keypress of a new line, not before. All command output before that
will just be written to stdout unchanged (long lines could become garbled
in 0.06 and earlier).
Signal handling (esp. SIGTSTP and SIGWINCH) is much improved.
The -a option forces rlwrap to use readline, which is useful if you
want to rlwrap a command that already uses readline.
is now bound to menu-complete by default: it will cylce through all
possible completions, instead of listing them all, as in 0.06.
0.06: Transparent mode (immediately handing down keypresses) is now
automatic whenever the pty has its ICANON flag unset.
readline version 4.2 is now mandatory.
Cleanup of code, eliminating many bugs, possibly introducing
others (ugh!)
Application name (used by readline) is now set to command name.
Duplicate history entries are not remembered.
Manpage updated: environment variable RLWRAP_HOME is now documented.
0.04: When started in transparent mode, now properly returns to it after
each readline edit.
Senses the pty's ECHO flag. When this is unset, rlwrap doesn't echo
user input. Neither is it put in the history list (which would contain
passwords etc. otherwise).
0.03: Now uses ._history and ._completions
files (by default in $HOME).
0.02: A couple of #ifdefs for portability (tested on BSDI and Digital Unix).
0.01: Initial version.
rlwrap-0.42/aclocal.m4 0000644 0001751 0000144 00000121707 12431353232 011532 0000000 0000000 # generated automatically by aclocal 1.14.1 -*- Autoconf -*-
# Copyright (C) 1996-2013 Free Software Foundation, Inc.
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])])
m4_ifndef([AC_AUTOCONF_VERSION],
[m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.69],,
[m4_warning([this file was generated for autoconf 2.69.
You have another version of autoconf. It may work, but is not guaranteed to.
If you have problems, you may need to regenerate the build system entirely.
To do so, use the procedure documented by the package, typically 'autoreconf'.])])
# Copyright (C) 2002-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_AUTOMAKE_VERSION(VERSION)
# ----------------------------
# Automake X.Y traces this macro to ensure aclocal.m4 has been
# generated from the m4 files accompanying Automake X.Y.
# (This private macro should not be called outside this file.)
AC_DEFUN([AM_AUTOMAKE_VERSION],
[am__api_version='1.14'
dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
dnl require some minimum version. Point them to the right macro.
m4_if([$1], [1.14.1], [],
[AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
])
# _AM_AUTOCONF_VERSION(VERSION)
# -----------------------------
# aclocal traces this macro to find the Autoconf version.
# This is a private macro too. Using m4_define simplifies
# the logic in aclocal, which can simply ignore this definition.
m4_define([_AM_AUTOCONF_VERSION], [])
# AM_SET_CURRENT_AUTOMAKE_VERSION
# -------------------------------
# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
[AM_AUTOMAKE_VERSION([1.14.1])dnl
m4_ifndef([AC_AUTOCONF_VERSION],
[m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
_AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
# AM_AUX_DIR_EXPAND -*- Autoconf -*-
# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# For projects using AC_CONFIG_AUX_DIR([foo]), Autoconf sets
# $ac_aux_dir to '$srcdir/foo'. In other projects, it is set to
# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
#
# Of course, Automake must honor this variable whenever it calls a
# tool from the auxiliary directory. The problem is that $srcdir (and
# therefore $ac_aux_dir as well) can be either absolute or relative,
# depending on how configure is run. This is pretty annoying, since
# it makes $ac_aux_dir quite unusable in subdirectories: in the top
# source directory, any form will work fine, but in subdirectories a
# relative path needs to be adjusted first.
#
# $ac_aux_dir/missing
# fails when called from a subdirectory if $ac_aux_dir is relative
# $top_srcdir/$ac_aux_dir/missing
# fails if $ac_aux_dir is absolute,
# fails when called from a subdirectory in a VPATH build with
# a relative $ac_aux_dir
#
# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
# are both prefixed by $srcdir. In an in-source build this is usually
# harmless because $srcdir is '.', but things will broke when you
# start a VPATH build or use an absolute $srcdir.
#
# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
# iff we strip the leading $srcdir from $ac_aux_dir. That would be:
# am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*\(.*\)"`
# and then we would define $MISSING as
# MISSING="\${SHELL} $am_aux_dir/missing"
# This will work as long as MISSING is not called from configure, because
# unfortunately $(top_srcdir) has no meaning in configure.
# However there are other variables, like CC, which are often used in
# configure, and could therefore not use this "fixed" $ac_aux_dir.
#
# Another solution, used here, is to always expand $ac_aux_dir to an
# absolute PATH. The drawback is that using absolute paths prevent a
# configured tree to be moved without reconfiguration.
AC_DEFUN([AM_AUX_DIR_EXPAND],
[dnl Rely on autoconf to set up CDPATH properly.
AC_PREREQ([2.50])dnl
# expand $ac_aux_dir to an absolute path
am_aux_dir=`cd $ac_aux_dir && pwd`
])
# AM_CONDITIONAL -*- Autoconf -*-
# Copyright (C) 1997-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_CONDITIONAL(NAME, SHELL-CONDITION)
# -------------------------------------
# Define a conditional.
AC_DEFUN([AM_CONDITIONAL],
[AC_PREREQ([2.52])dnl
m4_if([$1], [TRUE], [AC_FATAL([$0: invalid condition: $1])],
[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
AC_SUBST([$1_TRUE])dnl
AC_SUBST([$1_FALSE])dnl
_AM_SUBST_NOTMAKE([$1_TRUE])dnl
_AM_SUBST_NOTMAKE([$1_FALSE])dnl
m4_define([_AM_COND_VALUE_$1], [$2])dnl
if $2; then
$1_TRUE=
$1_FALSE='#'
else
$1_TRUE='#'
$1_FALSE=
fi
AC_CONFIG_COMMANDS_PRE(
[if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
AC_MSG_ERROR([[conditional "$1" was never defined.
Usually this means the macro was only invoked conditionally.]])
fi])])
# Copyright (C) 1999-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
# written in clear, in which case automake, when reading aclocal.m4,
# will think it sees a *use*, and therefore will trigger all it's
# C support machinery. Also note that it means that autoscan, seeing
# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
# _AM_DEPENDENCIES(NAME)
# ----------------------
# See how the compiler implements dependency checking.
# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
# We try a few techniques and use that to set a single cache variable.
#
# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
# dependency, and given that the user is not expected to run this macro,
# just rely on AC_PROG_CC.
AC_DEFUN([_AM_DEPENDENCIES],
[AC_REQUIRE([AM_SET_DEPDIR])dnl
AC_REQUIRE([AM_OUTPUT_DEPENDENCY_COMMANDS])dnl
AC_REQUIRE([AM_MAKE_INCLUDE])dnl
AC_REQUIRE([AM_DEP_TRACK])dnl
m4_if([$1], [CC], [depcc="$CC" am_compiler_list=],
[$1], [CXX], [depcc="$CXX" am_compiler_list=],
[$1], [OBJC], [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
[$1], [OBJCXX], [depcc="$OBJCXX" am_compiler_list='gcc3 gcc'],
[$1], [UPC], [depcc="$UPC" am_compiler_list=],
[$1], [GCJ], [depcc="$GCJ" am_compiler_list='gcc3 gcc'],
[depcc="$$1" am_compiler_list=])
AC_CACHE_CHECK([dependency style of $depcc],
[am_cv_$1_dependencies_compiler_type],
[if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
# We make a subdir and do the tests there. Otherwise we can end up
# making bogus files that we don't know about and never remove. For
# instance it was reported that on HP-UX the gcc test will end up
# making a dummy file named 'D' -- because '-MD' means "put the output
# in D".
rm -rf conftest.dir
mkdir conftest.dir
# Copy depcomp to subdir because otherwise we won't find it if we're
# using a relative directory.
cp "$am_depcomp" conftest.dir
cd conftest.dir
# We will build objects and dependencies in a subdirectory because
# it helps to detect inapplicable dependency modes. For instance
# both Tru64's cc and ICC support -MD to output dependencies as a
# side effect of compilation, but ICC will put the dependencies in
# the current directory while Tru64 will put them in the object
# directory.
mkdir sub
am_cv_$1_dependencies_compiler_type=none
if test "$am_compiler_list" = ""; then
am_compiler_list=`sed -n ['s/^#*\([a-zA-Z0-9]*\))$/\1/p'] < ./depcomp`
fi
am__universal=false
m4_case([$1], [CC],
[case " $depcc " in #(
*\ -arch\ *\ -arch\ *) am__universal=true ;;
esac],
[CXX],
[case " $depcc " in #(
*\ -arch\ *\ -arch\ *) am__universal=true ;;
esac])
for depmode in $am_compiler_list; do
# Setup a source with many dependencies, because some compilers
# like to wrap large dependency lists on column 80 (with \), and
# we should not choose a depcomp mode which is confused by this.
#
# We need to recreate these files for each test, as the compiler may
# overwrite some of them when testing with obscure command lines.
# This happens at least with the AIX C compiler.
: > sub/conftest.c
for i in 1 2 3 4 5 6; do
echo '#include "conftst'$i'.h"' >> sub/conftest.c
# Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
# Solaris 10 /bin/sh.
echo '/* dummy */' > sub/conftst$i.h
done
echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
# We check with '-c' and '-o' for the sake of the "dashmstdout"
# mode. It turns out that the SunPro C++ compiler does not properly
# handle '-M -o', and we need to detect this. Also, some Intel
# versions had trouble with output in subdirs.
am__obj=sub/conftest.${OBJEXT-o}
am__minus_obj="-o $am__obj"
case $depmode in
gcc)
# This depmode causes a compiler race in universal mode.
test "$am__universal" = false || continue
;;
nosideeffect)
# After this tag, mechanisms are not by side-effect, so they'll
# only be used when explicitly requested.
if test "x$enable_dependency_tracking" = xyes; then
continue
else
break
fi
;;
msvc7 | msvc7msys | msvisualcpp | msvcmsys)
# This compiler won't grok '-c -o', but also, the minuso test has
# not run yet. These depmodes are late enough in the game, and
# so weak that their functioning should not be impacted.
am__obj=conftest.${OBJEXT-o}
am__minus_obj=
;;
none) break ;;
esac
if depmode=$depmode \
source=sub/conftest.c object=$am__obj \
depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
$SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
>/dev/null 2>conftest.err &&
grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
${MAKE-make} -s -f confmf > /dev/null 2>&1; then
# icc doesn't choke on unknown options, it will just issue warnings
# or remarks (even with -Werror). So we grep stderr for any message
# that says an option was ignored or not supported.
# When given -MP, icc 7.0 and 7.1 complain thusly:
# icc: Command line warning: ignoring option '-M'; no argument required
# The diagnosis changed in icc 8.0:
# icc: Command line remark: option '-MP' not supported
if (grep 'ignoring option' conftest.err ||
grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
am_cv_$1_dependencies_compiler_type=$depmode
break
fi
fi
done
cd ..
rm -rf conftest.dir
else
am_cv_$1_dependencies_compiler_type=none
fi
])
AC_SUBST([$1DEPMODE], [depmode=$am_cv_$1_dependencies_compiler_type])
AM_CONDITIONAL([am__fastdep$1], [
test "x$enable_dependency_tracking" != xno \
&& test "$am_cv_$1_dependencies_compiler_type" = gcc3])
])
# AM_SET_DEPDIR
# -------------
# Choose a directory name for dependency files.
# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
AC_DEFUN([AM_SET_DEPDIR],
[AC_REQUIRE([AM_SET_LEADING_DOT])dnl
AC_SUBST([DEPDIR], ["${am__leading_dot}deps"])dnl
])
# AM_DEP_TRACK
# ------------
AC_DEFUN([AM_DEP_TRACK],
[AC_ARG_ENABLE([dependency-tracking], [dnl
AS_HELP_STRING(
[--enable-dependency-tracking],
[do not reject slow dependency extractors])
AS_HELP_STRING(
[--disable-dependency-tracking],
[speeds up one-time build])])
if test "x$enable_dependency_tracking" != xno; then
am_depcomp="$ac_aux_dir/depcomp"
AMDEPBACKSLASH='\'
am__nodep='_no'
fi
AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
AC_SUBST([AMDEPBACKSLASH])dnl
_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
AC_SUBST([am__nodep])dnl
_AM_SUBST_NOTMAKE([am__nodep])dnl
])
# Generate code to set up dependency tracking. -*- Autoconf -*-
# Copyright (C) 1999-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# _AM_OUTPUT_DEPENDENCY_COMMANDS
# ------------------------------
AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
[{
# Older Autoconf quotes --file arguments for eval, but not when files
# are listed without --file. Let's play safe and only enable the eval
# if we detect the quoting.
case $CONFIG_FILES in
*\'*) eval set x "$CONFIG_FILES" ;;
*) set x $CONFIG_FILES ;;
esac
shift
for mf
do
# Strip MF so we end up with the name of the file.
mf=`echo "$mf" | sed -e 's/:.*$//'`
# Check whether this is an Automake generated Makefile or not.
# We used to match only the files named 'Makefile.in', but
# some people rename them; so instead we look at the file content.
# Grep'ing the first line is not enough: some people post-process
# each Makefile.in and add a new line on top of each file to say so.
# Grep'ing the whole file is not good either: AIX grep has a line
# limit of 2048, but all sed's we know have understand at least 4000.
if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
dirpart=`AS_DIRNAME("$mf")`
else
continue
fi
# Extract the definition of DEPDIR, am__include, and am__quote
# from the Makefile without running 'make'.
DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
test -z "$DEPDIR" && continue
am__include=`sed -n 's/^am__include = //p' < "$mf"`
test -z "$am__include" && continue
am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
# Find all dependency output files, they are included files with
# $(DEPDIR) in their names. We invoke sed twice because it is the
# simplest approach to changing $(DEPDIR) to its actual value in the
# expansion.
for file in `sed -n "
s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
# Make sure the directory exists.
test -f "$dirpart/$file" && continue
fdir=`AS_DIRNAME(["$file"])`
AS_MKDIR_P([$dirpart/$fdir])
# echo "creating $dirpart/$file"
echo '# dummy' > "$dirpart/$file"
done
done
}
])# _AM_OUTPUT_DEPENDENCY_COMMANDS
# AM_OUTPUT_DEPENDENCY_COMMANDS
# -----------------------------
# This macro should only be invoked once -- use via AC_REQUIRE.
#
# This code is only required when automatic dependency tracking
# is enabled. FIXME. This creates each '.P' file that we will
# need in order to bootstrap the dependency handling code.
AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
[AC_CONFIG_COMMANDS([depfiles],
[test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
[AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
])
# Do all the work for Automake. -*- Autoconf -*-
# Copyright (C) 1996-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This macro actually does too much. Some checks are only needed if
# your package does certain things. But this isn't really a big deal.
dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
m4_define([AC_PROG_CC],
m4_defn([AC_PROG_CC])
[_AM_PROG_CC_C_O
])
# AM_INIT_AUTOMAKE(PACKAGE, VERSION, [NO-DEFINE])
# AM_INIT_AUTOMAKE([OPTIONS])
# -----------------------------------------------
# The call with PACKAGE and VERSION arguments is the old style
# call (pre autoconf-2.50), which is being phased out. PACKAGE
# and VERSION should now be passed to AC_INIT and removed from
# the call to AM_INIT_AUTOMAKE.
# We support both call styles for the transition. After
# the next Automake release, Autoconf can make the AC_INIT
# arguments mandatory, and then we can depend on a new Autoconf
# release and drop the old call support.
AC_DEFUN([AM_INIT_AUTOMAKE],
[AC_PREREQ([2.65])dnl
dnl Autoconf wants to disallow AM_ names. We explicitly allow
dnl the ones we care about.
m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
AC_REQUIRE([AC_PROG_INSTALL])dnl
if test "`cd $srcdir && pwd`" != "`pwd`"; then
# Use -I$(srcdir) only when $(srcdir) != ., so that make's output
# is not polluted with repeated "-I."
AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
# test to see if srcdir already configured
if test -f $srcdir/config.status; then
AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
fi
fi
# test whether we have cygpath
if test -z "$CYGPATH_W"; then
if (cygpath --version) >/dev/null 2>/dev/null; then
CYGPATH_W='cygpath -w'
else
CYGPATH_W=echo
fi
fi
AC_SUBST([CYGPATH_W])
# Define the identity of the package.
dnl Distinguish between old-style and new-style calls.
m4_ifval([$2],
[AC_DIAGNOSE([obsolete],
[$0: two- and three-arguments forms are deprecated.])
m4_ifval([$3], [_AM_SET_OPTION([no-define])])dnl
AC_SUBST([PACKAGE], [$1])dnl
AC_SUBST([VERSION], [$2])],
[_AM_SET_OPTIONS([$1])dnl
dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
m4_if(
m4_ifdef([AC_PACKAGE_NAME], [ok]):m4_ifdef([AC_PACKAGE_VERSION], [ok]),
[ok:ok],,
[m4_fatal([AC_INIT should be called with package and version arguments])])dnl
AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
_AM_IF_OPTION([no-define],,
[AC_DEFINE_UNQUOTED([PACKAGE], ["$PACKAGE"], [Name of package])
AC_DEFINE_UNQUOTED([VERSION], ["$VERSION"], [Version number of package])])dnl
# Some tools Automake needs.
AC_REQUIRE([AM_SANITY_CHECK])dnl
AC_REQUIRE([AC_ARG_PROGRAM])dnl
AM_MISSING_PROG([ACLOCAL], [aclocal-${am__api_version}])
AM_MISSING_PROG([AUTOCONF], [autoconf])
AM_MISSING_PROG([AUTOMAKE], [automake-${am__api_version}])
AM_MISSING_PROG([AUTOHEADER], [autoheader])
AM_MISSING_PROG([MAKEINFO], [makeinfo])
AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
AC_REQUIRE([AC_PROG_MKDIR_P])dnl
# For better backward compatibility. To be removed once Automake 1.9.x
# dies out for good. For more background, see:
#
#
AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
# We need awk for the "check" target. The system "awk" is bad on
# some platforms.
AC_REQUIRE([AC_PROG_AWK])dnl
AC_REQUIRE([AC_PROG_MAKE_SET])dnl
AC_REQUIRE([AM_SET_LEADING_DOT])dnl
_AM_IF_OPTION([tar-ustar], [_AM_PROG_TAR([ustar])],
[_AM_IF_OPTION([tar-pax], [_AM_PROG_TAR([pax])],
[_AM_PROG_TAR([v7])])])
_AM_IF_OPTION([no-dependencies],,
[AC_PROVIDE_IFELSE([AC_PROG_CC],
[_AM_DEPENDENCIES([CC])],
[m4_define([AC_PROG_CC],
m4_defn([AC_PROG_CC])[_AM_DEPENDENCIES([CC])])])dnl
AC_PROVIDE_IFELSE([AC_PROG_CXX],
[_AM_DEPENDENCIES([CXX])],
[m4_define([AC_PROG_CXX],
m4_defn([AC_PROG_CXX])[_AM_DEPENDENCIES([CXX])])])dnl
AC_PROVIDE_IFELSE([AC_PROG_OBJC],
[_AM_DEPENDENCIES([OBJC])],
[m4_define([AC_PROG_OBJC],
m4_defn([AC_PROG_OBJC])[_AM_DEPENDENCIES([OBJC])])])dnl
AC_PROVIDE_IFELSE([AC_PROG_OBJCXX],
[_AM_DEPENDENCIES([OBJCXX])],
[m4_define([AC_PROG_OBJCXX],
m4_defn([AC_PROG_OBJCXX])[_AM_DEPENDENCIES([OBJCXX])])])dnl
])
AC_REQUIRE([AM_SILENT_RULES])dnl
dnl The testsuite driver may need to know about EXEEXT, so add the
dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen. This
dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
AC_CONFIG_COMMANDS_PRE(dnl
[m4_provide_if([_AM_COMPILER_EXEEXT],
[AM_CONDITIONAL([am__EXEEXT], [test -n "$EXEEXT"])])])dnl
# POSIX will say in a future version that running "rm -f" with no argument
# is OK; and we want to be able to make that assumption in our Makefile
# recipes. So use an aggressive probe to check that the usage we want is
# actually supported "in the wild" to an acceptable degree.
# See automake bug#10828.
# To make any issue more visible, cause the running configure to be aborted
# by default if the 'rm' program in use doesn't match our expectations; the
# user can still override this though.
if rm -f && rm -fr && rm -rf; then : OK; else
cat >&2 <<'END'
Oops!
Your 'rm' program seems unable to run without file operands specified
on the command line, even when the '-f' option is present. This is contrary
to the behaviour of most rm programs out there, and not conforming with
the upcoming POSIX standard:
Please tell bug-automake@gnu.org about your system, including the value
of your $PATH and any error possibly output before this message. This
can help us improve future automake versions.
END
if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
echo 'Configuration will proceed anyway, since you have set the' >&2
echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
echo >&2
else
cat >&2 <<'END'
Aborting the configuration process, to ensure you take notice of the issue.
You can download and install GNU coreutils to get an 'rm' implementation
that behaves properly: .
If you want to complete the configuration process using your problematic
'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
to "yes", and re-run configure.
END
AC_MSG_ERROR([Your 'rm' program is bad, sorry.])
fi
fi])
dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion. Do not
dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
dnl mangled by Autoconf and run in a shell conditional statement.
m4_define([_AC_COMPILER_EXEEXT],
m4_defn([_AC_COMPILER_EXEEXT])[m4_provide([_AM_COMPILER_EXEEXT])])
# When config.status generates a header, we must update the stamp-h file.
# This file resides in the same directory as the config header
# that is generated. The stamp files are numbered to have different names.
# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
# loop where config.status creates the headers, so we can generate
# our stamp files there.
AC_DEFUN([_AC_AM_CONFIG_HEADER_HOOK],
[# Compute $1's index in $config_headers.
_am_arg=$1
_am_stamp_count=1
for _am_header in $config_headers :; do
case $_am_header in
$_am_arg | $_am_arg:* )
break ;;
* )
_am_stamp_count=`expr $_am_stamp_count + 1` ;;
esac
done
echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_PROG_INSTALL_SH
# ------------------
# Define $install_sh.
AC_DEFUN([AM_PROG_INSTALL_SH],
[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
if test x"${install_sh}" != xset; then
case $am_aux_dir in
*\ * | *\ *)
install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
*)
install_sh="\${SHELL} $am_aux_dir/install-sh"
esac
fi
AC_SUBST([install_sh])])
# Copyright (C) 2003-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# Check whether the underlying file-system supports filenames
# with a leading dot. For instance MS-DOS doesn't.
AC_DEFUN([AM_SET_LEADING_DOT],
[rm -rf .tst 2>/dev/null
mkdir .tst 2>/dev/null
if test -d .tst; then
am__leading_dot=.
else
am__leading_dot=_
fi
rmdir .tst 2>/dev/null
AC_SUBST([am__leading_dot])])
# Check to see how 'make' treats includes. -*- Autoconf -*-
# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_MAKE_INCLUDE()
# -----------------
# Check to see how make treats includes.
AC_DEFUN([AM_MAKE_INCLUDE],
[am_make=${MAKE-make}
cat > confinc << 'END'
am__doit:
@echo this is the am__doit target
.PHONY: am__doit
END
# If we don't find an include directive, just comment out the code.
AC_MSG_CHECKING([for style of include used by $am_make])
am__include="#"
am__quote=
_am_result=none
# First try GNU make style include.
echo "include confinc" > confmf
# Ignore all kinds of additional output from 'make'.
case `$am_make -s -f confmf 2> /dev/null` in #(
*the\ am__doit\ target*)
am__include=include
am__quote=
_am_result=GNU
;;
esac
# Now try BSD make style include.
if test "$am__include" = "#"; then
echo '.include "confinc"' > confmf
case `$am_make -s -f confmf 2> /dev/null` in #(
*the\ am__doit\ target*)
am__include=.include
am__quote="\""
_am_result=BSD
;;
esac
fi
AC_SUBST([am__include])
AC_SUBST([am__quote])
AC_MSG_RESULT([$_am_result])
rm -f confinc confmf
])
# Fake the existence of programs that GNU maintainers use. -*- Autoconf -*-
# Copyright (C) 1997-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_MISSING_PROG(NAME, PROGRAM)
# ------------------------------
AC_DEFUN([AM_MISSING_PROG],
[AC_REQUIRE([AM_MISSING_HAS_RUN])
$1=${$1-"${am_missing_run}$2"}
AC_SUBST($1)])
# AM_MISSING_HAS_RUN
# ------------------
# Define MISSING if not defined so far and test if it is modern enough.
# If it is, set am_missing_run to use it, otherwise, to nothing.
AC_DEFUN([AM_MISSING_HAS_RUN],
[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
AC_REQUIRE_AUX_FILE([missing])dnl
if test x"${MISSING+set}" != xset; then
case $am_aux_dir in
*\ * | *\ *)
MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
*)
MISSING="\${SHELL} $am_aux_dir/missing" ;;
esac
fi
# Use eval to expand $SHELL
if eval "$MISSING --is-lightweight"; then
am_missing_run="$MISSING "
else
am_missing_run=
AC_MSG_WARN(['missing' script is too old or missing])
fi
])
# Helper functions for option handling. -*- Autoconf -*-
# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# _AM_MANGLE_OPTION(NAME)
# -----------------------
AC_DEFUN([_AM_MANGLE_OPTION],
[[_AM_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
# _AM_SET_OPTION(NAME)
# --------------------
# Set option NAME. Presently that only means defining a flag for this option.
AC_DEFUN([_AM_SET_OPTION],
[m4_define(_AM_MANGLE_OPTION([$1]), [1])])
# _AM_SET_OPTIONS(OPTIONS)
# ------------------------
# OPTIONS is a space-separated list of Automake options.
AC_DEFUN([_AM_SET_OPTIONS],
[m4_foreach_w([_AM_Option], [$1], [_AM_SET_OPTION(_AM_Option)])])
# _AM_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
# -------------------------------------------
# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
AC_DEFUN([_AM_IF_OPTION],
[m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
# Copyright (C) 1999-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# _AM_PROG_CC_C_O
# ---------------
# Like AC_PROG_CC_C_O, but changed for automake. We rewrite AC_PROG_CC
# to automatically call this.
AC_DEFUN([_AM_PROG_CC_C_O],
[AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
AC_REQUIRE_AUX_FILE([compile])dnl
AC_LANG_PUSH([C])dnl
AC_CACHE_CHECK(
[whether $CC understands -c and -o together],
[am_cv_prog_cc_c_o],
[AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
# Make sure it works both with $CC and with simple cc.
# Following AC_PROG_CC_C_O, we do the test twice because some
# compilers refuse to overwrite an existing .o file with -o,
# though they will create one.
am_cv_prog_cc_c_o=yes
for am_i in 1 2; do
if AM_RUN_LOG([$CC -c conftest.$ac_ext -o conftest2.$ac_objext]) \
&& test -f conftest2.$ac_objext; then
: OK
else
am_cv_prog_cc_c_o=no
break
fi
done
rm -f core conftest*
unset am_i])
if test "$am_cv_prog_cc_c_o" != yes; then
# Losing compiler, so override with the script.
# FIXME: It is wrong to rewrite CC.
# But if we don't then we get into trouble of one sort or another.
# A longer-term fix would be to have automake use am__CC in this case,
# and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
CC="$am_aux_dir/compile $CC"
fi
AC_LANG_POP([C])])
# For backward compatibility.
AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_RUN_LOG(COMMAND)
# -------------------
# Run COMMAND, save the exit status in ac_status, and log it.
# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
AC_DEFUN([AM_RUN_LOG],
[{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
ac_status=$?
echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
(exit $ac_status); }])
# Check to make sure that the build environment is sane. -*- Autoconf -*-
# Copyright (C) 1996-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_SANITY_CHECK
# ---------------
AC_DEFUN([AM_SANITY_CHECK],
[AC_MSG_CHECKING([whether build environment is sane])
# Reject unsafe characters in $srcdir or the absolute working directory
# name. Accept space and tab only in the latter.
am_lf='
'
case `pwd` in
*[[\\\"\#\$\&\'\`$am_lf]]*)
AC_MSG_ERROR([unsafe absolute working directory name]);;
esac
case $srcdir in
*[[\\\"\#\$\&\'\`$am_lf\ \ ]]*)
AC_MSG_ERROR([unsafe srcdir value: '$srcdir']);;
esac
# Do 'set' in a subshell so we don't clobber the current shell's
# arguments. Must try -L first in case configure is actually a
# symlink; some systems play weird games with the mod time of symlinks
# (eg FreeBSD returns the mod time of the symlink's containing
# directory).
if (
am_has_slept=no
for am_try in 1 2; do
echo "timestamp, slept: $am_has_slept" > conftest.file
set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
if test "$[*]" = "X"; then
# -L didn't work.
set X `ls -t "$srcdir/configure" conftest.file`
fi
if test "$[*]" != "X $srcdir/configure conftest.file" \
&& test "$[*]" != "X conftest.file $srcdir/configure"; then
# If neither matched, then we have a broken ls. This can happen
# if, for instance, CONFIG_SHELL is bash and it inherits a
# broken ls alias from the environment. This has actually
# happened. Such a system could not be considered "sane".
AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken
alias in your environment])
fi
if test "$[2]" = conftest.file || test $am_try -eq 2; then
break
fi
# Just in case.
sleep 1
am_has_slept=yes
done
test "$[2]" = conftest.file
)
then
# Ok.
:
else
AC_MSG_ERROR([newly created file is older than distributed files!
Check your system clock])
fi
AC_MSG_RESULT([yes])
# If we didn't sleep, we still need to ensure time stamps of config.status and
# generated files are strictly newer.
am_sleep_pid=
if grep 'slept: no' conftest.file >/dev/null 2>&1; then
( sleep 1 ) &
am_sleep_pid=$!
fi
AC_CONFIG_COMMANDS_PRE(
[AC_MSG_CHECKING([that generated files are newer than configure])
if test -n "$am_sleep_pid"; then
# Hide warnings about reused PIDs.
wait $am_sleep_pid 2>/dev/null
fi
AC_MSG_RESULT([done])])
rm -f conftest.file
])
# Copyright (C) 2009-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_SILENT_RULES([DEFAULT])
# --------------------------
# Enable less verbose build rules; with the default set to DEFAULT
# ("yes" being less verbose, "no" or empty being verbose).
AC_DEFUN([AM_SILENT_RULES],
[AC_ARG_ENABLE([silent-rules], [dnl
AS_HELP_STRING(
[--enable-silent-rules],
[less verbose build output (undo: "make V=1")])
AS_HELP_STRING(
[--disable-silent-rules],
[verbose build output (undo: "make V=0")])dnl
])
case $enable_silent_rules in @%:@ (((
yes) AM_DEFAULT_VERBOSITY=0;;
no) AM_DEFAULT_VERBOSITY=1;;
*) AM_DEFAULT_VERBOSITY=m4_if([$1], [yes], [0], [1]);;
esac
dnl
dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
dnl do not support nested variable expansions.
dnl See automake bug#9928 and bug#10237.
am_make=${MAKE-make}
AC_CACHE_CHECK([whether $am_make supports nested variables],
[am_cv_make_support_nested_variables],
[if AS_ECHO([['TRUE=$(BAR$(V))
BAR0=false
BAR1=true
V=1
am__doit:
@$(TRUE)
.PHONY: am__doit']]) | $am_make -f - >/dev/null 2>&1; then
am_cv_make_support_nested_variables=yes
else
am_cv_make_support_nested_variables=no
fi])
if test $am_cv_make_support_nested_variables = yes; then
dnl Using '$V' instead of '$(V)' breaks IRIX make.
AM_V='$(V)'
AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
else
AM_V=$AM_DEFAULT_VERBOSITY
AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
fi
AC_SUBST([AM_V])dnl
AM_SUBST_NOTMAKE([AM_V])dnl
AC_SUBST([AM_DEFAULT_V])dnl
AM_SUBST_NOTMAKE([AM_DEFAULT_V])dnl
AC_SUBST([AM_DEFAULT_VERBOSITY])dnl
AM_BACKSLASH='\'
AC_SUBST([AM_BACKSLASH])dnl
_AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
])
# Copyright (C) 2001-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# AM_PROG_INSTALL_STRIP
# ---------------------
# One issue with vendor 'install' (even GNU) is that you can't
# specify the program used to strip binaries. This is especially
# annoying in cross-compiling environments, where the build's strip
# is unlikely to handle the host's binaries.
# Fortunately install-sh will honor a STRIPPROG variable, so we
# always use install-sh in "make install-strip", and initialize
# STRIPPROG with the value of the STRIP variable (set by the user).
AC_DEFUN([AM_PROG_INSTALL_STRIP],
[AC_REQUIRE([AM_PROG_INSTALL_SH])dnl
# Installed binaries are usually stripped using 'strip' when the user
# run "make install-strip". However 'strip' might not be the right
# tool to use in cross-compilation environments, therefore Automake
# will honor the 'STRIP' environment variable to overrule this program.
dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
if test "$cross_compiling" != no; then
AC_CHECK_TOOL([STRIP], [strip], :)
fi
INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
AC_SUBST([INSTALL_STRIP_PROGRAM])])
# Copyright (C) 2006-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# _AM_SUBST_NOTMAKE(VARIABLE)
# ---------------------------
# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
# This macro is traced by Automake.
AC_DEFUN([_AM_SUBST_NOTMAKE])
# AM_SUBST_NOTMAKE(VARIABLE)
# --------------------------
# Public sister of _AM_SUBST_NOTMAKE.
AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
# Check how to create a tarball. -*- Autoconf -*-
# Copyright (C) 2004-2013 Free Software Foundation, Inc.
#
# This file is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# _AM_PROG_TAR(FORMAT)
# --------------------
# Check how to create a tarball in format FORMAT.
# FORMAT should be one of 'v7', 'ustar', or 'pax'.
#
# Substitute a variable $(am__tar) that is a command
# writing to stdout a FORMAT-tarball containing the directory
# $tardir.
# tardir=directory && $(am__tar) > result.tar
#
# Substitute a variable $(am__untar) that extract such
# a tarball read from stdin.
# $(am__untar) < result.tar
#
AC_DEFUN([_AM_PROG_TAR],
[# Always define AMTAR for backward compatibility. Yes, it's still used
# in the wild :-( We should find a proper way to deprecate it ...
AC_SUBST([AMTAR], ['$${TAR-tar}'])
# We'll loop over all known methods to create a tar archive until one works.
_am_tools='gnutar m4_if([$1], [ustar], [plaintar]) pax cpio none'
m4_if([$1], [v7],
[am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'],
[m4_case([$1],
[ustar],
[# The POSIX 1988 'ustar' format is defined with fixed-size fields.
# There is notably a 21 bits limit for the UID and the GID. In fact,
# the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
# and bug#13588).
am_max_uid=2097151 # 2^21 - 1
am_max_gid=$am_max_uid
# The $UID and $GID variables are not portable, so we need to resort
# to the POSIX-mandated id(1) utility. Errors in the 'id' calls
# below are definitely unexpected, so allow the users to see them
# (that is, avoid stderr redirection).
am_uid=`id -u || echo unknown`
am_gid=`id -g || echo unknown`
AC_MSG_CHECKING([whether UID '$am_uid' is supported by ustar format])
if test $am_uid -le $am_max_uid; then
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
_am_tools=none
fi
AC_MSG_CHECKING([whether GID '$am_gid' is supported by ustar format])
if test $am_gid -le $am_max_gid; then
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
_am_tools=none
fi],
[pax],
[],
[m4_fatal([Unknown tar format])])
AC_MSG_CHECKING([how to create a $1 tar archive])
# Go ahead even if we have the value already cached. We do so because we
# need to set the values for the 'am__tar' and 'am__untar' variables.
_am_tools=${am_cv_prog_tar_$1-$_am_tools}
for _am_tool in $_am_tools; do
case $_am_tool in
gnutar)
for _am_tar in tar gnutar gtar; do
AM_RUN_LOG([$_am_tar --version]) && break
done
am__tar="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$$tardir"'
am__tar_="$_am_tar --format=m4_if([$1], [pax], [posix], [$1]) -chf - "'"$tardir"'
am__untar="$_am_tar -xf -"
;;
plaintar)
# Must skip GNU tar: if it does not support --format= it doesn't create
# ustar tarball either.
(tar --version) >/dev/null 2>&1 && continue
am__tar='tar chf - "$$tardir"'
am__tar_='tar chf - "$tardir"'
am__untar='tar xf -'
;;
pax)
am__tar='pax -L -x $1 -w "$$tardir"'
am__tar_='pax -L -x $1 -w "$tardir"'
am__untar='pax -r'
;;
cpio)
am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
am__untar='cpio -i -H $1 -d'
;;
none)
am__tar=false
am__tar_=false
am__untar=false
;;
esac
# If the value was cached, stop now. We just wanted to have am__tar
# and am__untar set.
test -n "${am_cv_prog_tar_$1}" && break
# tar/untar a dummy directory, and stop if the command works.
rm -rf conftest.dir
mkdir conftest.dir
echo GrepMe > conftest.dir/file
AM_RUN_LOG([tardir=conftest.dir && eval $am__tar_ >conftest.tar])
rm -rf conftest.dir
if test -s conftest.tar; then
AM_RUN_LOG([$am__untar /dev/null 2>&1 && break
fi
done
rm -rf conftest.dir
AC_CACHE_VAL([am_cv_prog_tar_$1], [am_cv_prog_tar_$1=$_am_tool])
AC_MSG_RESULT([$am_cv_prog_tar_$1])])
AC_SUBST([am__tar])
AC_SUBST([am__untar])
]) # _AM_PROG_TAR
rlwrap-0.42/config.h.in 0000644 0001751 0000144 00000016363 12431353251 011717 0000000 0000000 /* config.h.in. Generated from configure.ac by autoheader. */
/* Define to 1 to get debugging info */
#undef DEBUG
/* Define if overwriting argv changes args visible in ps (1) */
#undef ENABLE_MIRROR_ARGS
/* Define if your getopt() correctly understands double colons in the option
string */
#undef GETOPT_GROKS_OPTIONAL_ARGS
/* Define to 1 if you have the header file. */
#undef HAVE_CURSES_H
/* Define to 1 if you have the header file. */
#undef HAVE_ERRNO_H
/* Define to 1 if you have the header file. */
#undef HAVE_FCNTL_H
/* Define to 1 if you have the header file. */
#undef HAVE_GETOPT_H
/* Define to 1 if you have the `getopt_long' function. */
#undef HAVE_GETOPT_LONG
/* Define if you have _GNU_SOURCE getpt() */
#undef HAVE_GETPT
/* Define to 1 if you have the `getpty' function. */
#undef HAVE_GETPTY
/* Define to 1 if you have the `grantpt' function. */
#undef HAVE_GRANTPT
/* Define to 1 if you have the header file. */
#undef HAVE_INTTYPES_H
/* Define to 1 if you have the `isastream' function. */
#undef HAVE_ISASTREAM
/* Define to 1 if you have the `util' library (-lutil). */
#undef HAVE_LIBUTIL
/* Define to 1 if you have the header file. */
#undef HAVE_LIBUTIL_H
/* Define to 1 if you have the header file. */
#undef HAVE_MEMORY_H
/* Define to 1 if you have the `mkstemps' function. */
#undef HAVE_MKSTEMPS
/* Define to 1 if you have the header file. */
#undef HAVE_NCURSES_TERM_H
/* Define to 1 if you have the `openpty' function. */
#undef HAVE_OPENPTY
/* Define to 1 if //cwd is a link to working
directory of process */
#undef HAVE_PROC_PID_CWD
/* Define to 1 if you have the `pselect' function. */
#undef HAVE_PSELECT
/* Define to 1 if you have the header file. */
#undef HAVE_PTY_H
/* Define to 1 if you have the `putenv' function. */
#undef HAVE_PUTENV
/* Define to 1 if you have the `readlink' function. */
#undef HAVE_READLINK
/* Define to 1 if you have the header file. */
#undef HAVE_REGEX_H
/* Define to 1 if your readline lib has rl_readline_version */
#undef HAVE_RL_READLINE_VERSION
/* Define to 1 if your readline lib has rl_variable_value() */
#undef HAVE_RL_VARIABLE_VALUE
/* Define to 1 if you have the header file. */
#undef HAVE_SCHED_H
/* Define to 1 if you have the `sched_yield' function. */
#undef HAVE_SCHED_YIELD
/* Define to 1 if you have the `setenv' function. */
#undef HAVE_SETENV
/* Define to 1 if you have the `setitimer' function. */
#undef HAVE_SETITIMER
/* Define to 1 if you have the `setrlimit' function. */
#undef HAVE_SETRLIMIT
/* Define to 1 if you have the `setsid' function. */
#undef HAVE_SETSID
/* Define to 1 if you have the `sigaction' function. */
#undef HAVE_SIGACTION
/* Define to 1 if you have the `snprintf' function. */
#undef HAVE_SNPRINTF
/* Define to 1 if you have the header file. */
#undef HAVE_STDDEF_H
/* Define to 1 if you have the header file. */
#undef HAVE_STDINT_H
/* Define to 1 if you have the header file. */
#undef HAVE_STDLIB_H
/* Define to 1 if you have the header file. */
#undef HAVE_STRINGS_H
/* Define to 1 if you have the header file. */
#undef HAVE_STRING_H
/* Define to 1 if you have the `strlcat' function. */
#undef HAVE_STRLCAT
/* Define to 1 if you have the `strlcpy' function. */
#undef HAVE_STRLCPY
/* Define to 1 if you have the `strnlen' function. */
#undef HAVE_STRNLEN
/* Define to 1 if you have the `system' function. */
#undef HAVE_SYSTEM
/* Define to 1 if you have the header file. */
#undef HAVE_SYS_IOCTL_H
/* Define to 1 if you have the header file. */
#undef HAVE_SYS_RESOURCE_H
/* Define to 1 if you have the header file. */
#undef HAVE_SYS_STAT_H
/* Define to 1 if you have the header file. */
#undef HAVE_SYS_TYPES_H
/* Define to 1 if you have the header file. */
#undef HAVE_SYS_WAIT_H
/* Define to 1 if you have the header file. */
#undef HAVE_TERMCAP_H
/* Define to 1 if you have the header file. */
#undef HAVE_TERMIOS_H
/* Define to 1 if you have the header file. */
#undef HAVE_TERM_H
/* Define to 1 if you have the `tigetnum' function. */
#undef HAVE_TIGETNUM
/* Define to 1 if you have the header file. */
#undef HAVE_TIME_H
/* Define to 1 if you have the header file. */
#undef HAVE_UNISTD_H
/* Define to 1 if you have the `unlockpt' function. */
#undef HAVE_UNLOCKPT
/* Define to 1 to use homegrown_redisplay() */
#undef HOMEGROWN_REDISPLAY
/* Name of package */
#undef PACKAGE
/* Define to the address where bug reports for this package should be sent. */
#undef PACKAGE_BUGREPORT
/* Define to the full name of this package. */
#undef PACKAGE_NAME
/* Define to the full name and version of this package. */
#undef PACKAGE_STRING
/* Define to the one symbol short name of this package. */
#undef PACKAGE_TARNAME
/* Define to the home page for this package. */
#undef PACKAGE_URL
/* Define to the version of this package. */
#undef PACKAGE_VERSION
/* Define to location of Linux-style procfs mountpoint if provided and valid
*/
#undef PROC_MOUNTPOINT
/* Define for first char in devptyXX */
#undef PTYCHAR1
/* Define for second char in devptyXX */
#undef PTYCHAR2
/* Define for this pty type */
#undef PTYS_ARE_CLONE
/* Define for this pty type */
#undef PTYS_ARE_GETPT
/* Define for this pty type */
#undef PTYS_ARE_GETPTY
/* Define for this pty type */
#undef PTYS_ARE_NUMERIC
/* Define for this pty type */
#undef PTYS_ARE_OPENPTY
/* Define for this pty type */
#undef PTYS_ARE_PTC
/* Define for this pty type */
#undef PTYS_ARE_PTMX
/* Define for this pty type */
#undef PTYS_ARE_SEARCHED
/* Define for this pty type */
#undef PTYS_ARE__GETPTY
/* nonsense arg to overwrite conftest argv with */
#undef RANDOM_NONSENSE2
/* Define as the return type of signal handlers (`int' or `void'). */
#undef RETSIGTYPE
/* Define to 1 to use private _rl_horizontal_scroll_mode */
#undef SPY_ON_READLINE
/* Define to 1 if you have the ANSI C header files. */
#undef STDC_HEADERS
/* Define to 1 if you can safely include both and . */
#undef TIME_WITH_SYS_TIME
/* Define as the type for the argument to the putc function of tputs ('int' or
'char') */
#undef TPUTS_PUTC_ARGTYPE
/* Enable extensions on AIX 3, Interix. */
#ifndef _ALL_SOURCE
# undef _ALL_SOURCE
#endif
/* Enable GNU extensions on systems that have them. */
#ifndef _GNU_SOURCE
# undef _GNU_SOURCE
#endif
/* Enable threading extensions on Solaris. */
#ifndef _POSIX_PTHREAD_SEMANTICS
# undef _POSIX_PTHREAD_SEMANTICS
#endif
/* Enable extensions on HP NonStop. */
#ifndef _TANDEM_SOURCE
# undef _TANDEM_SOURCE
#endif
/* Enable general extensions on Solaris. */
#ifndef __EXTENSIONS__
# undef __EXTENSIONS__
#endif
/* Version number of package */
#undef VERSION
/* Define to 1 if on MINIX. */
#undef _MINIX
/* Define to 2 if the system does not provide POSIX.1 features except with
this defined. */
#undef _POSIX_1_SOURCE
/* Define to 1 if you need to in order for `stat' and other things to work. */
#undef _POSIX_SOURCE
/* Define to empty if `const' does not conform to ANSI C. */
#undef const
/* Define to `int' if does not define. */
#undef pid_t
rlwrap-0.42/configure.ac 0000644 0001751 0000144 00000033776 12431350137 012171 0000000 0000000 dnl configuration script for rlwrap
dnl Process this file with autoconf to produce configure.
dnl
dnl Copyright (C) 2000-2007 Hans Lub hlub@knoware.nl
dnl
dnl This file is part of rlwrap
dnl
dnl rlwrap is free software; you can redistribute it and/or modify it
dnl under the terms of the GNU General Public License as published by
dnl the Free Software Foundation; either version 2, or (at your
dnl option) any later version.
dnl
dnl rlwrap is distributed in the hope that it will be useful, but
dnl WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
dnl General Public License for more details.
dnl
dnl You should have received a copy of the GNU General Public License
dnl along with GUILE; see the file COPYING. If not, write to the
dnl Free Software Foundation, Inc., 59 Temple Place - Suite 330,
dnl Boston, MA 02111-1307, USA.
AC_INIT(rlwrap,0.42)
AC_PREREQ(2.61)
AC_CONFIG_AUX_DIR(tools)
AC_CANONICAL_HOST
AC_CONFIG_SRCDIR(src/main.c)
AM_INIT_AUTOMAKE
AC_PROG_INSTALL
AC_CONFIG_HEADERS([config.h])
AC_PROG_MAKE_SET
AM_SANITY_CHECK
# option parsing for optional features
opt_debug=no
opt_homegrown_redisplay=no
opt_spy_on_readline=yes
opt_proc_mountpoint=/proc
AC_ARG_ENABLE(debug,
AC_HELP_STRING([--enable-debug], [enable debugging [[default=NO]]]),
opt_debug=$enableval)
AC_ARG_ENABLE(homegrown-redisplay,
AC_HELP_STRING([--enable-homegrown-redisplay], [try this only if rlwrap messes up the prompt [[default=NO]]]),
opt_homegrown_redisplay=$enableval)
AC_ARG_ENABLE(spy-on-readline,
AC_HELP_STRING([--enable-spy-on-readline [[default=YES]]],
[use private readline variable to keep screen tidy when resizing terminal [[default=YES]]]),
opt_spy_on_readline=$enableval)
AC_ARG_ENABLE(proc-mountpoint,
AC_HELP_STRING([--enable-proc-mountpoint [[default=/proc]]],
[specify mountpoint for Linux-style procfs (used for determination of command's PWD) [[default=/proc]]]), # '
opt_proc_mountpoint=$enableval)
if test $opt_debug = yes; then
AC_DEFINE(DEBUG,1 ,Define to 1 to get debugging info)
test -z "$CFLAGS" || AC_MSG_WARN([Because CFLAGS is set, configure will not add -g and -Wall to them - do it yourself if necessary])
test -z "$CFLAGS" && AC_SUBST(CFLAGS,"-O0 -g -Wimplicit-function-declaration -Wimplicit -pedantic -Wall") # compile for debugging, and give plenty of warnings
fi
AC_USE_SYSTEM_EXTENSIONS
test $opt_homegrown_redisplay = yes && AC_DEFINE(HOMEGROWN_REDISPLAY,1 ,[Define to 1 to use homegrown_redisplay()])
test $opt_spy_on_readline = yes && AC_DEFINE(SPY_ON_READLINE,1 ,Define to 1 to use private _rl_horizontal_scroll_mode)
AC_CONFIG_FILES([Makefile filters/Makefile doc/Makefile src/Makefile doc/rlwrap.man])
# Checks for programs.
AC_PROG_CC
AC_PROG_CPP
AC_PATH_PROG(PERL,perl)
AC_CHECK_PROG(STRIP,strip,strip,true)
# Checks for header files.
AC_HEADER_STDC
AC_HEADER_SYS_WAIT
AC_CHECK_HEADERS([errno.h fcntl.h libutil.h stdlib.h string.h sched.h sys/ioctl.h sys/wait.h sys/resource.h stddef.h ])
AC_CHECK_HEADERS([termios.h unistd.h stdint.h time.h getopt.h regex.h curses.h termcap.h ])
AC_CHECK_HEADERS([ term.h ncurses/term.h], , ,
[#ifdef HAVE_CURSES_H
#include
#endif])
# Found this in configure.ac for 'top':
# The third argument to tputs is a putc-like function that takes an
# argument. On most systems that argument is an int, but on some (you
# know who you are, Solaris!) it is a char. Determine which:
_savedwerror_flag=$ac_c_werror_flag
ac_c_werror_flag=yes # make $CC fail after warning
AC_MSG_CHECKING([argument type of tputs putc function])
AC_COMPILE_IFELSE( [AC_LANG_PROGRAM(
[ #ifdef HAVE_CURSES_H
# include
# ifdef HAVE_TERM_H
# include
# else
# ifdef HAVE_NCURSES_TERM_H /* cygwin? AIX? */
# include
# endif
# endif
#else
# ifdef HAVE_TERMCAP_H
# include
# endif
#endif
int f(char i) { }],
[tputs("a", 1, f);])],
[ac_cv_type_tputs_putc="char"],
[ac_cv_type_tputs_putc="int"])
AC_MSG_RESULT($ac_cv_type_tputs_putc)
AC_DEFINE_UNQUOTED(TPUTS_PUTC_ARGTYPE, $ac_cv_type_tputs_putc,
[Define as the type for the argument to the putc function of tputs ('int' or 'char')])
ac_c_werror_flag=$_savedwerror_flag
AC_MSG_CHECKING([whether your getopt() correctly understands double colons in option string])
AC_RUN_IFELSE(
[AC_LANG_PROGRAM( [[ const char optstring[] = "+:a::b";
char * myargv [] = {"progname", "-a", "-b"};
int myargc = 3;
extern char *optarg;
]] , [[
int opt = getopt(myargc, myargv, optstring);
if (opt != 'a' || optarg) /* optarg != NULL means that -b is seen as argument of -a */
exit (-1);
else
exit(0); ]] )],
[AC_DEFINE(GETOPT_GROKS_OPTIONAL_ARGS, 1, Define if your getopt() correctly understands double colons in the option string)
AC_SUBST(HAVE_OPTIONAL_ARGS,yes)
ac_double_colons="yes"],
[AC_SUBST(HAVE_OPTIONAL_ARGS,no)
ac_double_colons="no"],
[echo
AC_MSG_WARN([This test doens't work when cross-compiling. Edit GETOPT_GROKS_OPTIONAL_ARGS in config.h by hand])])
AC_MSG_RESULT($ac_double_colons)
# Checks for typedefs, structures, and compiler characteristics.
AC_C_CONST
AC_TYPE_PID_T
AC_HEADER_TIME
# Checks for library functions.
AC_PROG_GCC_TRADITIONAL
AC_TYPE_SIGNAL
# Let groff -Tman know whether we have long options
AC_CHECK_FUNC([getopt_long], [AC_SUBST(HAVE_LONG_OPTS,[yes])],[AC_SUBST(HAVE_LONG_OPTS,[no])])
AC_CHECK_FUNCS(getopt_long isastream mkstemps pselect putenv readlink sched_yield )
AC_CHECK_FUNCS(setenv setitimer setsid setrlimit sigaction snprintf strlcpy strlcat strnlen system)
# Try to determine the kind of pty support on this system
# This is not so easy and may guess wrong; if this happens:
# - edit config.h by hand (and keep a copy of it somewhere as configure will overwrite it), and
# - *please* notify the author! (hanslub42@gmail.com)
# Most of the code below is taken from rxvt-2.7.10 (Copyright (c) 1999-2001
# Geoff Wing )
# In the newest FreeBSD, we need openpty, which exists in libutil
# NB: The rxvt configure script warns against this. Why?
AC_CHECK_LIB(util, openpty)
AC_CHECK_FUNCS(openpty getpty grantpt unlockpt)
AC_CACHE_CHECK(for getpt, ptyttylib_cv_func_getpt,
[AC_TRY_LINK([#define _GNU_SOURCE
#ifdef HAVE_STDLIB_H
# include
#endif],
[(void)getpt();],
ptyttylib_cv_func_getpt=yes, ptyttylib_cv_func_getpt=no)])
if test x$ptyttylib_cv_func_getpt = xyes; then
AC_DEFINE(HAVE_GETPT, 1, Define if you have _GNU_SOURCE getpt() )
fi
AC_CACHE_CHECK(for pty/tty type, ptyttylib_cv_ptys,
[if test x$ac_cv_func_openpty = xyes; then
ptyttylib_cv_ptys=OPENPTY
AC_CHECK_HEADERS([pty.h])
else if test x$ac_cv_func__getpty = xyes; then
ptyttylib_cv_ptys=SGI4
else if test -c /dev/ttyp20 -a ! -c /dev/ptmx; then
ptyttylib_cv_ptys=SCO
else if test -c /dev/ptym/clone; then
ptyttylib_cv_ptys=HPUX
else if test x$ptyttylib_cv_func_getpt = xyes; then
ptyttylib_cv_ptys=GLIBC
else if test -c /dev/ptc -a -c /dev/pts; then
ptyttylib_cv_ptys=PTC
else if test -c /dev/ptc -a -d /dev/pts; then
ptyttylib_cv_ptys=PTC
else if test -c /dev/ptmx -a -c /dev/pts/0; then
ptyttylib_cv_ptys=STREAMS
else case "$host_os" in
*cygwin*) ptyttylib_cv_ptys=STREAMS ;;
*) ptyttylib_cv_ptys=PREHISTORIC ;;
esac
fi
fi
fi
fi
fi
fi
fi
fi
])
if test x$ptyttylib_cv_ptys = xOPENPTY; then
AC_DEFINE(PTYS_ARE_OPENPTY, 1, Define for this pty type)
fi
if test x$ptyttylib_cv_ptys = xSCO; then
AC_DEFINE(PTYS_ARE_NUMERIC, 1, Define for this pty type)
fi
if test x$ptyttylib_cv_ptys = xSTREAMS; then
AC_DEFINE(PTYS_ARE_PTMX, 1, Define for this pty type)
fi
if test x$ptyttylib_cv_ptys = xPTC; then
AC_DEFINE(PTYS_ARE_PTC, 1, Define for this pty type)
fi
if test x$ptyttylib_cv_ptys = xSGI4; then
AC_DEFINE(PTYS_ARE__GETPTY, 1, Define for this pty type)
fi
if test x$ptyttylib_cv_ptys = xCONVEX; then
AC_DEFINE(PTYS_ARE_GETPTY, 1, Define for this pty type)
fi
if test x$ptyttylib_cv_ptys = xGLIBC; then
AC_DEFINE(PTYS_ARE_GETPT, 1, Define for this pty type)
fi
if test x$ptyttylib_cv_ptys = xHPUX; then
AC_DEFINE(PTYS_ARE_CLONE, 1, Define for this pty type)
fi
if test x$ptyttylib_cv_ptys = xPREHISTORIC -o x$ptyttylib_cv_ptys = xHPUX -o x$ptyttylib_cv_ptys = xGLIBC; then
AC_DEFINE(PTYS_ARE_SEARCHED, 1, Define for this pty type)
fi
AC_CHECKING(for pty ranges)
ptys=`echo /dev/pty??`
pch1=`echo $ptys | tr ' ' '\012' | sed -e 's/^.*\(.\).$/\1/g' | sort -u | tr -d '\012'`
pch2=`echo $ptys | tr ' ' '\012' | sed -e 's/^.*\(.\)$/\1/g' | sort -u | tr -d '\012'`
if test x$pch1 != x; then
AC_DEFINE_UNQUOTED(PTYCHAR1, "$pch1", Define for first char in devptyXX)
fi
if test x$pch2 != x; then
AC_DEFINE_UNQUOTED(PTYCHAR2, "$pch2", Define for second char in devptyXX)
fi
# Checks whether readline needs additional libs.
AC_CHECK_FUNC(tgetent,
[READLINE_SUPPLIB=],
[AC_CHECK_LIB(tinfo, tgetent,
[READLINE_SUPPLIB=-ltinfo],
[AC_CHECK_LIB(curses, tgetent,
[READLINE_SUPPLIB=-lcurses],
[AC_CHECK_LIB(ncurses, tgetent,
[READLINE_SUPPLIB=-lncurses],
[AC_CHECK_LIB(termcap, tgetent,
[READLINE_SUPPLIB=-ltermcap],
[AC_MSG_WARN(No termcap nor curses library found)])
])
])
])
])
AC_CHECK_LIB(readline,readline,[READLINELIB=-lreadline],
AC_MSG_ERROR([
You need the GNU readline library(ftp://ftp.gnu.org/gnu/readline/ ) to build
this program!
]), [$READLINE_SUPPLIB])
LIBS="$LIBS $READLINELIB $READLINE_SUPPLIB"
AC_CHECK_FUNCS(tigetnum)
AC_CHECK_HEADER([readline/readline.h],[],AC_MSG_ERROR([readline.h not found - you may need to install a readline development package]))
AC_MSG_CHECKING(whether your readline headers know about rl_set_screen_size)
AC_EGREP_HEADER([rl_set_screen_size],[readline/readline.h], true ,
AC_MSG_ERROR([
You need a more recent version (at least 4.2) of the readline
library (ftp://ftp.gnu.org/gnu/readline/) to build this program!
]))
AC_MSG_RESULT(yes)
AC_MSG_CHECKING(whether your readline library knows about rl_set_screen_size)
AC_CHECK_FUNC(rl_set_screen_size,true,AC_MSG_ERROR([[
Although you have recent enough readline headers, the readline library that I found is old and/or incomplete.
This may e.g. happen on Mac OS X machines, where the readline library is just a re-badged copy of editline
Please re-configure with ./configure LDFLAGS='-L/path/to/the/real/readline/lib/'
]]))
AC_MSG_CHECKING(whether your readline knows about rl_variable_value)
AC_EGREP_HEADER([rl_variable_value],[readline/readline.h], [
AC_DEFINE(HAVE_RL_VARIABLE_VALUE, 1 ,[Define to 1 if your readline lib has rl_variable_value()])])
AC_MSG_RESULT(yes)
AC_MSG_CHECKING(whether your readline knows about rl_readline_version)
AC_EGREP_HEADER([rl_readline_version],[readline/readline.h], [
AC_DEFINE(HAVE_RL_READLINE_VERSION, 1 ,[Define to 1 if your readline lib has rl_readline_version])])
AC_MSG_RESULT(yes)
# check for existence of myself under $opt_proc_mountpoint/$$/cwd If the user specified --disable-proc-mountpoint we'll still do these tests
# but they wil fail unless /no is a procfs mountpoint ;-)
echo "Will rlwrap find command's working directory under ${opt_proc_mountpoint}//cwd? let's see..."
AC_CHECK_FILES($opt_proc_mountpoint/$$/cwd/configure.ac,[
AC_DEFINE(HAVE_PROC_PID_CWD, 1 ,[Define to 1 if //cwd is a link to working directory of process ])
AC_SUBST(HAVE_PROC_PID_CWD,[yes])
],[AC_SUBST(HAVE_PROC_PID_CWD,[no])])
AC_DEFINE_UNQUOTED(PROC_MOUNTPOINT, "[$opt_proc_mountpoint]", [Define to location of Linux-style procfs mountpoint if provided and valid])
AC_MSG_CHECKING([whether we can find command line under //cmdline and mirror it by overwriting our own *argv])
# We won't exactly do that, but instead write a test program that writes a random string to *argv (making sure it is longer than argv[0])
# and then verify that we can see the same string under //cmdline
# If so, we enable the --mirror-args option
random_nonsense1="fymaytskjqhjeeimtmjqvqbnrnfutgnkehkmqqealklsoswyepxugcckimqdwbwfqdhdsdxfxiagqbnm"
random_nonsense2="iraliuuklajcorjfunavdsytdiydjaoaeauiapidtoxogfplrxfmfcmajikwenafwcownmoodxjljhsv"
AC_DEFINE_UNQUOTED(RANDOM_NONSENSE2, "\"$random_nonsense2\"", nonsense arg to overwrite conftest argv with)
AC_LANG_CONFTEST(
[AC_LANG_SOURCE([[#include
#include
int main(int argc, char **argv) {
memcpy(*argv, "a\0" RANDOM_NONSENSE2, strlen(RANDOM_NONSENSE2) + 3);
return(sleep(10));
}
]])])
result="no"
gcc -o conftest conftest.c
./conftest $random_nonsense1 >/dev/null 2>&1 &
CONFTEST_PID=$!
if grep $random_nonsense2 $opt_proc_mountpoint/$CONFTEST_PID/cmdline >/dev/null 2>&1; then
AC_DEFINE(ENABLE_MIRROR_ARGS, 1, [Define if overwriting argv changes args visible in ps (1)])
result="yes"
fi
kill $!
AC_MSG_RESULT($result)
echo
echo
AC_OUTPUT
cat <
Copyright (C)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
rlwrap-0.42/src/ 0000755 0001751 0000144 00000000000 12431413017 010527 5 0000000 0000000 rlwrap-0.42/src/string_utils.c 0000644 0001751 0000144 00000060065 12404151311 013344 0000000 0000000 /* rlwrap - a readline wrapper
(C) 2000-2007 Hans Lub
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
**************************************************************
string_utils.c: rlwrap uses a fair number of custom string-handling
functions. A few of those are replacements for (or default to)
GNU or POSIX standard funcions (with names like mydirname,
mystrldup). Others are special purpose string manglers for
debugging, removing colour codes and the construction of history
entries)
All of these functions work on basic types as char * and int, and
none of them refer to any of rlwraps global variables (except debug)
*/
#include "rlwrap.h"
/* mystrlcpy and mystrlcat: wrappers around strlcat and strlcpy, if
available, otherwise emulations of them. Both versions *assure*
0-termination, but don't check for truncation: return type is
void */
void
mystrlcpy(char *dst, const char *src, size_t size)
{
#ifdef HAVE_STRLCPY
strlcpy(dst, src, size);
#else
strncpy(dst, src, size - 1);
dst[size - 1] = '\0';
#endif
}
void
mystrlcat(char *dst, const char *src, size_t size)
{
#ifdef HAVE_STRLCAT
strlcat(dst, src, size);
dst[size - 1] = '\0'; /* we don't check for truncation, just assure '\0'-termination. */
#else
strncat(dst, src, size - strnlen(dst, size) - 1);
dst[size - 1] = '\0';
#endif
}
/* mystrndup: strndup replacement that uses the safer mymalloc instead
of malloc*/
static char *
mystrndup(const char *string, int len)
{
/* allocate copy of string on the heap */
char *buf;
assert(string != NULL);
buf = (char *)mymalloc(len + 1);
mystrlcpy(buf, string, len + 1);
return buf;
}
/* mysavestring: allocate a copy of a string on the heap */
char *
mysavestring(const char *string)
{
assert(string != NULL);
return mystrndup(string, strlen(string));
}
/* add3strings: allocate a sufficently long buffer on the heap and
successively copy the three arguments into it */
char *
add3strings(const char *str1, const char *str2, const char *str3)
{
int size;
char *buf;
assert(str1!= NULL); assert(str2!= NULL); assert(str3!= NULL);
size = strlen(str1) + strlen(str2) + strlen(str3) + 1; /* total length plus 0 byte */
buf = (char *) mymalloc(size);
/* DPRINTF3(DEBUG_TERMIO,"size1: %d, size2: %d, size3: %d", (int) strlen(str1), (int) strlen(str2), (int) strlen(str3)); */
mystrlcpy(buf, str1, size);
mystrlcat(buf, str2, size);
mystrlcat(buf, str3, size);
return buf;
}
/* append_and_free_old(str1, str2): return add2strings(str1, str2), freeing str1
append_and_free_old(NULL, str) just returns a copy of str
*/
char *
append_and_free_old(char *str1, const char *str2)
{
if (!str1)
return mysavestring(str2); /* if str1 == NULL there is no need to "free the old str1" */
else {
char *result = add2strings(str1,str2);
free (str1);
return result;
}
}
/* mybasename and mydirname: wrappers around basename and dirname, if
available, otherwise emulations of them */
char *
mybasename(char *filename)
{ /* determine basename of "filename" */
char *p;
/* find last '/' in name (if any) */
for (p = filename + strlen(filename) - 1; p > filename; p--)
if (*(p - 1) == '/')
break;
return p;
}
char *
mydirname(char *filename)
{ /* determine directory component of "name" */
char *p;
/* find last '/' in name (if any) */
for (p = filename + strlen(filename) - 1; p > filename; p--)
if (*(p - 1) == '/')
break;
return (p == filename ? "." : mystrndup(filename, p - filename));
}
/* mystrtok: saner version of strtok that doesn't overwrite its first argument */
char *
mystrtok(const char *s, const char *delim) {
static char *scratchpad = NULL;
if (s) {
if (scratchpad)
free(scratchpad);
scratchpad = mysavestring(s);
}
return strtok(s ? scratchpad : NULL, delim);
}
/* split_with("a bee cee"," ") returns a pointer to an array {"a", "bee", "cee", NULL} on the heap */
char **
split_with(const char *string, const char *delim) {
const char *s;
char *token, **pword;
char **list = mymalloc(1 + strlen(string) * sizeof(char **)); /* list can never be longer than string + 1 */
for (s = string, pword = list; (token = mystrtok(s, delim)); s = NULL)
*pword++ = mysavestring(token);
*pword = NULL;
return list;
}
/* unsplit_with(3, ["a", "bee", "cee"], "; ") returns a pointer to "a; bee; cee" on the heap */
char *
unsplit_with(int n, char **strings, const char *delim) {
int i;
char *result = mysavestring(n> 0 ? strings[0]: "");
for (i = 1; i < n; i++) {
result = append_and_free_old(result, delim);
result = append_and_free_old(result, strings[i]);
}
return result;
}
/* split_with("a\t\tbla","\t") returns {"a" "bla", NULL}, but we want {"a", "", "bla", NULL} for filter completion.
We write a special version (can be freed with free_splitlist) */
char **split_on_single_char(const char *string, char c) {
char **list = mymalloc(1 + strlen(string) * sizeof(char **));
char *stringcopy = mysavestring(string);
char *p, **pword, *current_word;
for (pword = list, p = current_word = stringcopy;
*p; p++) {
if (*p == c) {
*p = '\0';
*pword++ = mysavestring(current_word);
current_word = p+1;
}
}
*pword++ = mysavestring(current_word);
*pword = NULL;
free(stringcopy);
return list;
}
/* free_splitlist(list) frees lists components and then list itself. list must be NULL-terminated */
void free_splitlist (char **list) {
char **p = list;
while(*p)
free(*p++);
free (list);
}
/* search_and_replace() is a utilty for handling multi-line input
(-m option), keeping track of the cursor position on rlwraps prompt
in order to put the cursor on the very same spot in the external
editor For example, when using NL as a newline substitute (rlwrap
-m NL ):
search_and_replace("NL", "\n", "To be NL ... or not to be", 11,
&line, &col) will return "To be \n ... or not to be", put 2 in line
and 3 in col because a cursor position of 11 in "To be NL ..."
corresponds to the 3rd column on the 2nd line in "To be \n ..."
cursorpos, col and line only make sense if repl == "\n", otherwise
they may be 0/NULL (search_and_replace works for any repl). The
first position on the string corresponds to cursorpos = col = 0 and
line = 1.
*/
char *
search_and_replace(char *patt, char *repl, const char *string, int cursorpos,
int *line, int *col)
{
int i, j, k;
int pattlen = strlen(patt);
int replen = strlen(repl);
int stringlen = strlen(string);
int cursor_found = FALSE;
int current_line = 1;
int current_column = 0;
size_t scratchsize;
char *scratchpad, *result;
assert(patt && repl && string);
DPRINTF2(DEBUG_READLINE, "string=%s, cursorpos=%d",
mangle_string_for_debug_log(string, 40), cursorpos);
scratchsize = max(stringlen, (stringlen * replen) / pattlen) + 1; /* worst case : repleng > pattlen and string consists of only */
DPRINTF1(DEBUG_READLINE, "Allocating %d bytes for scratchpad", (int) scratchsize);
scratchpad = mymalloc(scratchsize);
for (i = j = 0; i < stringlen; ) {
if (line && col && /* if col and line are BOTH non-NULL, and .. */
i >= cursorpos && !cursor_found) { /* ... for the first time, i >= cursorpos: */
cursor_found = TRUE; /* flag that we're done here */
*line = current_line; /* update *line */
*col = current_column; /* update *column */
}
if (strncmp(patt, string + i, pattlen) == 0) { /* found match */
i += pattlen; /* update i ("jump over" patt (and, maybe, cursorpos)) */
for (k = 0; k < replen; k++) /* append repl to scratchpad */
scratchpad[j++] = repl[k];
current_line++; /* update line # (assuming that repl = "\n") */
current_column = 0; /* reset column */
} else {
scratchpad[j++] = string[i++]; /* or else just copy things */
current_column++;
}
}
if (line && col)
DPRINTF2(DEBUG_READLINE, "line=%d, col=%d", *line, *col);
scratchpad[j] = '\0';
result = mysavestring(scratchpad);
free(scratchpad);
return (result);
}
/* first_of(&string_array) returns the first non-NULL element of string_array */
char *
first_of(char **strings)
{
char **p;
for (p = strings; *p == NULL; p++);
return *p;
}
/* allocate string representation of an integer on the heap */
char *
as_string(int i)
{
#define MAXDIGITS 10 /* let's pray no-one edits multi-line input more than 10000000000 lines long :-) */
char *newstring = mymalloc(MAXDIGITS+1);
snprintf1(newstring, MAXDIGITS, "%d", i);
return (newstring);
}
char *
mangle_char_for_debug_log(char c, int quote_me)
{
char *special = NULL;
char scrap[10], code, *format;
char *remainder = "\\]^_";
switch (c) {
case 0: special = ""; break;
case 8: special = ""; break;
case 9: special = ""; break;
case 10: special = ""; break;
case 13: special = ""; break;
case 27: special = ""; break;
case 127: special = ""; break;
}
if (!special) {
if (c > 0 && c < 27 ) {
format = ""; code = c + 64;
} else if (c > 27 && c < 32) {
format = ""; code = remainder[c-28];
} else {
format = (quote_me ? "\"%c\"" : "%c"); code = c;
}
snprintf1(scrap, sizeof(scrap), format, code);
}
return mysavestring (special ? special : scrap);
}
/* mangle_string_for_debug_log(string, len) returns a printable
representation of string for the debug log. It will truncate a
resulting string longer than len, appending three dots ... */
char *
mangle_string_for_debug_log(const char *string, int maxlen)
{
int total_length;
char *mangled_char, *result;
const char *p; /* good old K&R-style *p. I have become a fossil... */
if (!string)
return mysavestring("(null)");
result = mysavestring("");
for(p = string, total_length = 0; *p; p++) {
mangled_char = mangle_char_for_debug_log(*p, FALSE);
total_length += strlen(mangled_char);
if (maxlen && (total_length > maxlen)) {
result = append_and_free_old(result, "...");
break; /* break *before* we reach maxlen */
}
result = append_and_free_old(result, mangled_char);
free(mangled_char);
}
return result;
}
char *mangle_buffer_for_debug_log(const char *buffer, int length) {
char *string = mymalloc(length+1);
int debug_saved = debug; /* needed by macro MANGLE_LENGTH */
memcpy(string, buffer, length);
string[length] = '\0';
return mangle_string_for_debug_log(string, MANGLE_LENGTH);
}
/* mem2str(mem, size) returns a fresh string representation of mem where al 0 bytes have been replaced by "\\0" */
char *mem2str(const char *mem, int size) {
const char *p_mem;
char *p_str;
char *str = mymalloc(2*size + 1); /* worst case: "\0\0\0\0.." */
for(p_mem = mem, p_str = str; p_mem < mem + size; p_mem++) {
if (*p_mem)
*p_str++ = *p_mem;
else {
*p_str++ = '\\';
*p_str++ = '0';
}
}
*p_str = '\0';
return str;
}
char *
mystrstr(const char *haystack, const char *needle)
{
return strstr(haystack, needle);
}
int scan_metacharacters(const char* string, const char *metacharacters) {
const char *c;
for (c = metacharacters; *c; c++)
if (strchr(string, *c))
return TRUE;
return FALSE;
}
/* allocate and init array of 4 strings (helper for munge_line_in_editor() and filter) */
char **
list4 (char *el0, char *el1, char *el2, char *el3)
{
char **list = mymalloc(4*sizeof(char*));
list[0] = el0;
list[1] = el1;
list[2] = el2;
list[3] = el3;
return list;
}
/* remove_padding_and_terminate(buf, N) overwrites buf with a copy of
its first N bytes, omitting any zero bytes, and then terminates the
result with a final zero byte. Example: if buf="a\0b\0\0cde@#!" then,
after calling remove_padding_and_terminate(buf, 8) buf will contain
"abcde\0de@#!"
We need to call this function on everything we get from the
inferior command because (out of sheer programmer laziness) rlwrap
uses C strings internally. Zero bytes are only ever used as padding
(@@@is this true?), and padding is not used anymore on modern
terminals. (except maybe for things like the visual bell) */
void remove_padding_and_terminate(char *buf, int length) {
char *readptr, *copyptr;
for (readptr = copyptr = buf; readptr < buf + length; readptr++) {
if (*readptr != '\0')
*copyptr++ = *readptr;
}
*copyptr = '\0';
if (debug && strlen(buf) != length)
DPRINTF2(DEBUG_TERMIO, "removed %d zero bytes (padding?) from %s", length - (int) strlen(buf), mangle_string_for_debug_log(buf, MANGLE_LENGTH));
}
#define ESCAPE '\033'
#define BACKSPACE '\010'
#define CARRIAGE_RETURN '\015'
/* unbackspace(&buf) will overwrite buf (up to and including the first
'\0') with a copy of itself. Backspaces will move the "copy
pointer" one backwards, carriage returns will re-set it to the
begining of buf. Because the re-written string is always shorter
than the original, we need not worry about writing outside buf
Example: if buf="abc\bd\r\e" then, after calling unbackspace(buf),
buf will contain "ebd"
We need this function because many commands emit "status lines"
using backspaces and carriage returns to re-write parts of the line in-place.
Rlwrap will consider such lines as "prompts" (@@@myabe it shouldn't?)
but mayhem results if we feed the \b and \r characters to readline
*/
void
unbackspace(char* buf) {
char *readptr, *copyptr, *endptr;
int seen_bs_or_cr;
DPRINTF1(DEBUG_TERMIO,"unbackspace: %s", mangle_string_for_debug_log(buf, MANGLE_LENGTH));
seen_bs_or_cr = FALSE;
for (readptr = copyptr = endptr = buf; *readptr; readptr++) {
assert(endptr <= readptr);
assert(copyptr <= endptr);
switch (*readptr) {
case BACKSPACE:
copyptr = (copyptr > buf ? copyptr - 1 : buf); /* cannot backspace past beginning of buf */
seen_bs_or_cr = TRUE;
break;
case CARRIAGE_RETURN:
copyptr = buf;
seen_bs_or_cr = TRUE;
break;
default:
*copyptr++ = *readptr;
break;
}
if (copyptr > endptr)
endptr = copyptr;
}
*endptr = '\0';
if (seen_bs_or_cr)
DPRINTF1(DEBUG_TERMIO,"unbackspace result: %s", mangle_string_for_debug_log(buf, MANGLE_LENGTH));
}
void test_unbackspace (const char *input, const char *expected_result) {
char *scrap = mysavestring(input);
unbackspace(scrap);
if (strcmp(scrap, expected_result) != 0)
myerror(FATAL|NOERRNO, "unbackspace %s yielded %s, expected %s",
mangle_string_for_debug_log(input,0),
mangle_string_for_debug_log(scrap,0),
expected_result);
}
/* Readline allows to single out character sequences that take up no
physical screen space when displayed by bracketing them with the
special markers `RL_PROMPT_START_IGNORE' and `RL_PROMPT_END_IGNORE'
(declared in `readline.h').
mark_invisible(buf) returns a new copy of buf with sequences of the
form ESC[;0-9]*m? marked in this way.
*/
/*
(Re-)definitions for testing
#undef RL_PROMPT_START_IGNORE
#undef RL_PROMPT_END_IGNORE
#undef isprint
#define isprint(c) (c != 'x')
#define RL_PROMPT_START_IGNORE '('
#define RL_PROMPT_END_IGNORE ')'
#define ESCAPE 'E'
*/
/* TODO @@@ replace the following obscure and unsafe functions using the regex library */
static void copy_ordinary_char_or_ESC_sequence(const char **original, char **copy);
static void match_and_copy(const char *charlist, const char **original, char **copy);
static int matches (const char *charlist, char c) ;
static void copy_next(int n, const char **original, char **copy);
char *
mark_invisible(const char *buf)
{
int padsize = (assert(buf != NULL), (3 * strlen(buf) + 1)); /* worst case: every char in buf gets surrounded by RL_PROMPT_{START,END}_IGNORE */
char *scratchpad = mymalloc (padsize);
char *result = scratchpad;
const char **original = &buf;
char **copy = &scratchpad;
if (strchr(buf, RL_PROMPT_START_IGNORE))
return mysavestring(buf); /* "invisible" parts already marked */
while (**original) {
copy_ordinary_char_or_ESC_sequence(original, copy);
assert(*copy - scratchpad < padsize);
}
**copy = '\0';
return(result);
}
static void
copy_ordinary_char_or_ESC_sequence (const char **original, char **copy)
{
if (**original != ESCAPE || ! matches ("[]", *(*original + 1))) {
copy_next(1, original, copy);
return; /* not an ESC[ sequence */
}
*(*copy)++ = RL_PROMPT_START_IGNORE;
copy_next(2, original, copy);
match_and_copy(";0123456789", original, copy);
match_and_copy("m", original, copy);
*(*copy)++ = RL_PROMPT_END_IGNORE;
}
static void
match_and_copy(const char *charlist, const char **original, char **copy)
{
while (matches(charlist, **original))
*(*copy)++ = *(*original)++;
}
static int
matches (const char *charlist, char c)
{
const char *p;
for (p = charlist; *p; p++)
if (*p == c)
return TRUE;
return FALSE;
}
static void
copy_next(int n, const char **original, char **copy)
{
int i;
for (i = 0; **original && (i < n); i++)
*(*copy)++ = *(*original)++;
}
/* helper function: returns the number of displayed characters (the
"colourless length") of str (which has its unprintable sequences
marked with RL_PROMPT_*_IGNORE). Puts a copy without the
RL_PROMPT_*_IGNORE characters in *copy_without_ignore_markers (if
!= NULL)
*/
int
colourless_strlen(const char *str, char **pcopy_without_ignore_markers, int termwidth)
{
int visible = TRUE;
int column = 0;
int length = strlen(str);
const char *p;
char *q, *copy_without_ignore_markers;
assert(termwidth >= 0);
q = copy_without_ignore_markers = mymalloc(length + 1);
for(p = str; *p; p++) {
assert (q < copy_without_ignore_markers + length);
switch (*p) {
case RL_PROMPT_START_IGNORE:
visible = FALSE;
continue;
case RL_PROMPT_END_IGNORE:
visible = TRUE;
continue;
case '\r':
if (visible) {
q -= column;
column = 0;
continue;
}
break;
case '\b':
if ((visible && q > copy_without_ignore_markers)) {
q -= 1;
column -= 1;
if (termwidth && column < 0)
column += termwidth;
continue;
}
break;
}
if (visible) {
*q++ = *p;
column +=1;
if (termwidth && column >= termwidth)
column -= termwidth;
}
}
*q = '\0';
DPRINTF4(DEBUG_READLINE, "colourless_strlen(\"%s\", 0x%lx, %d) = %ld",
mangle_string_for_debug_log(str, MANGLE_LENGTH), (long) pcopy_without_ignore_markers,
termwidth, q - copy_without_ignore_markers);
if (pcopy_without_ignore_markers)
*pcopy_without_ignore_markers = copy_without_ignore_markers;
else
free (copy_without_ignore_markers);
return q - copy_without_ignore_markers;
}
int
colourless_strlen_unmarked (const char *str, int termwidth)
{
char *marked_str = mark_invisible(str);
int colourless_length = colourless_strlen(marked_str, NULL, termwidth);
free(marked_str);
return colourless_length;
}
/* skip a maximal number (possibly zero) of termwidth-wide
initial segments of long_line and return the remainder
(i.e. the last line of long_line on screen)
if long_line contains an ESC character, return "" (signaling
"don't touch") */
char *
get_last_screenline(char *long_line, int termwidth)
{
int line_length, removed;
char *line_copy, *last_screenline;
line_copy = mysavestring(long_line);
line_length = strlen(line_copy);
if (termwidth == 0 || /* this may be the case on some weird systems */
line_length <= termwidth) { /* line doesn't extend beyond right margin
@@@ are there terminals that put the cursor on the
next line if line_length == termwidth?? */
return line_copy;
} else if (strchr(long_line, '\033')) { /* found, give up */
free (line_copy);
return mysavestring("Ehhmm..? > ");
} else {
removed = (line_length / termwidth) * termwidth; /* integer arithmetic: 33/10 = 3 */
last_screenline = mysavestring(line_copy + removed);
free(line_copy);
return last_screenline;
}
}
/* lowercase(str) returns lowercased copy of str */
char *
lowercase(const char *str) {
char *result, *p;
result = mysavestring(str);
for (p=result; *p; p++)
*p = tolower(*p);
return result;
}
char *
colour_name_to_ansi_code(const char *colour_name) {
if (colour_name && *colour_name && isalpha(*colour_name)) {
char *lc_colour_name = mysavestring(lowercase(colour_name));
char *bold_code = (isupper(*colour_name) ? "1" : "0");
#define isit(c) (strcmp(c,lc_colour_name)==0)
char *colour_code =
isit("black") ? "30" :
isit("red") ? "31" :
isit("green") ? "32" :
isit("yellow") ? "33" :
isit("blue") ? "34" :
isit("magenta") ? "35" :
isit("purple") ? "35" :
isit("cyan") ? "36" :
isit("white") ? "37" :
NULL ;
#undef isit
if (colour_code)
return add3strings(bold_code,";",colour_code);
else
myerror(FATAL|NOERRNO, "unrecognised colour name '%s'. Use e.g. 'yellow' or 'Blue'.", colour_name);
}
return mysavestring(colour_name);
}
/*
returns TRUE if 'string' matches the 'regexp' (or is a superstring
of it, when we don't HAVE_REGEX_H). The regexp is recompiled with
every call, which doesn't really hurt as this function is not called
often: at most twice for every prompt. 'string' and 'regexp' may be
NULL (in which case FALSE is returned)
Only used for the --forget-regexp and the --prompt-regexp options
*/
int match_regexp (const char *string, const char *regexp, int case_insensitive) {
int result;
if (!regexp || !string)
return FALSE;
#ifndef HAVE_REGEX_H
{
static int been_warned = 0;
char *metachars = "*()+?";
char *lc_string = (case_insensitive ? lowercase(string) : mysavestring(string));
char *lc_regexp = (case_insensitive ? lowercase(regexp) : mysavestring(regexp));
if (scan_metacharacters(regexp, metachars) && !been_warned++) /* warn only once if the user specifies a metacharacter */
myerror(WARNING|NOERRNO, "one of the regexp metacharacters \"%s\" occurs in regexp(?) \"%s\"\n"
" ...but on your platform, regexp matching is not supported!", metachars, regexp);
result = mystrstr(lc_string, lc_regexp);
free(lc_string);
free(lc_regexp);
}
#else
{
regex_t *compiled_regexp = mymalloc(sizeof(regex_t));
int compile_error = regcomp(compiled_regexp, regexp, REG_EXTENDED|REG_NOSUB|(case_insensitive ? REG_ICASE : 0));
if (compile_error) {
int size = regerror(compile_error, compiled_regexp, NULL, 0);
char *error_message = mymalloc(size);
regerror(compile_error, compiled_regexp, error_message, size);
myerror(FATAL|NOERRNO, "in regexp \"%s\": %s", regexp, error_message);
} else {
result = !regexec(compiled_regexp, string, 0, NULL, 0);
free(compiled_regexp);
}
}
#endif
return result;
}
rlwrap-0.42/src/term.c 0000644 0001751 0000144 00000025163 12404151311 011565 0000000 0000000 /* term.c: terminal handling, cursor movement etc.
(C) 2000-2007 Hans Lub
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License , or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
You may contact the author by:
e-mail: hlub@knoware.nl
*/
#include "rlwrap.h"
/*global vars */
char term_eof; /* end_of_file char */
char term_stop; /* stop (suspend) key */
char *term_backspace; /* backspace control seq (or 0, if none defined in terminfo) */
char *term_cursor_hpos;
char *term_clear_screen;
char *term_cursor_up;
char *term_cursor_down;
char *term_cursor_left; /* only used for debugging (the SHOWCURSOR macro) */
char *term_rmcup; /* rmcup - char sequence to return from alternate screen */
char *term_rmkx; /* rmkx - char sequence to return from keyboard application mode */
/* int term_colors = -1; number of colors ('colors' capability, only in terminfo) */
int redisplay = 1;
int newline_came_last = TRUE; /* used to determine whether rlwrap needs to ouptut a newline at the very end */
struct termios saved_terminal_settings; /* original terminal settings */
int terminal_settings_saved = FALSE; /* saved_terminal_settings is valid */
struct winsize winsize; /* current window size */
static char *term_cr; /* carriage return (or 0, if none defined in terminfo) */
static char *term_clear_line;
char *term_name;
/* TODO: replace termcap functions by terminfo ones, keeping termcap as a fallback for ancient systems
we might have to give both terminfo-style and termcap names, like in my_tigetstr("cub1", "le") */
static char *my_tgetstr (char *id) {
char *term_string_buf = (char *)mymalloc(2048), *tb = term_string_buf;
char *stringcap = tgetstr(id, &tb); /* rl_get_termcap(id) only gets capabilities used by readline */
char *retval = stringcap ? mysavestring(stringcap) : NULL;
DPRINTF2(DEBUG_TERMIO, "tgetstr(\"%s\") = %s", id, (stringcap ? mangle_string_for_debug_log(stringcap,20) : "NULL"));
free(term_string_buf);
return retval;
}
#define FALLBACK_TERMINAL "vt100" /* terminal to use when we don't know which terminal we're on */
void
init_terminal(void)
{ /* save term settings and determine term type */
char *term_buf;
int we_have_stringcaps;
int we_are_on_hp_ux11;
if (!isatty(STDIN_FILENO))
myerror(FATAL|NOERRNO, "stdin is not a tty");
if (tcgetattr(STDIN_FILENO, &saved_terminal_settings) < 0)
myerror(FATAL|USE_ERRNO, "tcgetattr error on stdin");
else
terminal_settings_saved = TRUE;
if (ioctl(STDIN_FILENO, TIOCGWINSZ, &winsize) < 0)
myerror(FATAL|USE_ERRNO, "Could not get terminal size");
DPRINTF2(DEBUG_TERMIO, "winsize.ws_col: %d; winsize.ws_row: %d", winsize.ws_col, winsize.ws_row);
if (winsize.ws_col == 0)
myerror(FATAL|NOERRNO, "My terminal reports width=0 (is it emacs?) I can't handle this, sorry!");
/* init some variables: */
term_name = getenv("TERM");
DPRINTF1(DEBUG_TERMIO, "found TERM = %s", term_name);
if (!term_name || strlen(term_name)==0) {
myerror(WARNING|USE_ERRNO, "environment variable TERM not set, assuming %s", FALLBACK_TERMINAL);
term_name = FALLBACK_TERMINAL;
}
term_buf = (char *)mymalloc(4096);
term_backspace = NULL;
term_cr = NULL;
term_clear_line = NULL;
term_cursor_hpos = NULL;
/* On weird and scary HP-UX 11 succesful tgetent() returns 0: */
we_are_on_hp_ux11 = tgetent(term_buf, "vt100") == 0 && tgetent(term_buf,"QzBgt57gr6xwxw") == -1; /* assuming there is no terminal called Qz... */
#define T_OK(retval) ((retval) > 0 || ((retval)== 0 && we_are_on_hp_ux11))
/* Test whether we can find stringcaps, use FALLBACK_TERMINAL name if not */
if (! (we_have_stringcaps = T_OK(tgetent(term_buf, term_name))) && strcmp(term_name, FALLBACK_TERMINAL)) {
myerror(WARNING|NOERRNO, "your $TERM is '%s' but %s couldn't find it in the terminfo database. We'll use '%s'",
term_name, program_name, FALLBACK_TERMINAL);
term_name = FALLBACK_TERMINAL;
}
if (! (we_have_stringcaps = T_OK(tgetent(term_buf, FALLBACK_TERMINAL))))
myerror(WARNING|NOERRNO, "Even %s is not found in the terminfo database. Expect some problems...", FALLBACK_TERMINAL);
DPRINTF1(DEBUG_TERMIO, "using TERM = %s", term_name);
mysetenv("TERM", term_name);
if (we_have_stringcaps) {
term_backspace = my_tgetstr("le");
term_cr = my_tgetstr("cr");
term_clear_line = my_tgetstr("ce");
term_clear_screen = my_tgetstr("cl");
term_cursor_hpos = my_tgetstr("ch");
term_cursor_left = my_tgetstr("le");
term_rmcup = my_tgetstr("te"); /* rlwrap still uses ye olde termcappe names */
term_rmkx = my_tgetstr("ke");
if (term_cursor_hpos && !strstr(term_cursor_hpos, "%p")) {
/* Some RedHat or Debian people with out-of sync devel packages will get problems when tgoto expects terminfo-style caps
and their tgetstr returns termcap-style. This is a rather heavy-handed way of avoiding those problems: */
DPRINTF0(DEBUG_TERMIO, "term_cursor_hpos appears to be termcap-style, not terminfo; NULLing it");
term_cursor_hpos = NULL;
}
term_cursor_up = my_tgetstr("up");
term_cursor_down = my_tgetstr("do");
/*
setupterm(term_name, 1, (int *)0);
term_colors = tigetnum("colors");
DPRINTF1(DEBUG_TERMIO, "terminal colors: %d", term_colors);
*/
}
term_eof = saved_terminal_settings.c_cc[VEOF];
term_stop = saved_terminal_settings.c_cc[VSTOP];
DPRINTF1(DEBUG_TERMIO, "term_eof=%d", term_eof);
free(term_buf);
}
void
set_echo(int yes)
{
struct termios *pterm = my_tcgetattr(slave_pty_sensing_fd, "slave pty"); /* mimic terminal settings of client */
if (!pterm) /* child has probably died */
return;
pterm->c_lflag &= ~ICANON; /* except a few details... */
pterm->c_cc[VMIN] = 1;
pterm->c_cc[VTIME] = 0;
if (yes)
pterm->c_lflag |= ECHO;
else /* no */
pterm->c_lflag &= ~ECHO;
log_terminal_settings(pterm);
if (tcsetattr(STDIN_FILENO, TCSANOW, pterm) < 0 && errno != ENOTTY)
; /* myerror(FATAL|USE_ERRNO, "cannot prepare terminal (tcsetattr error on stdin)"); */
free(pterm);
}
int
cursor_hpos(int col)
{
char *instantiated;
assert(term_cursor_hpos != NULL); /* caller has to make sure */
instantiated = tgoto(term_cursor_hpos, 0, col); /* tgoto with a command that takes one parameter: parameter goes to 2nd arg ("vertical position"). */
assert(instantiated);
DPRINTF2(DEBUG_TERMIO, "tgoto(term_cursor_hpos, 0, %d) = %s", col, mangle_string_for_debug_log(instantiated, 20));
tputs(instantiated, 1, my_putchar);
return TRUE;
}
void
cr()
{
if (term_cr)
tputs(term_cr, 1, my_putchar);
else
my_putchar('\r');
}
void
clear_the_screen()
{ /* clear_screen is a macro in term.h */
int i;
if (term_clear_screen)
tputs(term_clear_screen, 1, my_putchar);
else
for (i = 0; i < winsize.ws_row; i++)
my_putchar('\n'); /* poor man's clear screen */
}
void
clear_line()
{
int i;
int width = winsize.ws_col;
char *p, *spaces;
cr();
if (term_clear_line)
tputs(term_clear_line, 1, my_putchar);
else {
spaces = (char *) mymalloc(width + 1);
for (i = 0, p = spaces; i < width; i++, p++)
*p = ' ';
*p = '\0';
my_putstr(spaces); /* poor man's clear line */
free((void *)spaces);
}
cr();
}
void
backspace(int count)
{
int i;
if (term_backspace)
for (i = 0; i < count; i++)
tputs(term_backspace, 1, my_putchar);
else
for (i = 0; i < count; i++)
my_putchar('\b');
}
void
curs_left()
{
if (term_cursor_left)
tputs(term_cursor_left, 1, my_putchar);
else
backspace(1);
}
void
curs_up()
{
/* assert(term_cursor_up != NULL); caller has to make sure */
tputs(term_cursor_up, 1, my_putchar);
}
void
curs_down()
{
assert(term_cursor_down != NULL); /* caller has to make sure */
tputs(term_cursor_down, 1, my_putchar);
}
int my_putchar(TPUTS_PUTC_ARGTYPE c)
{
char ch = c;
ssize_t nwritten = write(STDOUT_FILENO, &ch, 1);
return (nwritten == -1 ? -1 : c);
}
void
my_putstr(const char *string)
{
int string_length = strlen(string);
DPRINTF2(DEBUG_TERMIO,"wrote %d bytes to stdout: %s", string_length,
mangle_string_for_debug_log(string, MANGLE_LENGTH));
if (string_length == 0)
return;
write_patiently(STDOUT_FILENO, string, string_length, "to stdout");
newline_came_last = (string[string_length - 1] == '\n'); /* remember whether newline came last */
}
static void test_termfunc(char *control_string, char *control_string_name, char* start, void (* termfunc)(), char *end)
{
char *mangled_control_string =
(control_string ?
add3strings("\"", mangle_string_for_debug_log(control_string,20),"\"") :
mysavestring("NULL"));
printf("\n%s = %s\n", control_string_name, mangled_control_string);
if (!control_string)
return;
my_putstr(start);
sleep(1);
termfunc();
my_putstr(end);
sleep(1);
free(mangled_control_string);
}
static void backspace1 () { backspace(1); }
static void cursor_hpos4 () { cursor_hpos(4);}
void test_terminal()
{
if (debug) {
debug_fp = fopen(DEBUG_FILENAME, "w");
setbuf(debug_fp, NULL);
}
init_terminal();
printf("\nTerminal is \"%s\"\n", term_name);
test_termfunc(term_backspace, "term_backspace", "This should print \"grape\": \ngras", &backspace1, "pe\n");
test_termfunc(term_cr, "term_cr", "This should print \"lemon juice\": \napple", &cr, "lemon juice\n");
test_termfunc(term_clear_line, "term_clear_line","This should print \"apple\": \npomegranate", &clear_line, "apple\n");
test_termfunc(term_cursor_hpos, "term_cursor_hpos", "This should print \"pomegranate\": \npomelo", &cursor_hpos4, "granate\n");
test_termfunc(term_cursor_up, "term_cursor_up", "This should print \"blackberry\": \n blueberry\n", &curs_up,"black\n");
printf("\n");
}
rlwrap-0.42/src/main.c 0000644 0001751 0000144 00000125207 12407053737 011562 0000000 0000000 /* main.c: main(), initialisation and cleanup
* (C) 2000-2009 Hans Lub
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License , or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
* You may contact the author by e-mail: hlub@knoware.nl
*/
#include "rlwrap.h"
/* global vars */
/* variables set via command line options */
int always_readline = FALSE; /* -a option: always be in readline mode */
char *password_prompt_search_string = NULL; /* (part of) password prompt (argument of -a option) */
int ansi_colour_aware = FALSE; /* -A option: make readline aware of ANSI colour codes in prompt */
int complete_filenames = FALSE; /* -c option: whether to complete file names */
int debug = 0; /* -d option: debugging mask */
char *extra_char_after_completion = " "; /* -e option: override readlines's default completion_append_char (space) */
int history_duplicate_avoidance_policy =
ELIMINATE_SUCCESIVE_DOUBLES; /* -D option: whether and how to avoid duplicate history entries */
char *history_format = NULL; /* -F option: format to append to history entries */
char *forget_regexp = NULL; /* -g option: keep matching input out of history */
int pass_on_sigINT_as_sigTERM = FALSE; /* -I option: send a SIGTERM to client when a SIGINT is received */
char *multi_line_tmpfile_ext = NULL; /* -M option: tmpfile extension for multi-line editor */
int nowarn = FALSE; /* -n option: suppress warnings */
int commands_children_not_wrapped = FALSE; /* -N option: always use direct mode when is waiting */
int one_shot_rlwrap = FALSE; /* -o option: whether to close the pty after writing the first line to */
char *prompt_regexp = NULL; /* -O option: only ever "cook" prompts matching this regexp */
int colour_the_prompt = FALSE; /* -p option: whether we should paint the prompt */
int renice = FALSE; /* -R option: whether to be nicer than command */
int mirror_arguments = FALSE; /* -U option: whether to mirror command's arguments */
int wait_before_prompt = 40; /* -w option: how long we wait before deciding we have a cookable prompt (in msec)) */
int polling = FALSE; /* -W option: always give select() a small (=wait_before_prompt) timeout. */
int impatient_prompt = TRUE; /* show raw prompt as soon as possible, even before we cook it. may result in "flashy" prompt */
char *substitute_prompt = NULL; /* -S option: substitute our own prompt for s */
char *filter_command = NULL; /* -z option: pipe prompts, input, output, history and completion requests through an external filter */
/* variables for global bookkeeping */
int master_pty_fd; /* master pty (rlwrap uses this to communicate with client) */
int slave_pty_sensing_fd; /* slave pty (client uses this to communicate with rlwrap,
* we keep it open after forking in order to keep track of
* client's terminal settings */
FILE *debug_fp = NULL; /* filehandle of debugging log */
char *program_name, *command_name; /* "rlwrap" (or whatever has been symlinked to rlwrap) and (base-)name of command */
char *rlwrap_command_line = ""; /* rlwrap command line (rlwrap -options command */
char *command_line = ""; /* command */
int within_line_edit = FALSE; /* TRUE while user is editing input */
pid_t command_pid = 0; /* pid of child (client), or 0 before child is born */
int i_am_child = FALSE; /* Am I child or parent? after forking, child will set this to TRUE */
int ignore_queued_input = FALSE; /* read and then ignore all characters in input queue until it is empty (i.e. read would block) */
int received_WINCH = FALSE; /* flag set in SIGWINCH signal handler: start line edit as soon as possible */
int prompt_is_still_uncooked = TRUE; /* The main loop consults this variable to determine the select() timeout: when TRUE, it is
a few millisecs, if FALSE, it is infinite.
TRUE just after receiving command output (when we still don't know whether we have a
prompt), and, importantly, at startup (so that substitute prompts get displayed even with
programs that don't have a startup message, such as cat) */
int we_just_got_a_signal_or_EOF = FALSE; /* When we got a signal or EOF, and the program sends something that ends in a newline, take it
as a response to user input - i.e. preserve a cooked prompt and just print the new output after it */
int rlwrap_already_prompted = FALSE;
int accepted_lines = 0; /* number of lines accepted (used for one-shot rlwrap) */
/* private variables */
static char *history_filename = NULL;
static int histsize = 300;
static int write_histfile = TRUE;
static char *completion_filename, *default_completion_filename;
static char *full_program_name;
static int last_option_didnt_have_optional_argument = FALSE;
static int last_opt = -1;
static char *client_term_name = NULL; /* we'll set TERM to this before exec'ing client command */
static int feed_history_into_completion_list = FALSE;
/* private functions */
static void init_rlwrap(char *command_line);
static void fork_child(char *command_name, char **argv);
static char *read_options_and_command_name(int argc, char **argv);
static void main_loop(void);
static void test_main(void);
/* options */
#ifdef GETOPT_GROKS_OPTIONAL_ARGS
static char optstring[] = "+:a::Ab:cC:d::D:e:f:F:g:hH:iIl:nNM:m::oO:p::P:q:rRs:S:t:TUvw:Wz:";
/* +: is not really documented. configure checks wheteher it works as expected
if not, GETOPT_GROKS_OPTIONAL_ARGS is undefined. @@@ */
#else
static char optstring[] = "+:a:Ab:cC:d:D:e:f:F:g:hH:iIl:nNM:m:oO:p:P:q:rRs:S:t:TUvw:Wz:";
#endif
#ifdef HAVE_GETOPT_LONG
static struct option longopts[] = {
{"always-readline", optional_argument, NULL, 'a'},
{"ansi-colour-aware", no_argument, NULL, 'A'},
{"break-chars", required_argument, NULL, 'b'},
{"complete-filenames", no_argument, NULL, 'c'},
{"command-name", required_argument, NULL, 'C'},
{"debug", optional_argument, NULL, 'd'},
{"extra-char-after-completion", required_argument, NULL, 'e'},
{"history-no-dupes", required_argument, NULL, 'D'},
{"file", required_argument, NULL, 'f'},
{"history-format", required_argument, NULL, 'F'},
{"forget-matching", required_argument, NULL, 'g'},
{"help", no_argument, NULL, 'h'},
{"history-filename", required_argument, NULL, 'H'},
{"case-insensitive", no_argument, NULL, 'i'},
{"pass-sigint-as-sigterm", no_argument, NULL, 'I'},
{"logfile", required_argument, NULL, 'l'},
{"multi-line", optional_argument, NULL, 'm'},
{"multi-line-ext", required_argument, NULL, 'M'},
{"no-warnings", no_argument, NULL, 'n'},
{"no-children", no_argument, NULL, 'N'},
{"one-shot", no_argument, NULL, 'o'},
{"only-cook", required_argument, NULL, 'O'},
{"prompt-colour", optional_argument, NULL, 'p'},
{"pre-given", required_argument, NULL, 'P'},
{"quote-characters", required_argument, NULL, 'q'},
{"remember", no_argument, NULL, 'r'},
{"renice", no_argument, NULL, 'R'},
{"histsize", required_argument, NULL, 's'},
{"substitute-prompt", required_argument, NULL, 'S'},
{"set-terminal-name", required_argument, NULL, 't'},
{"test-terminal", no_argument, NULL, 'T'},
{"mirror-arguments", no_argument, NULL, 'U'},
{"version", no_argument, NULL, 'v'},
{"wait-before-prompt", required_argument, NULL, 'w'},
{"polling", no_argument, NULL, 'W'},
{"filter", required_argument, NULL, 'z'},
{0, 0, 0, 0}
};
#endif
/*
* main function. initialises everything and calls main_loop(),
* which never returns
*/
int
main(int argc, char **argv)
{
char *command_name;
rlwrap_command_line = unsplit_with(argc, argv, " ");
init_completer();
command_name = read_options_and_command_name(argc, argv);
command_line = unsplit_with(argc - optind, argv, " ");
/* by now, optind points to , and &argv[optind] is 's argv */
if (!isatty(STDIN_FILENO) && execvp(argv[optind], &argv[optind]) < 0)
/* if stdin is not a tty, just execute */
myerror(FATAL|USE_ERRNO, "Cannot execute %s", argv[optind]);
init_rlwrap(rlwrap_command_line);
install_signal_handlers();
block_all_signals();
fork_child(command_name, argv);
if (filter_command)
spawn_filter(filter_command);
main_loop();
return 42; /* not reached, but some compilers are unhappy without this ... */
}
/*
* create pty pair and fork using my_pty_fork; parent returns immediately; child
* executes the part of rlwrap's command line that remains after
* read_options_and_command_name() has harvested rlwrap's own options
*/
static void
fork_child(char *command_name, char **argv)
{
char *arg = argv[optind], *p;
int pid;
if (mirror_arguments)
mirror_args_init(&argv[optind]);
pid = my_pty_fork(&master_pty_fd, &saved_terminal_settings, &winsize);
if (pid > 0) /* parent: */
return;
else { /* child: */
DPRINTF1(DEBUG_TERMIO, "preparing to execute %s", arg);
close_open_files_without_writing_buffers();
if (client_term_name)
mysetenv("TERM", client_term_name);
if (execvp(argv[optind], &argv[optind]) < 0) {
if (last_opt > 0 && last_option_didnt_have_optional_argument) { /* e.g. 'rlwrap -a Password: sqlpus' will try to exec 'Password:' */
for (p=" '; !(){}"; *p; p++) /* does arg need shell quoting? */
if (strchr(arg,*p)) {
arg = add3strings("'", arg,"'"); /* quote it */
break;
}
fprintf(stderr, "Did you mean '%s' to be an option argument?\nThen you should write -%c%s, without the space(s)\n",
argv[optind], last_opt, arg);
}
myerror(FATAL|USE_ERRNO, "Cannot execute %s", argv[optind]); /* stillborn child, parent will live on and display child's last gasps */
}
}
}
/*
* main loop: listen on stdin (for user input) and master pty (for command output),
* and try to write output_queue to master_pty (if it is not empty)
* This function never returns.
*/
void
main_loop()
{
int nfds;
fd_set readfds;
fd_set writefds;
int nread;
char buf[BUFFSIZE], *timeoutstr, *old_raw_prompt, *new_output_minus_prompt;
int promptlen = 0;
int leave_prompt_alone;
sigset_t no_signals_blocked;
int seen_EOF = FALSE;
struct timespec select_timeout, *select_timeoutptr;
struct timespec immediately = { 0, 0 }; /* zero timeout when child is dead */
struct timespec wait_a_little = {0, 0xBadf00d }; /* tv_usec field will be filled in when initialising */
struct timespec *forever = NULL;
wait_a_little.tv_nsec = 1000 * 1000 * wait_before_prompt;
sigemptyset(&no_signals_blocked);
init_readline("");
last_minute_checks();
pass_through_filter(TAG_OUTPUT,""); /* If something is wrong with filter, get the error NOW */
set_echo(FALSE); /* This will also put the terminal in CBREAK mode */
test_main();
/* ------------------------------ main loop -------------------------------*/
while (TRUE) {
/* listen on both stdin and pty_fd */
FD_ZERO(&readfds);
FD_SET(STDIN_FILENO, &readfds);
FD_SET(master_pty_fd, &readfds);
/* try to write output_queue to master_pty (but only if it is nonempty) */
FD_ZERO(&writefds);
if (output_queue_is_nonempty())
FD_SET(master_pty_fd, &writefds);
DPRINTF1(DEBUG_AD_HOC, "prompt_is_still_uncooked = %d", prompt_is_still_uncooked);
if (command_is_dead || ignore_queued_input) {
select_timeout = immediately;
select_timeoutptr = &select_timeout;
timeoutstr = "immediately";
} else if (prompt_is_still_uncooked || polling) {
select_timeout = wait_a_little;
select_timeoutptr = &select_timeout;
timeoutstr = "wait_a_little";
} else {
select_timeoutptr = forever; /* NULL */
timeoutstr = "forever";
}
DPRINTF1(DEBUG_TERMIO, "calling select() with timeout %s", timeoutstr);
nfds = my_pselect(1 + master_pty_fd, &readfds, &writefds, NULL, select_timeoutptr, &no_signals_blocked);
DPRINTF3(DEBUG_TERMIO, "select() returned %d (stdin|pty in|pty out = %03d), within_line_edit=%d", nfds,
100*(FD_ISSET(STDIN_FILENO, &readfds)?1:0) + 10*(FD_ISSET(master_pty_fd, &readfds)?1:0) + (FD_ISSET(master_pty_fd, &writefds)?1:0),
within_line_edit);
assert(!filter_pid || filter_is_dead || kill(filter_pid,0) == 0);
assert(command_is_dead || kill(command_pid,0) == 0);
/* check flags that may have been set by signal handlers */
if (filter_is_dead)
filters_last_words(); /* will call myerror with last words */
if (received_WINCH) { /* received_WINCH flag means we've had a WINCH while within_line_edit was FALSE */
DPRINTF0(DEBUG_READLINE, "Starting line edit as a result of WINCH ");
within_line_edit = TRUE;
restore_rl_state();
received_WINCH = FALSE;
continue;
}
if (nfds < 0) { /* exception */
if (errno == EINTR || errno == 0) { /* interrupted by signal, or by a cygwin bug (errno == 0) :-( */
continue;
} else
myerror(FATAL|USE_ERRNO, "select received exception");
} else if (nfds == 0) {
/* timeout, which can only happen when .. */
if (ignore_queued_input) { /* ... we have read all the input keystrokes that should
be ignored (i.e. those that accumulated on stdin while we
were calling an external editor) */
ignore_queued_input = FALSE;
continue;
} else if (command_is_dead) { /* ... or else, if child is dead, ... */
DPRINTF2(DEBUG_SIGNALS,
"select returned 0, command_is_dead=%d, commands_exit_status=%d",
command_is_dead, commands_exit_status);
cleanup_rlwrap_and_exit(EXIT_SUCCESS);
} else if (prompt_is_still_uncooked) { /* cooking time? */
if (we_just_got_a_signal_or_EOF) {
we_just_got_a_signal_or_EOF = FALSE; /* 1. If we got a signal/EOF before cooking time, we don't need special action
to preserve the cooked prompt.
2. Reset we_just_got_a_signal_or_EOF after a signal or EOF that didn't kill command */
continue;
}
if (!skip_rlwrap()) { /* ... or else, it is time to cook the prompt */
if (pre_given && accepted_lines == 0) {
saved_rl_state.input_buffer = mysavestring(pre_given); /* stuff pre-given text into edit buffer */
saved_rl_state.point = strlen(pre_given);
DPRINTF0(DEBUG_READLINE, "Starting line edit (because of -P option)");
within_line_edit = TRUE;
restore_rl_state();
continue;
}
if (accepted_lines == 1 && one_shot_rlwrap)
cleanup_rlwrap_and_exit(EXIT_SUCCESS);
move_cursor_to_start_of_prompt(ERASE); /* cooked prompt may be shorter than raw prompt, hence the ERASE */
/* move and erase before cooking, as we need to move/erase according
to the raw prompt */
cook_prompt_if_necessary();
DPRINTF2(DEBUG_READLINE,"After cooking, raw_prompt=%s, cooked=%s",
mangle_string_for_debug_log(saved_rl_state.raw_prompt, MANGLE_LENGTH),
mangle_string_for_debug_log(saved_rl_state.cooked_prompt, MANGLE_LENGTH));
my_putstr(saved_rl_state.cooked_prompt);
rlwrap_already_prompted = TRUE;
}
prompt_is_still_uncooked = FALSE;
} else if (polling) {
completely_mirror_slaves_special_characters();
if (mirror_arguments)
mirror_args(command_pid);
continue;
} else {
myerror(FATAL|NOERRNO, "unexpected select() timeout");
}
} else if (nfds > 0) { /* Hah! something to read or write */
/* -------------------------- read pty --------------------------------- */
/* Always first read and process the slave command's output, even if there is input waiting on stdin
(which may happen when pasting a lot of text). E.g. when pasting "a\nb\nc" into "rlwrap cat" we want
a
a
b
b
c
c
and not
a
b
c
a
b
c
*/
if (FD_ISSET(master_pty_fd, &readfds)) { /* there is something (or nothing, if EOF) to read on master pty: */
nread = read(master_pty_fd, buf, BUFFSIZE - 1); /* read it */
DPRINTF1(DEBUG_AD_HOC, "nread: %d", nread);
if (nread <= 0) {
if (command_is_dead || nread == 0) { /* we catched a SIGCHLD, or slave command has closed its stdout */
if (promptlen > 0) /* commands dying words were not terminated by \n ... */
my_putchar('\n'); /* provide the missing \n */
cleanup_rlwrap_and_exit(EXIT_SUCCESS);
} else if (errno == EINTR) { /* interrupted by signal ...*/
continue; /* ... don't worry */
} else if (! seen_EOF) { /* maybe command has just died (and SIGCHLD, whose handler sets command_is_dead is not */
mymicrosleep(50); /* yet caught) Therefore we wait a bit, */
seen_EOF = TRUE; /* set a flag */
continue; /* and try one more time (hopefully catching the signal this time round */
} else {
myerror(FATAL|USE_ERRNO, "read error on master pty");
}
}
completely_mirror_slaves_output_settings(); /* some programs (e.g. joe) need this. Gasp!! */
mirror_args(command_pid);
if (skip_rlwrap()) { /* Race condition here! The client may just have finished an emacs session and
returned to cooked mode, while its ncurses-riddled output is stil waiting for us to be processed. */
write_patiently(STDOUT_FILENO, buf, nread, "to stdout");
DPRINTF2(DEBUG_TERMIO, "read from pty and wrote to stdout %d bytes in direct mode <%s>",
nread, mangle_string_for_debug_log((buf[nread]='\0', buf), MANGLE_LENGTH));
yield();
continue;
}
DPRINTF2(DEBUG_TERMIO, "read %d bytes from pty into buffer: %s", nread, mangle_string_for_debug_log((buf[nread]='\0', buf), MANGLE_LENGTH));
remove_padding_and_terminate(buf, nread);
write_logfile(buf);
if (within_line_edit) /* client output arrives while we're editing keyboard input: */
save_rl_state(); /* temporarily disable readline and restore the screen state before readline was called */
assert(saved_rl_state.raw_prompt != NULL);
/* We *always* compute the printable part and the new raw prompt, and *always* print the printable part
There are four possibilities:
1. impatient before cooking. The raw prompt has been printed, write the new output after it
2. patient before cooking No raw prompt has been printed yet, don't print anything
3. impatient after cooking
3a no current prompt print the new output
3b some current prompt erase it, replace by current raw prompt and print new output
4. patient after cooking don't print anything
*/
/* sometimes we want to leave the prompt standing, e.g. after accepting a line, or when a signal arrived */
leave_prompt_alone =
*saved_rl_state.raw_prompt == '\0' /* saved_rl_state.raw_prompt = "" in two distinct cases: when there is actually no prompt,
or just after accepting a line, when the cursor is at the end of the prompt. In both
cases, we dont't want to move the cursor */
|| prompt_is_still_uncooked /* in this case no prompt has been displayed yet */
|| command_is_dead
|| (we_just_got_a_signal_or_EOF && strrchr(buf, '\n')); /* a signal followed by output with a newline in it: treat it as
response to user input, so leave the prompt alone */
DPRINTF3(DEBUG_READLINE, "leave_prompt_alone: %s (raw prompt: %s, prompt_is_still_uncooked: %d)",
(leave_prompt_alone? "yes" : "no"), mangle_string_for_debug_log(saved_rl_state.raw_prompt, MANGLE_LENGTH), prompt_is_still_uncooked);
if (!leave_prompt_alone) /* && (!impatient_prompt || !saved_rl_state.cooked_prompt)) */
move_cursor_to_start_of_prompt(ERASE);
else if (we_just_got_a_signal_or_EOF) {
free (saved_rl_state.raw_prompt);
saved_rl_state.raw_prompt = mysavestring(""); /* prevent reprinting the prompt */
}
if (impatient_prompt && !leave_prompt_alone)
old_raw_prompt = mysavestring(saved_rl_state.raw_prompt);
new_output_minus_prompt = process_new_output(buf, &saved_rl_state); /* chop off the part after the last newline and put this in
saved_rl_state.raw_prompt (or append buf if no newline found)*/
if (impatient_prompt) { /* in impatient mode, ALL command output is passed through the OUTPUT filter, including the prompt The
prompt, however, is filtered separately at cooking time and then displayed */
char *filtered = pass_through_filter(TAG_OUTPUT, buf);
if(!leave_prompt_alone) {
my_putstr(old_raw_prompt);
free(old_raw_prompt);
}
my_putstr(filtered);
free (filtered);
rlwrap_already_prompted = TRUE;
} else {
my_putstr(new_output_minus_prompt);
rlwrap_already_prompted = FALSE;
}
free(new_output_minus_prompt);
prompt_is_still_uncooked = TRUE;
if (within_line_edit)
restore_rl_state();
yield(); /* wait for what client has to say .... */
continue; /* ... and don't attempt to process keyboard input as long as it is talking ,
in order to avoid re-printing the current prompt (i.e. unfinished output line) */
}
/* ----------------------------- key pressed: read stdin -------------------------*/
if (FD_ISSET(STDIN_FILENO, &readfds)) { /* key pressed */
unsigned char byte_read; /* the readline function names and documentation talk about "characters" and "keys",
but we're reading bytes (i.e. unsigned chars) here, and those may very well be
part of a multi-byte character. Example: hebrew "aleph" in utf-8 is 0xd790; pressing this key
will make us read 2 bytes 0x90 and then 0xd7, (or maybe the other way round depending on endianness??)
The readline library hides all this complexity and allows one to just "pass the bytes around" */
nread = read(STDIN_FILENO, &byte_read, 1); /* read next byte of input */
assert(sizeof(unsigned char) == 1); /* gets optimised away */
if (nread <= 0)
DPRINTF1(DEBUG_TERMIO, "read from stdin returned %d", nread);
if (nread < 0)
if (errno == EINTR)
continue;
else
myerror(FATAL|USE_ERRNO, "Unexpected error");
else if (nread == 0) /* EOF on stdin */
cleanup_rlwrap_and_exit(EXIT_SUCCESS);
else if (ignore_queued_input)
continue; /* do nothing with it*/
assert(nread == 1);
DPRINTF2(DEBUG_TERMIO, "read from stdin: byte 0x%02x (%s)", byte_read, mangle_char_for_debug_log(byte_read, TRUE));
if (skip_rlwrap()) { /* direct mode, just pass it on */
/* remote possibility of a race condition here: when the first half of a multi-byte char is read in
direct mode and the second half in readline mode. Oh well... */
DPRINTF0(DEBUG_TERMIO, "passing it on (in transparent mode)");
completely_mirror_slaves_terminal_settings(); /* this is of course 1 keypress too late: we should
mirror the terminal settings *before* the user presses a key.
(maybe using rl_event_hook??) @@@FIXME @@@ HOW?*/
write_patiently(master_pty_fd, &byte_read, 1, "to master pty");
} else { /* hand it over to readline */
if (!within_line_edit) { /* start a new line edit */
DPRINTF0(DEBUG_READLINE, "Starting line edit");
within_line_edit = TRUE;
restore_rl_state();
}
if (term_eof && byte_read == term_eof && strlen(rl_line_buffer) == 0) { /* hand a term_eof (usually CTRL-D) directly to command */
char *sent_EOF = mysavestring("?");
*sent_EOF = term_eof;
put_in_output_queue(sent_EOF);
we_just_got_a_signal_or_EOF = TRUE;
free(sent_EOF);
}
else {
rl_stuff_char(byte_read); /* stuff it back in readline's input queue */
DPRINTF0(DEBUG_TERMIO, "passing it to readline");
DPRINTF2(DEBUG_READLINE, "rl_callback_read_char() (_rl_eof_char=%d, term_eof=%d)", _rl_eof_char, term_eof);
rl_callback_read_char();
}
}
}
/* -------------------------- write pty --------------------------------- */
if (FD_ISSET(master_pty_fd, &writefds)) {
flush_output_queue();
yield(); /* give slave command time to respond. If we don't do this,
nothing bad will happen, but the "dialogue" on screen will be
out of order */
}
} /* if (ndfs > 0) */
} /* while (1) */
} /* void main_loop() */
/* Read history and completion word lists */
static void
init_rlwrap(char *command_line)
{
char *homedir, *histdir, *homedir_prefix, *hostname;
time_t now;
/* open debug file if necessary */
if (debug) {
debug_fp = fopen(DEBUG_FILENAME, "w");
if (!debug_fp)
myerror(FATAL|USE_ERRNO, "Couldn't open debug file %s", DEBUG_FILENAME);
setbuf(debug_fp, NULL); /* always write debug messages to disk at once */
}
hostname = getenv("HOSTNAME") ? getenv("HOSTNAME") : "?";
now = time(NULL);
DPRINTF0(DEBUG_ALL, "-*- mode: grep -*-");
DPRINTF1(DEBUG_ALL, "command line: %s", command_line);
DPRINTF3(DEBUG_ALL, "rlwrap version %s, host: %s, time: %s", VERSION, hostname, ctime(&now));
init_terminal();
/* Determine rlwrap home dir and prefix for default history and completion filenames */
homedir = (getenv("RLWRAP_HOME") ? getenv("RLWRAP_HOME") : getenv("HOME"));
homedir_prefix = (getenv("RLWRAP_HOME") ? /* is RLWRAP_HOME set? */
add2strings(getenv("RLWRAP_HOME"), "/") : /* use $RLWRAP_HOME/_history */
add2strings(getenv("HOME"), "/.")); /* if not, use ~/._history */
/* Determine history file name and check its existence and permissions */
if (history_filename) {
histdir = mydirname(history_filename);
} else {
histdir = homedir;
history_filename = add3strings(homedir_prefix, command_name, "_history");
}
if (write_histfile) {
if (access(history_filename, F_OK) == 0) { /* already exists, can we read/write it? */
if (access(history_filename, R_OK | W_OK) != 0) {
myerror(FATAL|USE_ERRNO, "cannot read and write %s", history_filename);
}
} else { /* doesn't exist, can we create it? */
if(access(histdir, W_OK) != 0) {
if (errno == ENOENT) {
mode_t oldmask = umask(0);
if (mkdir(histdir, 0700)) /* rwx------ */
myerror(FATAL|USE_ERRNO, "cannot create directory %s", histdir);
umask(oldmask);
} else {
myerror(FATAL|USE_ERRNO, "cannot create history file %s", history_filename);
}
}
}
} else { /* ! write_histfile */
if (access(history_filename, R_OK) != 0) {
myerror(FATAL|USE_ERRNO, "cannot read %s", history_filename);
}
}
/* Initialize history */
using_history();
stifle_history(histsize);
read_history(history_filename); /* ignore errors here: history file may not yet exist, but will be created on exit */
if (feed_history_into_completion_list)
feed_file_into_completion_list(history_filename);
/* Determine completion file name (completion files are never written to,
and ignored when unreadable or non-existent) */
completion_filename =
add3strings(homedir_prefix, command_name, "_completions");
default_completion_filename =
add3strings(DATADIR, "/rlwrap/completions/", command_name);
rl_readline_name = command_name;
/* Initialise completion list (if is readable) */
if (access(completion_filename, R_OK) == 0) {
feed_file_into_completion_list(completion_filename);
} else if (access(default_completion_filename, R_OK) == 0) {
feed_file_into_completion_list(default_completion_filename);
}
}
/*
* On systems where getopt doens't handle optional argments, warn the user whenever an
* argument of the form - is seen, or whenever the argument is the last item on the command line
* (e.g. 'rlwrap -a command', which will be parsed as 'rlwrap --always-readline=command')
*/
static char *
check_optarg(char opt, int remaining)
{
if (!optarg)
last_option_didnt_have_optional_argument = TRUE; /* if this variable is set, and if command is not found,
suggest that it may have been meant
as optional argument (e.g. 'rlwrap -a password sqlplus' will try to
execute 'password sqlplus' ) */
#ifndef GETOPT_GROKS_OPTIONAL_ARGS
if (optarg && /* is there an optional arg? have a look at it: */
((optarg[0] == '-' && isalpha(optarg[1])) || /* looks like next option */
remaining == 0)) /* or is last item on command line */
myerror(WARNING|NOERRNO, "on this system, the getopt() library function doesn't\n"
"grok optional arguments, so '%s' is taken as an argument to the -%c option\n"
"Is this what you meant? If not, please provide an argument", optarg, opt);
#endif
return optarg;
}
/* find name of current option
*/
static const char *
current_option(int opt, int longindex)
{
static char buf[BUFFSIZE];
#ifdef HAVE_GETOPT_LONG
if (longindex >=0) {
sprintf(buf, "--%s", longopts[longindex].name);
return buf;
}
#endif
sprintf(buf, "-%c", opt);
return buf;
}
char *
read_options_and_command_name(int argc, char **argv)
{
int c;
char *opt_C = NULL;
int option_count = 0;
int opt_b = FALSE;
int opt_f = FALSE;
int remaining = -1; /* remaining number of arguments on command line */
int longindex = -1; /* index of current option in longopts[], set by getopt_long */
full_program_name = mysavestring(argv[0]);
program_name = mybasename(full_program_name); /* normally "rlwrap"; needed by myerror() */
rl_basic_word_break_characters = " \t\n\r(){}[],'+-=&^%$#@\";|\\";
opterr = 0; /* we do our own error reporting */
while (1) {
#ifdef HAVE_GETOPT_LONG
c = getopt_long(argc, argv, optstring, longopts, &longindex);
#else
c = getopt(argc, argv, optstring);
#endif
if (c == EOF)
break;
option_count++;
last_option_didnt_have_optional_argument = FALSE;
remaining = argc - optind;
last_opt = c;
switch (c) {
case 'a':
always_readline = TRUE;
if (check_optarg('a', remaining))
password_prompt_search_string = mysavestring(optarg);
break;
case 'A': ansi_colour_aware = TRUE; break;
case 'b':
rl_basic_word_break_characters = add3strings("\r\n \t", optarg, "");
opt_b = TRUE;
break;
case 'c': complete_filenames = TRUE; break;
case 'C': opt_C = mysavestring(optarg); break;
case 'd':
#ifdef DEBUG
if (option_count > 1)
myerror(FATAL|NOERRNO, "-d or --debug option has to be the *first* rlwrap option");
if (check_optarg('d', remaining))
debug = atoi(optarg);
else
debug = DEBUG_DEFAULT;
#else
myerror(FATAL|NOERRNO, "To use -d( for debugging), configure %s with --enable-debug and rebuild",
program_name);
#endif
break;
case 'D':
history_duplicate_avoidance_policy=atoi(optarg);
if (history_duplicate_avoidance_policy < 0 || history_duplicate_avoidance_policy > 2)
myerror(FATAL|NOERRNO, "%s option with illegal value %d, should be 0, 1 or 2",
current_option('D', longindex), history_duplicate_avoidance_policy);
break;
case 'e':
extra_char_after_completion = mysavestring(optarg);
if (strlen(extra_char_after_completion) > 1)
myerror(FATAL|NOERRNO, "-e (--extra-char-after-completion) argument should be at most one character");
break;
case 'f':
if (strncmp(optarg, ".", 10) == 0)
feed_history_into_completion_list = TRUE;
else
feed_file_into_completion_list(optarg);
opt_f = TRUE;
break;
case 'F': myerror(FATAL|NOERRNO, "The -F (--history-format) option is obsolete. Use -z \"history_format '%s'\" instead", optarg);
case 'g': forget_regexp = mysavestring(optarg); match_regexp("just testing", forget_regexp, 1); break;
case 'h': usage(EXIT_SUCCESS); /* will call exit() */
case 'H': history_filename = mysavestring(optarg); break;
case 'i':
if (opt_f)
myerror(FATAL|NOERRNO, "-i option has to precede -f options");
completion_is_case_sensitive = FALSE;
break;
case 'I': pass_on_sigINT_as_sigTERM = TRUE; break;
case 'l': open_logfile(optarg); break;
case 'n': nowarn = TRUE; break;
case 'm':
#ifndef HAVE_SYSTEM
myerror(WARNING|NOERRNO, "the -m option doesn't work on this system");
#endif
multiline_separator =
(check_optarg('m', remaining) ? mysavestring(optarg) : " \\ ");
break;
case 'M': multi_line_tmpfile_ext = mysavestring(optarg); break;
case 'N': commands_children_not_wrapped = TRUE; break;
case 'o':
one_shot_rlwrap = TRUE;
impatient_prompt = FALSE;
wait_before_prompt = 200;
break;
case 'O': prompt_regexp = mysavestring(optarg); match_regexp("just testing", prompt_regexp, 1); break;
case 'p':
colour_the_prompt = TRUE;
initialise_colour_codes(check_optarg('p', remaining) ?
colour_name_to_ansi_code(optarg) :
colour_name_to_ansi_code("Red"));
break;
case 'P':
pre_given = mysavestring(optarg);
always_readline = TRUE; /* pre_given does not work well with transparent mode */
break;
case 'q': rl_basic_quote_characters = mysavestring(optarg); break;
case 'r': remember_for_completion = TRUE; break;
case 'R': renice = TRUE; break;
case 's':
histsize = atoi(optarg);
if (histsize < 0) {
write_histfile = 0;
histsize = -histsize;
}
break;
case 'S': substitute_prompt = mysavestring(optarg);break;
case 't': client_term_name=mysavestring(optarg);break;
#ifdef DEBUG
case 'T': test_terminal(); exit(EXIT_SUCCESS);
#endif
case 'U': mirror_arguments = TRUE; break;
case 'v': printf("rlwrap %s\n", VERSION); exit(EXIT_SUCCESS);
case 'w':
wait_before_prompt = atoi(optarg);
if (wait_before_prompt < 0) {
wait_before_prompt *= -1;
impatient_prompt = FALSE;
}
break;
case 'W':
polling = TRUE; break;
case 'z': filter_command = mysavestring(optarg); break;
case '?':
assert(optind > 0);
myerror(FATAL|NOERRNO, "unrecognised option %s\ntry '%s --help' for more information", argv[optind-1], full_program_name);
case ':':
assert(optind > 0);
myerror(FATAL|NOERRNO, "option %s requires an argument \ntry '%s --help' for more information",
argv[optind-1], full_program_name);
default:
usage(EXIT_FAILURE);
}
}
if (!complete_filenames && !opt_b) { /* use / and . as default breaking characters whenever we don't complete filenames */
rl_basic_word_break_characters =
add2strings(rl_basic_word_break_characters, "/.");
}
if (optind >= argc) { /* rlwrap -a -b -c with no command specified */
if (filter_command) { /* rlwrap -z filter with no command specified */
mysignal(SIGALRM, &handle_sigALRM); /* needed for read_patiently2 */
spawn_filter(filter_command);
pass_through_filter(TAG_OUTPUT,""); /* ignore result but allow TAG_OUTPUT_OUT_OF_BAND */
cleanup_rlwrap_and_exit(EXIT_SUCCESS);
} else {
usage(EXIT_FAILURE);
}
}
if (opt_C) {
int countback = atoi(opt_C); /* investigate whether -C option argument is numeric */
if (countback > 0) { /* e.g -C 1 or -C 12 */
if (argc - countback < optind) /* -C 666 */
myerror(FATAL|NOERRNO, "when using -C %d you need at least %d non-option arguments",
countback, countback);
else if (argv[argc - countback][0] == '-') /* -C 2 perl -d blah.pl */
myerror(FATAL|NOERRNO, "the last argument minus %d appears to be an option!",
countback);
else { /* -C 1 perl test.cgi */
command_name = mysavestring(mybasename(argv[argc - countback]));
}
} else if (countback == 0) { /* -C name1 name2 or -C 0 */
if (opt_C[0] == '0' && opt_C[1] == '\0') /* -C 0 */
myerror(FATAL|NOERRNO, "-C 0 makes no sense");
else if (strlen(mybasename(opt_C)) != strlen(opt_C)) /* -C dir/name */
myerror(FATAL|NOERRNO, "-C option argument should not contain directory components");
else if (opt_C[0] == '-') /* -C -d (?) */
myerror(FATAL|NOERRNO, "-C option needs argument");
else /* -C name */
command_name = opt_C;
} else { /* -C -2 */
myerror (FATAL|NOERRNO, "-C option needs string or positive number as argument, perhaps you meant -C %d?",
-countback);
}
} else { /* no -C option given, use command name */
command_name = mysavestring(mybasename(argv[optind]));
}
assert(command_name != NULL);
return command_name;
}
/*
* Since version 0.24, rlwrap only writes to master_pty
* asynchronously, keeping a queue of pending output. The readline
* line handler calls put_in_output_queue(user_input) , while
* main_loop calls flush_output_queue() as long as there is something
* in the queue.
*/
static char *output_queue; /* NULL when empty */
int
output_queue_is_nonempty()
{
return (output_queue ? TRUE : FALSE);
}
void
put_in_output_queue(char *stuff)
{
output_queue = append_and_free_old(output_queue, stuff);
DPRINTF3(DEBUG_TERMIO,"put %d bytes in output queue (which now has %d bytes): %s",
(int) strlen(stuff), (int) strlen(output_queue), mangle_string_for_debug_log(stuff, 20));
}
/*
* flush the output queue, writing its contents to master_pty_fd
* never write more than one line, or BUFFSIZE in one go
*/
void
flush_output_queue()
{
int nwritten, queuelen, how_much;
char *old_queue = output_queue;
char *nl;
if (!output_queue)
return;
queuelen = strlen(output_queue);
nl = strchr(output_queue, '\n');
how_much = min(BUFFSIZE, nl ? 1+ nl - output_queue : queuelen); /* never write more than one line, and never more than BUFFSIZE in one go */
nwritten = write(master_pty_fd, output_queue, how_much);
assert(nwritten <= strlen(output_queue));
if (debug) {
char scratch = output_queue[nwritten];
output_queue[nwritten] = '\0'; /* temporarily replace the last written byte + 1 by a '\0' */
DPRINTF3(DEBUG_TERMIO,"flushed %d of %d bytes from output queue to pty: %s",
nwritten, queuelen, mangle_string_for_debug_log(output_queue, MANGLE_LENGTH));
output_queue[nwritten] = scratch;
}
if (nwritten < 0) {
switch (nwritten) {
case EINTR:
case EAGAIN:
return;
default:
myerror(FATAL|USE_ERRNO, "write to master pty failed");
}
}
if (!output_queue[nwritten]) /* nothing left in queue */
output_queue = NULL;
else
output_queue = mysavestring(output_queue + nwritten); /* this much is left to be written */
free(old_queue);
}
void
cleanup_rlwrap_and_exit(int status)
{
unblock_all_signals();
DPRINTF0(DEBUG_TERMIO, "Cleaning up");
if (write_histfile && (histsize==0 || history_total_bytes() > 0)) /* avoid creating empty .speling_eror_history file after typo */
write_history(history_filename); /* ignore errors */
close_logfile();
DPRINTF4(DEBUG_SIGNALS, "command_pid: %d, commands_exit_status: %x, filter_pid: %d, filters_exit_status: %x",
command_pid, commands_exit_status, filter_pid, filters_exit_status);
mymicrosleep(10); /* we may have got an EOF or EPIPE because the filter or command died, but this doesn't mean that
SIGCHLD has been caught already. Taking a little nap now improves the chance that we will catch it
(no grave problem if we miss it, but diagnostics, exit status and transparent signal handling depend on it) */
if (filter_pid)
kill_filter();
else if (filter_is_dead) {
int filters_killer = killed_by(filters_exit_status);
myerror(WARNING|NOERRNO, (filters_killer ? "filter was killed by signal %d (%s)" :
WEXITSTATUS(filters_exit_status) ? "filter died" : "filter exited"), filters_killer, signal_name(filters_killer));
}
if (debug)
debug_postmortem();
if (terminal_settings_saved)
if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &saved_terminal_settings) < 0) /* ignore errors (almost dead anyway) */
; /* fprintf(stderr, "Arggh\n"); don't use myerror!!*/
if (!newline_came_last) /* print concluding newline, if necessary */
my_putstr("\n");
if (status != EXIT_SUCCESS) /* rlwrap itself has failed, rather than the wrapped command */
exit(status);
else {
int commands_killer = killed_by(commands_exit_status);
if (commands_killer)
suicide_by(commands_killer, commands_exit_status); /* command terminated by signal, make rlwrap's
parent believe rlwrap was killed by it */
else
exit(WEXITSTATUS(commands_exit_status)); /* propagate command's exit status */
}
}
static void test_main() {
#ifdef DEBUG
if(debug & DEBUG_TEST_MAIN) {
/* test, test */
test_unbackspace("abc","abc");
test_unbackspace("abc\bd","abd");
test_unbackspace("abc\r","abc");
test_unbackspace("abc\rd","dbc");
test_unbackspace("abc\bd\re","ebd");
test_unbackspace("abc\rde\rf","fec");
puts("tests OK");
exit(0);
}
#endif
}
rlwrap-0.42/src/completion.rb 0000644 0001751 0000144 00000026430 12407054356 013164 0000000 0000000 /* completion.c is generated from completion.rb by the program rbgen
(cf. http://libredblack.sourceforge.net/)
completion.rb: maintaining the completion list, my_completion_function()
(callback for readline lib)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License , or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
You may contact the author by:
e-mail: hlub@knoware.nl
*/
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include "rlwrap.h"
#ifdef assert
#undef assert
#endif
int completion_is_case_sensitive = 1;
int
compare(const char *string1, const char *string2)
{
const char *p1;
const char *p2;
int count;
for (p1 = string1, p2 = string2, count = 0;
*p1 && *p2 && count < BUFFSIZE; p1++, p2++, count++) {
char c1 = completion_is_case_sensitive ? *p1 : tolower(*p1);
char c2 = completion_is_case_sensitive ? *p2 : tolower(*p2);
if (c1 != c2)
return (c1 < c2 ? -1 : 1);
}
if ((*p1 && *p2) || (!*p1 && !*p2))
return 0;
return (*p1 ? 1 : -1);
}
#ifdef malloc
# undef malloc
#endif
#define malloc(x) mymalloc(x) /* This is a bit evil, but there is no other way to make libredblack use mymalloc() */
/* This file has to be processed by the program rbgen */
%%rbgen
%type char
%cmp compare
%access pointer
%static
%omit
%%rbgen
/* forward declarations */
static struct rbtree *completion_tree;
static char *my_history_completion_function(char *prefix, int state);
static void print_list(void);
static void
my_rbdestroy(struct rbtree *rb)
{ /* destroy rb tree, freeing the keys first */
const char *key, *lastkey;
for (key = rbmin(rb);
key;
lastkey = key, key =
rblookup(RB_LUGREAT, key, rb), free((void *)lastkey))
rbdelete(key, rb);
rbdestroy(rb);
}
static void
print_list()
{
const char *word;
RBLIST *completion_list = rbopenlist(completion_tree); /* uses mymalloc() internally, so no chance of getting a NULL pointer back */
printf("Completions:\n");
while ((word = rbreadlist(completion_list)))
printf("%s\n", word);
rbcloselist(completion_list);
}
static char *rbtree_to_string(const struct rbtree *rb, int max_items) {
const char *word;
char *result = NULL;
int i;
RBLIST *list = rbopenlist(rb);
for (i = 0; (word = rbreadlist(list)) && (i < max_items); i++) {
if (i > 0)
result = append_and_free_old(result, ", ");
result = append_and_free_old(result, word);
}
if (i >= max_items)
result = append_and_free_old(result, "...");
rbcloselist(list);
return result;
}
void
init_completer()
{
completion_tree = rbinit();
}
void
add_word_to_completions(const char *word)
{
rbsearch(mysavestring(word), completion_tree); /* the tree stores *pointers* to the words, we have to allocate copies of them ourselves
freeing the tree will call free on the pointers to the words
valgrind reports the copies as lost, I don't understand this.' */
}
void
remove_word_from_completions(const char *word)
{
free((char *) rbdelete(word, completion_tree)); /* why does rbdelete return a const *? I want to be able to free it! */
}
void
feed_line_into_completion_list(const char *line)
{
char **words = split_with(line, rl_basic_word_break_characters);
char **plist, *word;
for(plist = words;(word = *plist); plist++)
add_word_to_completions(word);
free_splitlist(words);
}
void
feed_file_into_completion_list(const char *completions_file)
{
FILE *compl_fp;
char buffer[BUFFSIZE];
if ((compl_fp = fopen(completions_file, "r")) == NULL)
myerror(FATAL|USE_ERRNO, "Could not open %s", completions_file);
while (fgets(buffer, BUFFSIZE - 1, compl_fp) != NULL) {
buffer[BUFFSIZE - 1] = '\0'; /* make sure buffer is properly terminated (it should be anyway, according to ANSI) */
feed_line_into_completion_list(buffer);
}
if (! feof(compl_fp) && ferror(compl_fp)) /* at least in GNU libc, errno will be set in this case. If not, no harm is done */
myerror(FATAL|USE_ERRNO, "Couldn't read completions from %s", completions_file);
fclose(compl_fp);
/* print_list(); */
}
#define COMPLETE_FILENAMES 1
#define COMPLETE_FROM_LIST 2
#define COMPLETE_USERNAMES 4
#define FILTER_COMPLETIONS 8
#define COMPLETE_PARANORMALLY 16 /* read user's thoughts */
int
get_completion_type()
{ /* some day, this function will inspect the current line and make rlwrap complete
differently according to the word *preceding* the one we're completing ' */
return (COMPLETE_FROM_LIST | (complete_filenames ? COMPLETE_FILENAMES : 0) | (filter_pid ? FILTER_COMPLETIONS : 0));
}
/* helper function for my_completion_function */
static int
is_prefix(const char *s0, const char *s1)
{ /* s0 is prefix of s1 */
const char *p0, *p1;
int count;
for (count = 0, p0 = s0, p1 = s1; *p0; count++, p0++, p1++) {
char c0 = completion_is_case_sensitive ? *p0 : tolower(*p0);
char c1 = completion_is_case_sensitive ? *p1 : tolower(*p1);
if (c0 != c1 || count == BUFFSIZE)
return FALSE;
}
return TRUE;
}
/* See readline doumentation: this function is called by readline whenever a completion is needed. The first time state == 0,
whwnever the user presses TAB to cycle through the list, my_completion_function() is called again, but then with state != 0
It should return the completion, which then will be freed by readline (so we'll hand back a copy instead of the real thing) ' */
char *
my_completion_function(char *prefix, int state)
{
static struct rbtree *scratch_tree = NULL;
static RBLIST *scratch_list = NULL; /* should remain unchanged between invocations */
int completion_type, count;
const char *word;
const char *completion;
rl_completion_append_character = *extra_char_after_completion;
if (*prefix == '!')
return my_history_completion_function(prefix + 1, state);
if (state == 0) { /* first time we're called for this prefix ' */
if (scratch_list)
rbcloselist(scratch_list);
if (scratch_tree)
my_rbdestroy(scratch_tree);
scratch_tree = rbinit(); /* allocate scratch_tree. We will use this to get a sorted list of completions */
/* now find all possible completions: */
completion_type = get_completion_type();
DPRINTF2(DEBUG_ALL, "completion_type: %d, filter_pid: %d", completion_type, filter_pid);
if (completion_type & COMPLETE_FROM_LIST) {
for (word = rblookup(RB_LUGTEQ, prefix, completion_tree); /* start with first word >= prefix */
word && is_prefix(prefix, word); /* as long as prefix is really prefix of word */
word = rblookup(RB_LUGREAT, word, completion_tree)) { /* find next word in list */
rbsearch(mysavestring(word), scratch_tree); /* insert fresh copy of the word */
/* DPRINTF1(DEBUG_COMPLETION, "Adding %s to completion list ", word); */
}
}
if (completion_type & COMPLETE_FILENAMES) {
change_working_directory();
DPRINTF1(DEBUG_COMPLETION, "Starting milking of rl_filename_completion_function, prefix = <%s> ", prefix);
for (count = 0;
(word = copy_and_free_string_for_malloc_debug(rl_filename_completion_function(prefix, count)));
count++) { /* using rl_filename_completion_function means
that completing filenames will always be case-sensitive */
DPRINTF1(DEBUG_COMPLETION, "Adding <%s> to completion list ", word);
rbsearch(word, scratch_tree);
}
}
scratch_list = rbopenlist(scratch_tree); /* OK, we now have our list with completions. We may have to filter it: */
if (completion_type & FILTER_COMPLETIONS) {
/* build message (filter_food) consisting of: input line, TAB, prefix, TAB, completion_1 SPACE completion_2 .... */
char *word, *filtered, **words, **plist, **fragments;
int length = strlen(rl_line_buffer) + strlen(prefix) + 3;
char *filter_food = mymalloc(length);
assert(strchr(rl_line_buffer,'\n') == NULL);
sprintf(filter_food, "%s\t%s\t", rl_line_buffer, prefix);
while((completion = rbreadlist(scratch_list))) {
filter_food = append_and_free_old(filter_food, completion);
filter_food = append_and_free_old(filter_food, " ");
}
/* feed message to filter */
filtered = pass_through_filter(TAG_COMPLETION, filter_food);
free(filter_food);
rbcloselist(scratch_list); /* throw away old list, and */
DPRINTF1(DEBUG_ALL, "Filtered: %s", mangle_string_for_debug_log(filtered, 40));
/* parse contents */
fragments = split_on_single_char(filtered, '\t');
if (!fragments[0] || ! fragments[1] || !fragments[2] ||
strncmp(fragments[0], rl_line_buffer, length) || strncmp(fragments[1], prefix,length)) {
myerror(FATAL|NOERRNO, "filter has illegally messed with completion message\n"); /* it should ONLY have changed the completion word list */
}
my_rbdestroy(scratch_tree); /* burn the old scratch tree (but leave the completion tree alone) */
scratch_tree = rbinit(); /* now grow a new one */
words = split_with(fragments[2], " ");
for(plist = words;(word = *plist); plist++) {
if (!*word)
continue; /* empty space at beginning or end of the word list results in an empty word. skip it now */
rbsearch(mysavestring(word), scratch_tree); /* add the filtered completions to the new scratch tree */
DPRINTF1(DEBUG_COMPLETION, "Adding %s to completion list ", word);
}
free_splitlist(words);
free_splitlist(fragments);
free(filtered);
scratch_list = rbopenlist(scratch_tree); /* flatten the tree into a new list */
}
DPRINTF1(DEBUG_COMPLETION, "scratch list: %s", rbtree_to_string(scratch_tree, 6));
} /* if state == 0 */
/* we get here each time the user presses TAB to cycle through the list */
assert(scratch_tree != NULL);
assert(scratch_list != NULL);
if ((completion = rbreadlist(scratch_list))) { /* read next possible completion */
struct stat buf;
char *copy_for_readline = malloc_foreign(strlen(completion)+1);
strcpy(copy_for_readline, completion);
/* This doesn ... (comment disappeared) */
rl_filename_completion_desired = rl_filename_quoting_desired = (stat(completion, &buf) ? FALSE : TRUE);
DPRINTF1(DEBUG_COMPLETION, "Returning completion to readline: <%s>", copy_for_readline);
return copy_for_readline; /* we cannot just return it as readline will free it (and make rlwrap explode) */
} else {
return NULL;
}
}
static char *
my_history_completion_function(char *prefix, int state)
{
while (next_history());
if (state || history_search_prefix(prefix, -1) < 0)
return NULL;
return mysavestring(current_history()->line);
}
/* The following sets edit modes for GNU EMACS
Local Variables:
mode:c
End: */
rlwrap-0.42/src/pty.c 0000644 0001751 0000144 00000035367 12407121400 011440 0000000 0000000 /* pty.c: pty handling */
/* This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License , or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
You may contact the author by:
e-mail: hlub@knoware.nl
*/
#include "rlwrap.h"
/*local vars */
static int always_echo = FALSE;
/* global var */
int slave_pty_sensing_fd = -1;
static char *sensing_pty = "uninitialized";
pid_t
my_pty_fork(int *ptr_master_fd,
const struct termios *slave_termios,
const struct winsize *slave_winsize)
{
int fdm, fds = -1;
int ttyfd, timeout;
pid_t pid;
const char *slave_name;
struct termios pterm;
int only_sigchld[] = { SIGCHLD, 0 };
ptytty_openpty(&fdm, &fds, &slave_name);
block_signals(only_sigchld); /* block SIGCHLD until we have had a chance to install a handler for it after the fork() */
if ((pid = fork()) < 0) {
myerror(FATAL|USE_ERRNO, "Cannot fork");
return(42); /* the compiler may not know that myerror() won't return */
} else if (pid == 0) { /* child */
DEBUG_RANDOM_SLEEP;
i_am_child = TRUE; /* remember who I am */
unblock_all_signals();
close(fdm); /* fdm not used in child */
ptytty_control_tty(fds, slave_name);
if (dup2(fds, STDIN_FILENO) != STDIN_FILENO) /* extremely unlikely */
myerror(FATAL|USE_ERRNO, "dup2 to stdin failed");
if (isatty(STDOUT_FILENO) && dup2(fds, STDOUT_FILENO) != STDOUT_FILENO)
myerror(FATAL|USE_ERRNO, "dup2 to stdout failed");
if (isatty(STDERR_FILENO) && dup2(fds, STDERR_FILENO) != STDERR_FILENO)
myerror(FATAL|USE_ERRNO, "dup2 to stderr failed");
if (fds > STDERR_FILENO)
close(fds);
if (slave_termios != NULL)
if (tcsetattr(STDIN_FILENO, TCSANOW, slave_termios) < 0)
myerror(FATAL|USE_ERRNO, "tcsetattr failed on slave pty");
return (0);
} else { /* parent */
srand(pid); DEBUG_RANDOM_SLEEP;
command_pid = pid; /* the SIGCHLD signal handler needs this global variable */
*ptr_master_fd = fdm;
/* Try to find a suitable file descriptor to sense the state of the slave pty */
/* At least on Solaris, we have to use the slave pty itself, but this works only after it has been set up in the child */
/* This may take some time, hence the (increasing) timeout below */
for(timeout = 10; timeout < 2000 && slave_pty_sensing_fd < 0; timeout *= 2) {
if (tcgetattr(fdm, &pterm) == 0) { /* if we can do a tcgetattr on the master, assume that it reflects the slave's
terminal settings (at least on Linux and FreeBSD, this works), and use it as
slave_pty_sensing_fd, to keep tabs on slave terminal settings. In this case we can
close fds (the slave), avoiding problems with lost output on FreeBSD when the slave dies */
slave_pty_sensing_fd = fdm;
sensing_pty = "master";
close(fds);
} else if (mymicrosleep(timeout), /* wait a little */
tcgetattr(fds, &pterm) == 0) { /* ... then try slave pty */
slave_pty_sensing_fd = fds;
sensing_pty = "slave"; /* keep the slave pty open to get its terminal settings */
}
}
if (slave_pty_sensing_fd < 0) /* both master and slave unusable: give up */
myerror(FATAL|USE_ERRNO, "cannot determine terminal mode of slave command");
DPRINTF1(DEBUG_TERMIO, "Using %s pty to sense slave settings in parent", sensing_pty);
if (!isatty(STDOUT_FILENO) || !isatty(STDERR_FILENO)) { /* stdout or stderr redirected? */
ttyfd = open("/dev/tty", O_WRONLY); /* open users terminal */
DPRINTF1(DEBUG_TERMIO, "stdout or stderr are not a terminal, opening /dev/tty with fd=%d", ttyfd);
if (ttyfd <0)
myerror(FATAL|USE_ERRNO, "Could not open /dev/tty");
if (dup2(ttyfd, STDOUT_FILENO) != STDOUT_FILENO)
myerror(FATAL|USE_ERRNO, "dup2 of stdout to ttyfd failed");
if (dup2(ttyfd, STDERR_FILENO) != STDERR_FILENO)
myerror(FATAL|USE_ERRNO, "dup2 of stderr to ttyfd failed");
close (ttyfd);
}
errno = 0;
if (renice) {
int retval = nice(1);
if (retval < 0 && errno)
myerror(FATAL|USE_ERRNO, "could not increase my own niceness");
}
if (slave_winsize != NULL)
if (ioctl(slave_pty_sensing_fd, TIOCSWINSZ, slave_winsize) < 0)
myerror(FATAL|USE_ERRNO, "TIOCSWINSZ failed on %s pty", sensing_pty); /* This is done in parent and not in child as that would fail on Solaris (why?) */
return (pid);
}
}
int
slave_is_in_raw_mode()
{
struct termios *pterm_slave;
static int been_warned = 0;
int in_raw_mode;
if (always_echo)
return FALSE;
if (command_is_dead)
return FALSE; /* filter last words too (even if ncurses-ridden) */
if (!(pterm_slave = my_tcgetattr(slave_pty_sensing_fd, "slave pty"))) {
if (been_warned++ == 1) /* only warn once, but not the first time (as this usually means that the rlwrapped command has just died)
- this is still a race when signals get delivered very late*/
myerror(WARNING|USE_ERRNO, "tcgetattr error on slave pty (from parent process)");
return TRUE;
}
in_raw_mode = !(pterm_slave -> c_lflag & ICANON);
myfree(pterm_slave);
return in_raw_mode;
}
void
mirror_slaves_echo_mode()
{ /* important e.g. when slave command asks for password */
struct termios *pterm_slave = NULL;
int should_echo_anyway = always_echo || (always_readline && !dont_wrap_command_waits());
if ( !(pterm_slave = my_tcgetattr(slave_pty_sensing_fd, "slave pty")) ||
command_is_dead ||
always_echo
)
/* race condition here: SIGCHLD may not yet have been caught */
return;
assert (pterm_slave != NULL);
if (tcsetattr(STDIN_FILENO, TCSANOW, pterm_slave) < 0 && errno != ENOTTY) /* @@@ */
myerror(FATAL|USE_ERRNO, "cannot prepare terminal (tcsetattr error on stdin)");
term_eof = pterm_slave -> c_cc[VEOF];
/* if the --always-readline option is set with argument "assword:", determine whether prompt ends with "assword:\s" */
if (should_echo_anyway && password_prompt_search_string) {
char *p, *q;
DPRINTF2(DEBUG_READLINE, "matching prompt <%s> and password search string <%s>..", saved_rl_state.raw_prompt, password_prompt_search_string);
assert(strlen(saved_rl_state.raw_prompt) < BUFFSIZE);
p = saved_rl_state.raw_prompt + strlen(saved_rl_state.raw_prompt) - 1;
q =
password_prompt_search_string + strlen(password_prompt_search_string) -
1;
while (*p == ' ') /* skip trailing spaces in prompt */
p--;
while (p >= saved_rl_state.raw_prompt && q >= password_prompt_search_string)
if (*p-- != *q--)
break;
if (q < password_prompt_search_string) /* found "assword:" */
should_echo_anyway = FALSE;
DPRINTF1(DEBUG_READLINE,".. result: should_echo_anyway = %d", should_echo_anyway);
}
if (!command_is_dead && (should_echo_anyway || pterm_slave->c_lflag & ECHO)) {
redisplay = TRUE;
} else {
redisplay = FALSE;
}
if (pterm_slave)
free(pterm_slave);
set_echo(redisplay); /* This is a bit weird: we want echo off all the time, because readline takes care
of echoing, but as readline uses the current ECHO mode to determine whether
you want echo or not, we must set it even if we know that readline will switch it
off immediately */
}
void
write_EOF_to_master_pty()
{
struct termios *pterm_slave = my_tcgetattr(slave_pty_sensing_fd, "slave pty");
char *sent_EOF = mysavestring("?");
*sent_EOF = (pterm_slave && pterm_slave->c_cc[VEOF] ? pterm_slave->c_cc[VEOF] : 4) ; /*@@@ HL shouldn't we directly mysavestring(pterm_slave->c_cc[VEOF]) ??*/
DPRINTF1(DEBUG_TERMIO, "Sending %s", mangle_string_for_debug_log(sent_EOF, MANGLE_LENGTH));
put_in_output_queue(sent_EOF);
myfree(pterm_slave);
free(sent_EOF);
}
/* @@@ The next fuction is probably superfluous */
void
write_EOL_to_master_pty(char *received_eol)
{
struct termios *pterm_slave = my_tcgetattr(slave_pty_sensing_fd, "slave pty");
char *sent_eol = mysavestring("?");
*sent_eol = *received_eol;
if (pterm_slave) {
switch (*received_eol) {
case '\n':
if (pterm_slave->c_iflag & INLCR)
*sent_eol = '\r';
break;
case '\r':
if (pterm_slave->c_iflag & IGNCR)
return;
if (pterm_slave->c_iflag & ICRNL)
*sent_eol = '\n';
}
}
put_in_output_queue(sent_eol);
myfree(pterm_slave);
free(sent_eol);
}
void
completely_mirror_slaves_terminal_settings()
{
struct termios *pterm_slave;
DEBUG_RANDOM_SLEEP;
pterm_slave = my_tcgetattr(slave_pty_sensing_fd, "slave pty");
log_terminal_settings(pterm_slave);
if (pterm_slave && tcsetattr(STDIN_FILENO, TCSANOW, pterm_slave) < 0 && errno != ENOTTY)
; /* myerror(FATAL|USE_ERRNO, "cannot prepare terminal (tcsetattr error on stdin)"); */
myfree(pterm_slave);
DEBUG_RANDOM_SLEEP;
}
void
completely_mirror_slaves_output_settings()
{
struct termios *pterm_stdin, *pterm_slave;
DEBUG_RANDOM_SLEEP;
pterm_stdin = my_tcgetattr(STDIN_FILENO, "stdin");
pterm_slave = my_tcgetattr(slave_pty_sensing_fd, "slave pty");
if (pterm_slave && pterm_stdin) { /* no error message - we can be called while slave is already dead */
pterm_stdin -> c_oflag = pterm_slave -> c_oflag;
tcsetattr(STDIN_FILENO, TCSANOW, pterm_stdin);
}
myfree(pterm_slave);
myfree(pterm_stdin);
DEBUG_RANDOM_SLEEP;
}
/* rlwrap's transparency depends on knowledge of the slave commands terminal settings, which are kept in its
termios structure. In many cases it is enough to inspect those settings after the user has pressed a key
(e.g.: user presses a key - rlwrap inspects slaves ECHO flag - rlwrap echoes the keypress (or not)
But some keypresses are directly handled by the terminal driver, e.g.: user presses CTRL-C - driver
inspects rlwrap's ISIG flag and c_cc[VINTR] character - driver sends a sigINT to rlwrap.
Rlwrap doesn't get a chance to intervene - except by unsetting ISIG beforehand and handling the interrupt
key itself. We cannot, however, just bind the key to a readline action self-insert(key), as this wouldn't
interrupt an ongoing line edit.
Rlwrap solves this problem by copying the relevant flags and special characters from the slave pty to
stdin/stdout. Of course, ideally this should happen *before* the user presses her key. This can be done by
calling rlwrap with the -W (--polling) option.
*/
/* Many termios flags and characters are serial-specific and will never be used on a pty
Possible exceptions (cf: http://www.lafn.org/~dave/linux/termios.txt)
ISTRIP IGNCR (and related flags) and all the c_cc characters (although only VINTR seems to be changed
in practice, e.g. by emacs to CTRL-G)
*/
void
completely_mirror_slaves_special_characters()
{
struct termios *pterm_stdin, *pterm_slave;
DEBUG_RANDOM_SLEEP;
pterm_stdin = my_tcgetattr(STDIN_FILENO, "stdin");
pterm_slave = my_tcgetattr(slave_pty_sensing_fd, "slave pty");
if (pterm_slave && pterm_stdin) { /* no error message - we can be called while slave is already dead */
int isig_stdin = pterm_stdin -> c_lflag & ISIG;
cc_t ic_stdin = pterm_stdin -> c_cc[VINTR];
int isig_slave = pterm_slave -> c_lflag & ISIG;
cc_t ic_slave = pterm_slave -> c_cc[VINTR];
if ((isig_stdin == isig_slave) && (ic_stdin == ic_slave)) /* nothing to do */
return;
DPRINTF4(DEBUG_TERMIO,"stdin interrupt handling copied from slave: ISIG: %0x->%0x, VINTR: %0x->%0x",
isig_stdin, isig_slave, ic_stdin, ic_slave);
pterm_stdin -> c_cc[VINTR] = ic_slave;
pterm_stdin -> c_lflag ^= (isig_slave ^ ISIG); /* copy ISIG bit from slave */
tcsetattr(STDIN_FILENO, TCSANOW, pterm_stdin);
}
myfree(pterm_slave);
myfree(pterm_stdin);
DEBUG_RANDOM_SLEEP;
}
/* returns TRUE if the -N option has been specified, we can read /proc//wchan,
(which happens only on linux, as far as I know) and what we read there contains the word "wait"
meaning (presumably...) that command is waiting for one of its children
if otherwise returns FALSE
*/
int dont_wrap_command_waits() {
static char command_wchan[MAXPATHLEN+1];
static int initialised = FALSE;
static int wchan_fd;
static int been_warned = 0;
char buffer[BUFFSIZE];
int nread, result = FALSE;
DEBUG_RANDOM_SLEEP;
if (!commands_children_not_wrapped)
return FALSE;
if (!initialised) { /* first time we're called after birth of child */
snprintf2(command_wchan, MAXPATHLEN , "%s/%d/wchan", PROC_MOUNTPOINT, command_pid);
initialised = TRUE;
}
if (command_is_dead)
return TRUE; /* This is lazy!! signal may not have been delivered @@@ */
wchan_fd = open(command_wchan, O_RDONLY);
if (wchan_fd < 0) {
if (been_warned++ == 0) {
myerror(WARNING|USE_ERRNO, "you probably specified the -N (--no-children) option"
" - but spying\non %s's wait status does not work on"
" your system, as we cannot read %s", command_name, command_wchan);
}
return FALSE;
}
if (((nread = read(wchan_fd, buffer, BUFFSIZE -1)) > 0)) {
buffer[nread] = '\0';
DPRINTF1(DEBUG_READLINE, "read commands wchan: <%s> ", buffer);
result = (strstr(buffer, "wait") != NULL);
}
close(wchan_fd);
DEBUG_RANDOM_SLEEP;
return result;
}
int skip_rlwrap() { /* this function is called from sigTSTP signal handler. Is it re-entrant? */
int retval = FALSE;
DEBUG_RANDOM_SLEEP;
if (dont_wrap_command_waits())
retval = TRUE;
else if (always_readline)
retval = FALSE;
else if (slave_is_in_raw_mode())
retval= TRUE;
DEBUG_RANDOM_SLEEP;
return retval;
}
rlwrap-0.42/src/utils.c 0000644 0001751 0000144 00000060307 12406647411 011772 0000000 0000000 /* This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License , or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
You may contact the author by:
e-mail: hlub@knoware.nl
*/
#include "rlwrap.h"
char slaves_working_directory[MAXPATHLEN+1];
static FILE *log_fp;
/* Give up the processor so that other processes (like command) can have their say. Especially useful with multi-line
input: if we, after writing a line to the inferior command, would return to the main select() loop immediately, we
would find more output to write, and keep blathering away without giving the poor command time to say something
back */
void
yield()
{
DPRINTF0(DEBUG_TERMIO, "yield...");
#if 0 /* If command writes some output and immediately starts a long computation, sched_yield() will not return for a
long time,and rlwrap will not see the output for all that time. The "poor mans sched_yield" with select
actually works better! */
sched_yield();
#else
{ struct timeval a_few_millisecs = { 0, 1000 };
select(0, NULL, NULL, NULL, &a_few_millisecs); /* poor man's sched_yield() */
}
#endif
}
static volatile int signal_handled = FALSE;
#ifdef HAVE_REAL_PSELECT
void zero_select_timeout () {
signal_handled = TRUE;
}
#else
#define until_hell_freezes NULL ;
static struct timeval * volatile pmy_select_timeout_tv; /* The SIGCHLD handler sets this variable (see zero_select_timeout() below) to make
select() return immediately when a child has died. gcc (4.8 and higher) may optimize it
into a register, which won't work: hence the "volatile" keyword */
static struct timeval my_select_timeout_tv;
void zero_select_timeout () {
my_select_timeout_tv.tv_sec = 0;
my_select_timeout_tv.tv_usec = 0;
pmy_select_timeout_tv = &my_select_timeout_tv;
signal_handled = TRUE;
}
#endif
/*
Even though even older linux systems HAVE PSELECT, is is non-atomic: signal handlers may (and
generally will) run between the unblocking of the signals and the select call (which will
then wait untill hell freezes over) Therefore we always convert the contents op
ptimeout_ts into to a static struct timeval my_select_timeout_tv, and use the function
zero_select_timeout to set this to {0,0} from within a signal handler, which will then
make select return immediately. (Linus Torvalds mentions this trick in
http://lkml.indiana.edu/hypermail/linux/kernel/0506.1/1191.html),
As I know of no reliable way to distiguish real pselect from fake pselect at configure
time HAVE_REAL_PSELECT will be undefined on all systems, even those that do have a genuine
pselect.
*/
int
my_pselect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *ptimeout_ts, const sigset_t *sigmask) {
#ifdef HAVE_REAL_PSELECT
return pselect(n, readfds, writefds, exceptfds, ptimeout_ts, sigmask);
#else
int retval;
sigset_t oldmask;
if (ptimeout_ts) { /* convert timespec e.g {0,40000000} to timeval {0, 40000} */
pmy_select_timeout_tv = &my_select_timeout_tv;
pmy_select_timeout_tv -> tv_sec = ptimeout_ts -> tv_sec;
pmy_select_timeout_tv -> tv_usec = ptimeout_ts -> tv_nsec / 1000;
} else
pmy_select_timeout_tv = until_hell_freezes;
signal_handled = FALSE;
sigprocmask(SIG_SETMASK, sigmask, &oldmask);
/* most signals will be catched HERE (and their handlers will set my_select_timeout_tv to {0,0}) */
retval = select(n, readfds, writefds, exceptfds, pmy_select_timeout_tv);
/* but even if they are slow off the mark and get catched HERE the code 3 lines below will notice */
sigprocmask(SIG_SETMASK, &oldmask, NULL);
if (signal_handled && retval >= 0) {
errno = EINTR;
return -1;
} else {
return retval;
}
#endif
}
struct termios *
my_tcgetattr(int fd, char *which) /* the 'which' argument is only needed for error reporting */
{
struct termios *pterm =
(struct termios *)mymalloc(sizeof(struct termios));
return tcgetattr(fd, pterm) < 0 ? NULL : pterm;
}
void
do_nothing(int unused)
{
; /* yawn.... */
}
/* When using read (2) or write (2), one always has to be prepared to handle incomplete
reads or writes. The {read,write}_patiently* routines below do just that: they repeat the read
or write until the whole buffer has been filled, or an error occurs.
The {read,write}_patiently2 functions are specialised for reading/writing the input/output pipe
of a filter */
int
write_patiently(int fd, const void *buffer, int count, const char *whither) {
int nwritten = 0;
int total_written = 0;
assert(count >= 0);
if (count == 0)
return TRUE;
while(1) {
if((nwritten = write(fd, (char *)buffer + total_written, count - total_written)) <= 0) {
if (errno == EINTR)
continue;
else if (errno == EPIPE || nwritten == 0) {
return FALSE;
} else
myerror(FATAL|USE_ERRNO, "write error %s", whither);
}
total_written += nwritten;
if (total_written == count) /* done */
break;
}
return TRUE;
}
static int user_frustration_signals[] = {SIGHUP, SIGINT, SIGQUIT, SIGTERM, SIGALRM};
/* keep reading from fd and write into buffer until count bytes have been read.
for uninterruptible_msec, restart when interrupted by a signal, after this,
bail out with an error. if count < 0, returns a 0-terminated copy of buffer */
void
read_patiently2 (int fd,
void *buffer,
int count,
int uninterruptible_msec,
const char *whence) {
int nread = 0;
int total_read = 0;
int interruptible = FALSE;
assert (count >= 0);
unblock_signals(user_frustration_signals); /* allow users to use CTRL-C, but only after uninterruptible_msec */
if (count > 0) {
myalarm(uninterruptible_msec);
while (1) {
assert(count > total_read);
if((nread = read(fd, (char *) buffer + total_read, count - total_read)) <= 0) {
if (nread < 0 && errno == EINTR) {
if (interruptible)
myerror(FATAL|NOERRNO, "(user) interrupt reading %s, filter_hangs?", whence);
if (received_sigALRM) {
received_sigALRM = FALSE;
interruptible = TRUE;
}
continue;
} else if (nread == 0)
myerror(FATAL|NOERRNO, "EOF reading %s", whence);
else /* nread < 0 */
myerror(FATAL|USE_ERRNO, "error reading %s", whence);
}
total_read += nread;
if (total_read == count) /* done */
break;
}
}
myalarm(0); /* reset alarm */
block_all_signals();
DPRINTF2(DEBUG_AD_HOC, "read_patiently2 read %d bytes: %s", total_read, mangle_buffer_for_debug_log(buffer, total_read));
return;
}
void
write_patiently2(int fd,
const void *buffer,
int count,
int uninterruptible_msec,
const char* whither) {
int nwritten = 0;
int total_written = 0;
int interruptible = FALSE;
assert(count >= 0);
if (count == 0)
return; /* no-op */
unblock_signals(user_frustration_signals); /* allow impatient users to hit CTRL-C, but only after uninterruptible_msec */
myalarm(uninterruptible_msec);
while(1) {
if((nwritten = write(fd, (char *)buffer + total_written, count - total_written)) <= 0) {
if (nwritten < 0 && errno == EINTR) {
if (interruptible)
myerror(FATAL|NOERRNO, "(user) interrupt - filter hangs?");
if (received_sigALRM) {
received_sigALRM = FALSE;
interruptible = TRUE;
}
continue;
} else /* nwritten== 0 or < 0 with error other than EINTR */
myerror(FATAL|USE_ERRNO, "error writing %s", whither);
}
total_written += nwritten;
if (total_written == count) /* done */
break;
}
myalarm(0);
DPRINTF2(DEBUG_AD_HOC, "write_patiently2 wrote %d bytes: %s", total_written, mangle_buffer_for_debug_log(buffer, total_written));
block_all_signals();
return;
}
void
mysetenv(const char *name, const char *value)
{
int return_value = 0;
#ifdef HAVE_SETENV
return_value = setenv(name, value, TRUE);
#elif defined(HAVE_PUTENV)
char *name_is_value = add3strings (name, "=", value);
return_value = putenv (name_is_value);
#else /* won't happen, but anyway: */
myerror(WARNING|NOERRNO, "setting environment variable %s=%s failed, as this system has neither setenv() nor putenv()", name, value);
#endif
if (return_value != 0)
myerror(WARNING|USE_ERRNO, "setting environment variable %s=%s failed%s", name, value,
(errno ? "" : " (insufficient environment space?)")); /* will setenv(...) = -1 set errno? */
}
void set_ulimit(int resource, long value) {
#ifdef HAVE_SETRLIMIT
struct rlimit limit;
int result;
limit.rlim_cur = value;
result = setrlimit(resource, &limit);
DPRINTF4(DEBUG_ALL, "setrlim() used to set resource #%d to value %ld, result = %d (%s)",
resource, value, result, (result == 0 ? "success" : "failure"));
#endif
}
int open_unique_tempfile(const char *suffix, char **tmpfile_name) {
char **tmpdirs = list4(getenv("TMPDIR"), getenv("TMP"), getenv("TEMP"), "/tmp");
char *tmpdir = first_of(tmpdirs);
int tmpfile_fd;
if (!suffix)
suffix = "";
*tmpfile_name = mymalloc(MAXPATHLEN+1);
#ifdef HAVE_MKSTEMPS
snprintf4(*tmpfile_name, MAXPATHLEN, "%s/%s_%s_XXXXXX%s", tmpdir, program_name, command_name, suffix);
tmpfile_fd = mkstemps(*tmpfile_name, strlen(suffix)); /* this will write into *tmpfile_name */
#else
{ static int tmpfile_counter = 0;
snprintf6(*tmpfile_name, MAXPATHLEN, "%s/%s_%s_%d_%d%s", tmpdir, program_name, command_name, command_pid, tmpfile_counter++, suffix);
tmpfile_fd = open(*tmpfile_name, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
}
#endif
if (tmpfile_fd < 0)
myerror(FATAL|USE_ERRNO, "could not create temporary file %s", tmpfile_name);
free(tmpdirs);
return tmpfile_fd;
}
static char*
markup(const char*str)
{
if (isatty(STDOUT_FILENO) && (ansi_colour_aware || colour_the_prompt))
return add3strings("\033[1;31m", str,"\033[0m");
else
return mysavestring(str);
}
/* print error or warning message. There are two error flags,
defined in rlwrap.h
FATAL: exit(EXIT_FAILURE) after printing the message)
USE_ERRNO: print perror(errno) after the message
*/
void
myerror(int error_flags, const char *message_format, ...)
{
int saved_errno = errno;
char contents[BUFFSIZE];
int is_warning = !(error_flags & FATAL);
char *warning_or_error = is_warning ? "warning: " : "error: ";
static int warnings_given = 0;
char *message = add2strings(program_name, ": ");
va_list ap;
va_start(ap, message_format);
vsnprintf(contents, sizeof(contents) - 1, message_format, ap);
va_end(ap);
message = append_and_free_old(message, markup(warning_or_error));
message = append_and_free_old(message, contents);
if ((error_flags & USE_ERRNO) && saved_errno) {
message = append_and_free_old(message, ": ");
message = append_and_free_old(message, strerror(saved_errno));
}
message = append_and_free_old(message,"\n");
fflush(stdout);
DPRINTF2(DEBUG_ALL, "%s %s", warning_or_error, contents);
if (! (is_warning && nowarn))
fputs(message, stderr); /* @@@ error reporting (still) uses buffered I/O */
if (is_warning && !warnings_given++ && !nowarn)
fputs("\nwarnings can be silenced by the --no-warnings (-n) option\n", stderr);
fflush(stderr);
free(message);
errno = saved_errno;
if (error_flags & FATAL) {
if (!i_am_child)
cleanup_rlwrap_and_exit(EXIT_FAILURE);
else /* child: die and let parent clean up */
exit(EXIT_FAILURE);
}
}
void
open_logfile(const char *filename)
{
time_t now;
log_fp = fopen(filename, "a");
if (!log_fp)
myerror(FATAL|USE_ERRNO, "Cannot write to logfile %s", filename);
now = time(NULL);
fprintf(log_fp, "\n\n[rlwrap] %s\n", ctime(&now));
}
void
write_logfile(const char *str)
{
if (log_fp)
fputs(str, log_fp);
}
size_t
filesize(const char *filename)
{
struct stat buf;
if (stat(filename, &buf))
myerror(FATAL|USE_ERRNO, "couldn't stat file %s", filename);
return (size_t) buf.st_size;
}
void
close_logfile()
{
if (log_fp)
fclose(log_fp);
}
void
close_open_files_without_writing_buffers() /* called from child just before exec(command) */
{
if(log_fp)
close(fileno(log_fp)); /* don't flush buffers to avoid avoid double double output output */
if (debug)
close(fileno(debug_fp));
}
void
timestamp(char *buf, int size)
{
struct timeval now;
static struct timeval firsttime; /* remember when first called */
static int never_called = 1;
long diff_usec;
float diff_sec;
gettimeofday(&now, NULL);
if (never_called) {
firsttime = now;
never_called = 0;
}
diff_usec = 1000000 * (now.tv_sec -firsttime.tv_sec) + (now.tv_usec - firsttime.tv_usec);
diff_sec = diff_usec / 1000000.0;
snprintf1(buf, size, "%f ", diff_sec);
}
int killed_by(int status) {
#ifdef WTERMSIG
if (WIFSIGNALED(status))
return WTERMSIG(status);
#endif
return 0;
}
/* change_working_directory() changes rlwrap's working directory to /proc//cwd
(on systems where this makes sense, like linux and Solaris) */
void
change_working_directory()
{
#ifdef HAVE_PROC_PID_CWD
static char proc_pid_cwd[MAXPATHLEN+1];
static int initialized = FALSE;
int linklen = 0;
snprintf0(slaves_working_directory, MAXPATHLEN, "?");
if (!initialized && command_pid > 0) { /* first time we're called after birth of child */
snprintf2(proc_pid_cwd, MAXPATHLEN , "%s/%d/cwd", PROC_MOUNTPOINT, command_pid);
initialized = TRUE;
}
if (chdir(proc_pid_cwd) == 0) {
#ifdef HAVE_READLINK
linklen = readlink(proc_pid_cwd, slaves_working_directory, MAXPATHLEN);
if (linklen > 0)
slaves_working_directory[linklen] = '\0';
else
snprintf1(slaves_working_directory, MAXPATHLEN, "? (%s)", strerror(errno));
#endif /* HAVE_READLINK */
}
#else /* HAVE_PROC_PID_CWD */
/* do nothing at all */
#endif
}
#define isset(flag) ((flag) ? "set" : "unset")
/* print info about terminal settings */
void log_terminal_settings(struct termios *terminal_settings) {
if (!terminal_settings)
return;
DPRINTF3(DEBUG_TERMIO, "terminal settings: clflag.ISIG: %s, cc_c[VINTR]=%d, cc_c[VEOF]=%d",
isset(terminal_settings->c_lflag | ISIG),
terminal_settings->c_cc[VINTR],
terminal_settings->c_cc[VEOF]);
}
void log_fd_info(int fd) {
struct termios terminal_settings;
if (isatty(fd)) {
if (tcgetattr(fd, &terminal_settings) < 0) {
DPRINTF1(DEBUG_TERMIO, "could not get terminal settings for fd %d", fd);
} else {
DPRINTF1(DEBUG_TERMIO, "terminal settings for fd %d:", fd);
}
log_terminal_settings(&terminal_settings);
}
}
/* some last-minute checks before we can start */
void
last_minute_checks()
{
/* flag unhealthy option combinations */
if (multiline_separator && filter_command)
myerror(WARNING|NOERRNO, "Filters don't work very well with multi-line rlwrap!");
}
/* sleep a little (for debugging cursor movement with the SHOWCURSOR macro) */
void mymicrosleep(int msec) {
int sec = msec / 1000;
struct timeval timeout;
msec -= (1000*sec);
timeout.tv_sec = sec;
timeout.tv_usec = 1000 * msec;
select (0,NULL,NULL,NULL,&timeout);
}
/* print info about option, considering whether we HAVE_GETOPT_LONG and whether GETOPT_GROKS_OPTIONAL_ARGS */
static void print_option(char shortopt, char *longopt, char*argument, int optional, char *comment) {
int long_opts, optional_args;
char *format;
char *maybe_optional = "";
char *longoptional = "";
#ifdef HAVE_GETOPT_LONG
long_opts = TRUE;
#else
long_opts = FALSE;
#endif
#ifdef GETOPT_GROKS_OPTIONAL_ARGS
optional_args = TRUE;
#else
optional_args = FALSE;
#endif
if (argument) {
maybe_optional = (optional_args && optional ? add3strings("[", argument,"]") : add3strings(" <", argument,">"));
longoptional = (optional ? add3strings("[=", argument,"]") : add3strings("=<", argument, ">"));
}
/* if we cannot use long options, use the long option as a reminder (no warnings) instead of "--no-warnings" */
if (!long_opts)
longopt = search_and_replace("-"," ", longopt, 0, NULL,NULL);
format = add2strings (" -%c%-24.24s", (long_opts ? " --%s%s" : "(%s)"));
fprintf(stderr, format, shortopt, maybe_optional, longopt, longoptional);
if (comment)
fprintf(stderr, " %s", comment);
fprintf(stderr, "\n");
/* don't free allocated strings: we'll exit() soon */
}
static void
print_debug_flag(int flag, char *explanation) {
fprintf(stderr, " %4d %s\n", flag, explanation);
}
void
usage(int status)
{
fprintf(stderr, "Usage: %s [options] command ...\n"
"\n"
"Options:\n", program_name);
print_option('a', "always-readline", "password prompt", TRUE, NULL);
print_option('A', "ansi-colour-aware", NULL, FALSE, NULL);
print_option('b', "break-chars", "chars", FALSE, NULL);
print_option('c', "complete-filenames", NULL, FALSE, NULL);
print_option('C', "command-name", "name|N", FALSE, NULL);
print_option('D', "history-no-dupes", "0|1|2", FALSE, NULL);
print_option('e', "extra-char-after-completion", "char|''", FALSE, NULL);
print_option('f', "file", "completion list", FALSE,NULL);
print_option('g', "forget-matching", "regexp", FALSE,NULL);
print_option('h', "help", NULL, FALSE, NULL);
print_option('H', "history-filename", "file", FALSE, NULL);
print_option('i', "case-insensitive", NULL, FALSE, NULL);
print_option('I', "pass-sigint-as-sigterm", NULL, FALSE, NULL);
print_option('l', "logfile", "file", FALSE, NULL);
print_option('m', "multi-line", "newline substitute", TRUE, NULL);
print_option('M', "multi-line-ext", ".ext", FALSE, NULL);
print_option('n', "no-warnings", NULL, FALSE, NULL);
print_option('N', "no-children", NULL, FALSE, NULL);
print_option('o', "one-shot", NULL, FALSE, NULL);
print_option('O', "only-cook", "regexp", FALSE, NULL);
print_option('p', "prompt-colour", "colour", TRUE, NULL);
print_option('P', "pre-given","input", FALSE, NULL);
print_option('q', "quote-characters", "chars", FALSE, NULL);
print_option('r', "remember", NULL, FALSE, NULL);
print_option('R', "renice", NULL, FALSE, NULL);
print_option('s', "histsize", "N", FALSE,"(negative: readonly)");
print_option('S', "substitute-prompt", "prompt", FALSE, NULL);
print_option('t', "set-term-name", "name", FALSE, NULL);
print_option('U', "mirror-arguments", NULL, FALSE, NULL);
print_option('v', "version", NULL, FALSE, NULL);
print_option('w', "wait-before-prompt", "N", FALSE, "(msec, <0 : patient mode)");
print_option('W', "polling", NULL, FALSE, NULL);
print_option('z', "filter", "filter command", FALSE, "(-z listing lists installed filters)");
#ifdef DEBUG
fprintf(stderr, "\n");
print_option('T', "test-terminal", NULL, FALSE, NULL);
print_option('d', "debug", "mask", TRUE, add3strings("(output sent to ", DEBUG_FILENAME,")"));
fprintf(stderr,
" \n"
"The -d or --debug option *must* come first\n"
"The debugging mask is a bitmask obtained by adding:\n");
print_debug_flag (DEBUG_TERMIO, "to debug termio,");
print_debug_flag (DEBUG_SIGNALS, "signal handling,");
print_debug_flag (DEBUG_READLINE, "readline,");
print_debug_flag (DEBUG_MEMORY_MANAGEMENT, "memory management,");
print_debug_flag (DEBUG_FILTERING, "filtering,");
print_debug_flag (DEBUG_COMPLETION, "and completion.");
/* print_debug_flag (DEBUG_AD_HOC, "to see your own DEBUG_AD_HOC results"); */
print_debug_flag (DEBUG_WITH_TIMESTAMPS, "to add (relative) timestamps,");
print_debug_flag (FORCE_HOMEGROWN_REDISPLAY, "to force the use of my_homegrown_redisplay(),");
print_debug_flag (DEBUG_LONG_STRINGS, "to not limit the length of strings in debug log (sloooow!)");
print_debug_flag (DEBUG_RACES, "add random delays to expose race conditions.");
fprintf(stderr, " default debug mask = %d (debug termio, signals and readline handling)\n"
" use the shell construct $[ ] to calculate the mask, e.g. -d$[%d+%d+%d]\n",
DEBUG_DEFAULT, DEBUG_DEFAULT, DEBUG_WITH_TIMESTAMPS, DEBUG_RACES);
#endif
fprintf(stderr,
"\n"
"bug reports, suggestions, updates:\n"
"http://utopia.knoware.nl/~hlub/uck/rlwrap/\n");
exit(status);
}
#ifdef DEBUG
#undef mymalloc
#endif
/* malloc with simplistic error handling: just bail out when out of memory */
void *
mymalloc(size_t size)
{
void *ptr;
ptr = malloc(size);
if (ptr == NULL) {
/* don't call myerror(), as this calls mymalloc() again */
fprintf(stderr, "Out of memory: tried in vain to allocate %d bytes\n", (int) size);
exit(EXIT_FAILURE);
}
return ptr;
}
/* free of possibly NULL pointer (only needed on very olde systems) */
void myfree(void *ptr) {
if (ptr)
free(ptr);
}
void mysetsid() {
# ifdef HAVE_SETSID /* c'mon, this is POSIX! */
pid_t ret = setsid();
DPRINTF2(DEBUG_TERMIO, "setsid() returned %d %s", (int)ret,
ERRMSG(ret < 0));
# endif
}
/* mirror_args(): look up command's command line and copy it to our own
important for commands that re-write their command lines e.g. to hide
passwords.
*/
static char ** rlwrap_command_argv; /* The slice of rlwrap's argv after all rlwrap options */
static char *argv_buffer;
static int argv_len;
static char *stored_cmdline_filename;
void mirror_args_init(char**argv) {
int i;
#ifdef ENABLE_MIRROR_ARGS
rlwrap_command_argv = argv;
stored_cmdline_filename = mymalloc(MAXPATHLEN);
*stored_cmdline_filename = '\0';
for (i = 0; argv[i]; i++) {
argv_len += strlen(argv[i]) + 1;
}
argv_buffer = mymalloc(argv_len * sizeof(char) + 1);
#else
stored_cmdline_filename = NULL;
myerror(WARNING|NOERRNO, "On this system, the -U (--mirror-arguments) option doesn't work");
#endif
}
/* C standard: "The parameters argc and argv and the strings pointed to by the argv
array shall be modifiable by the program, and retain their last-stored
values between program startup and program termination.
This doesn't guarantee that those changed values will be visible to e.g. the ps (1) command
*/
void mirror_args(command_pid) {
int cmdline_fd;
long cmdline_length;
static int been_warned = 0;
if (!stored_cmdline_filename)
return;
if (!*stored_cmdline_filename)
snprintf2(stored_cmdline_filename, MAXPATHLEN , "%s/%d/cmdline", PROC_MOUNTPOINT, command_pid);
if((cmdline_fd = open(stored_cmdline_filename, O_RDONLY)) < 1) {
stored_cmdline_filename = NULL;
if (been_warned++ == 0)
myerror(WARNING|USE_ERRNO, "cannot mirror command's command line, as %s is unreadable", stored_cmdline_filename);
return;
}
cmdline_length = read(cmdline_fd, argv_buffer,argv_len);
/* argv_buffer[cmdline_length] = '\0'; */
DPRINTF2(DEBUG_TERMIO,"read %d bytes from %s", (int) cmdline_length, stored_cmdline_filename);
if (memcmp(*rlwrap_command_argv, argv_buffer, cmdline_length)) {
char *rlwrap_argstr = mem2str(*rlwrap_command_argv, cmdline_length);
char *command_argstr = mem2str(argv_buffer, cmdline_length);
DPRINTF2(DEBUG_TERMIO, "discrepancy: rlwarp_args: %s, command_args %s", rlwrap_argstr, command_argstr);
free(rlwrap_argstr);
free(command_argstr);
memcpy(*rlwrap_command_argv, argv_buffer, cmdline_length);
}
}
rlwrap-0.42/src/rlwrap.h 0000644 0001751 0000144 00000045334 12407053650 012146 0000000 0000000 /* rlwrap.h: includes, definitions, declarations */
/* This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License , or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
You may contact the author by:
e-mail: hlub@knoware.nl
*/
#include "../config.h"
#include
#if HAVE_SYS_WAIT_H
# include
#endif
#ifndef WEXITSTATUS
# define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include /* stdint.h is not on AIX, inttypes.h is in ISO C 1999 */
#include
#include
/* #define __USE_XOPEN
#define __USE_GNU */
#include
#include
#if TIME_WITH_SYS_TIME
# include
# include
#else
# if HAVE_SYS_TIME_H
# include
# else
# include
# endif
#endif
#ifdef HAVE_GETOPT_H
# include
#endif
#ifdef HAVE_CURSES_H
# include
# ifdef HAVE_TERM_H
# include
# else
# ifdef HAVE_NCURSES_TERM_H /* cygwin? AIX? */
# include
# endif
# endif
#else
# ifdef HAVE_TERMCAP_H
# include
# endif
#endif
#include
#ifdef HAVE_REGEX_H
# include
#endif
#if STDC_HEADERS
# include
#else
# ifndef HAVE_STRRCHR
# define strrchr rindex
# endif
char *strchr(), *strrchr();
# ifndef HAVE_MEMMOVE
# define memmove(d, s, n) bcopy ((s), (d), (n))
# endif
#endif
#ifdef HAVE_PTY_H /* glibc (even if BSD) */
# include
#elif HAVE_LIBUTIL_H /* BSD, non-glibc */
# include
#elif HAVE_UTIL_H /* BSD, other varriants */
# include
#endif
#define BUFFSIZE 512
#ifndef MAXPATHLEN
#define MAXPATHLEN 512
#endif
#ifdef HAVE_SNPRINTF /* don't rely on the compiler understanding variadic macros */
# define snprintf0(buf,bufsize,format) snprintf(buf,bufsize,format)
# define snprintf1(buf,bufsize,format,arg1) snprintf(buf,bufsize,format,arg1)
# define snprintf2(buf,bufsize,format,arg1,arg2) snprintf(buf,bufsize,format,arg1,arg2)
# define snprintf3(buf,bufsize,format,arg1,arg2,arg3) snprintf(buf,bufsize,format,arg1,arg2,arg3)
# define snprintf4(buf,bufsize,format,arg1,arg2,arg3,arg4) snprintf(buf,bufsize,format,arg1,arg2,arg3,arg4)
# define snprintf5(buf,bufsize,format,arg1,arg2,arg3,arg4,arg5) snprintf(buf,bufsize,format,arg1,arg2,arg3,arg4,arg5)
# define snprintf6(buf,bufsize,format,arg1,arg2,arg3,arg4,arg5,arg6) snprintf(buf,bufsize,format,arg1,arg2,arg3,arg4,arg5,arg6)
#else
# define snprintf0(buf,bufsize,format) sprintf(buf,format)
# define snprintf1(buf,bufsize,format,arg1) sprintf(buf,format,arg1)
# define snprintf2(buf,bufsize,format,arg1,arg2) sprintf(buf,format,arg1,arg2)
# define snprintf3(buf,bufsize,format,arg1,arg2,arg3) sprintf(buf,format,arg1,arg2,arg3)
# define snprintf4(buf,bufsize,format,arg1,arg2,arg3,arg4) sprintf(buf,format,arg1,arg2,arg3,arg4)
# define snprintf5(buf,bufsize,format,arg1,arg2,arg3,arg4,arg5) sprintf(buf,format,arg1,arg2,arg3,arg4,arg5)
# define snprintf6(buf,bufsize,format,arg1,arg2,arg3,arg4,arg5,arg6) sprintf(buf,format,arg1,arg2,arg3,arg4,arg5,arg6)
# define vsnprintf(buf,bufsize,format,ap) vsprintf(buf,format,ap)
#endif
#ifndef HAVE_STRNLEN
# define strnlen(s,l) strlen(s)
#endif
#include
#include
#ifndef HAVE_RL_VARIABLE_VALUE
# define rl_variable_value(s) "off"
#endif
#ifndef HAVE_RL_READLINE_VERSION
# define rl_readline_version 0xbaddef
#endif
#if defined(SPY_ON_READLINE)
extern int _rl_eof_char; /* Spying on readline's private life .... */
extern int _rl_horizontal_scroll_mode;
# if !defined(HOMEGROWN_REDISPLAY)
# define MAYBE_MULTILINE 1
# endif
#else
# define _rl_eof_char 0;
#endif
#ifdef MAYBE_MULTILINE
# define redisplay_multiple_lines (!_rl_horizontal_scroll_mode)
#else
# define redisplay_multiple_lines (strncmp(rl_variable_value("horizontal-scroll-mode"),"off",3) == 0)
#endif
/* in main.c: */
extern int master_pty_fd;
extern int slave_pty_sensing_fd;
extern FILE *debug_fp;
extern char *program_name, *command_name;
extern int always_readline;
extern int complete_filenames;
extern pid_t command_pid;
extern char *rlwrap_command_line;
extern char *command_line;
extern char *extra_char_after_completion;
extern int i_am_child;
extern int nowarn;
extern int debug;
extern char *password_prompt_search_string;
extern int one_shot_rlwrap;
extern char *substitute_prompt;
extern char *history_format;
extern char *forget_regexp;
extern char *multi_line_tmpfile_ext;
extern char *prompt_regexp;
extern int renice;
extern int ignore_queued_input;
extern int history_duplicate_avoidance_policy;
extern int pass_on_sigINT_as_sigTERM;
/* now follow the possible values for history_duplicate_avoidance_policy: */
#define KEEP_ALL_DOUBLES 0
#define ELIMINATE_SUCCESIVE_DOUBLES 1
#define ELIMINATE_ALL_DOUBLES 2
extern int one_shot_rlwrap;
extern int ansi_colour_aware;
extern int colour_the_prompt;
extern int received_WINCH;
extern int prompt_is_still_uncooked;
extern int mirror_arguments;
extern int impatient_prompt;
extern int we_just_got_a_signal_or_EOF;
extern int remember_for_completion;
extern int commands_children_not_wrapped;
extern int accepted_lines;
extern char *filter_command;
extern int polling;
void cleanup_rlwrap_and_exit(int status);
void put_in_output_queue(char *stuff);
int output_queue_is_nonempty(void);
void flush_output_queue(void);
/* in readline.c: */
extern struct rl_state
{ /* struct to save readline state while we're processing output from slave command*/
char *input_buffer; /* current input buffer */
char *raw_prompt; /* current prompt */
char *cooked_prompt; /* ditto redefined by user, or with colour added */
int point; /* cursor position within input buffer */
int already_saved; /* flag set when saved, cleared when restored */
} saved_rl_state;
void save_rl_state(void);
void restore_rl_state(void);
void init_readline(char *);
void my_redisplay(void);
void initialise_colour_codes(char *colour);
void reprint_prompt(int coloured);
char *colourise (const char *prompt);
void move_cursor_to_start_of_prompt(int erase);
#define ERASE 1
#define DONT_ERASE 0
int prompt_is_single_line(void);
char *process_new_output(const char* buffer, struct rl_state* state);
int cook_prompt_if_necessary (void);
extern int within_line_edit, transparent;
extern char *multiline_separator;
extern char *pre_given;
extern int leave_prompt_alone;
/* in signals.c */
extern volatile int command_is_dead;
extern int commands_exit_status;
extern int filter_is_dead;
extern int filters_exit_status;
extern int sigterm_received;
extern int deferred_adapt_commands_window_size;
extern int signal_handlers_were_installed;
extern int received_sigALRM;
#ifndef RETSIGTYPE
#define RETSIGTYPE void /* systems where RETSIGTYPE = int have died out, apparently */
#endif
typedef RETSIGTYPE (*sighandler_type)(int);
void mysignal(int sig, sighandler_type handler);
void install_signal_handlers(void);
void block_signals(int *sigs);
void unblock_signals(int *sigs);
void block_all_passed_on_signals(void);
void block_all_signals(void);
void unblock_all_signals(void);
void ignore_sigchld(void);
void suicide_by(int sig, int status);
int adapt_tty_winsize(int from_fd, int to_fd);
void myalarm(int msec);
void handle_sigALRM(int signo);
char *signal_name(int signal);
/* in utils.c */
void yield(void);
void zero_select_timeout(void);
int my_pselect(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *ptimeout_ts, const sigset_t *sigmask);
struct termios *my_tcgetattr(int fd, char *which);
int read_patiently(int fd, void *buffer, int count, char *whence);
int write_patiently(int fd, const void *buffer, int count, const char *whither);
void read_patiently2(int fd, void *buffer, int count, int uninterruptible_msec, const char *whence);
void write_patiently2(int fd, const void *buffer, int count, int uninterruptible_msec, const char *whither);
void mysetenv(const char *name, const char *value);
void set_ulimit(int resource, long value);
void usage(int status);
int open_unique_tempfile(const char *suffix, char **tmpfile_name);
void mirror_args_init(char **argv);
void mirror_args(pid_t command_pid);
/* flags to use for the error_flags argument to myerror */
#define FATAL 2
#define WARNING 0
#define USE_ERRNO 1
#define NOERRNO 0
void myerror(int error_flags, const char *message, ...);
void *mymalloc(size_t size);
void myfree(void *ptr);
void mysetsid(void);
void close_open_files_without_writing_buffers(void);
size_t filesize(const char *filename);
void open_logfile(const char *filename);
void write_logfile(const char *str);
void close_logfile(void);
void timestamp(char *buf, int size);
int killed_by(int status);
void change_working_directory(void);
void log_terminal_settings(struct termios *terminal_settings);
void log_fd_info(int fd);
void last_minute_checks(void);
void mymicrosleep(int msec);
void do_nothing(int unused);
extern char slaves_working_directory[];
/* in string_utils.c */
char *mybasename(char *filename);
char *mydirname(char *filename);
void mystrlcpy(char *dst, const char *src, size_t size);
void mystrlcat(char *dst, const char *src, size_t size);
char *mystrstr(const char *haystack, const char *needle);
char *mysavestring(const char *string);
char *add3strings(const char *str1, const char *str2, const char *str3);
#define add2strings(a,b) add3strings(a,b,"")
char *mystrtok(const char *s, const char *delim);
char **split_with(const char *string, const char *delim);
char *unsplit_with(int n, char ** strings, const char *delim);
char **split_on_single_char(const char *string, char c);
int scan_metacharacters(const char* string, const char *metacharacters);
char **list4 (char *el0, char *el1, char *el2, char *el3);
void free_splitlist (char **list);
char *append_and_free_old(char *str1, const char *str2);
char *mangle_char_for_debug_log(char c, int quote_me);
char *mangle_string_for_debug_log(const char *string, int maxlen);
char *mangle_buffer_for_debug_log(const char *buffer, int length);
char *mem2str(const char *mem, int size);
char *search_and_replace(char *patt, char *repl, const char *string,
int cursorpos, int *line, int *col);
char *first_of(char **strings);
char *as_string(int i);
char *append_and_expand_history_format(char *line);
void remove_padding_and_terminate(char *buf, int length);
void unbackspace(char* buf);
void test_unbackspace (const char *input, const char *expected_result);
char *mark_invisible(const char *buf);
char *copy_and_unbackspace(const char *original);
int colourless_strlen(const char *str, char **pcopy_without_ignore_markers, int termwidth);
int colourless_strlen_unmarked (const char *str, int termwidth);
char *get_last_screenline(char *long_line, int termwidth);
char *lowercase(const char *str);
char *colour_name_to_ansi_code(const char *colour_name);
int match_regexp(const char *string, const char *regexp, int case_insensitive);
/* in pty.c: */
pid_t my_pty_fork(int *, const struct termios *, const struct winsize *);
int slave_is_in_raw_mode(void);
struct termios *get_pterm_slave(void);
void mirror_slaves_echo_mode(void);
void completely_mirror_slaves_terminal_settings(void);
void completely_mirror_slaves_output_settings(void);
void completely_mirror_slaves_special_characters(void);
void write_EOF_to_master_pty(void);
void write_EOL_to_master_pty(char *);
int dont_wrap_command_waits(void);
int skip_rlwrap(void);
/* in ptytty.c: */
int ptytty_get_pty(int *fd_tty, const char **ttydev);
int ptytty_get_tty(const char *ttydev);
int ptytty_control_tty(int fd_tty, const char *ttydev);
int ptytty_openpty(int *amaster, int *aslave, const char **name);
/* in completion.rb: */
void init_completer(void);
void feed_file_into_completion_list(const char *completions_file);
void feed_line_into_completion_list(const char *line);
void add_word_to_completions(const char *word);
void remove_word_from_completions(const char *word);
char *my_completion_function(char *prefix, int state);
extern int completion_is_case_sensitive;
/* in term.c: */
extern int redisplay; /* TRUE when user input should be readable (instead of *******) */
void init_terminal(void);
void set_echo(int);
void prepare_terminal(void);
void cr(void);
void backspace(int);
void clear_line(void);
void clear_the_screen(void);
void curs_up(void);
void curs_down(void);
void curs_left(void);
void test_terminal(void);
int my_putchar(TPUTS_PUTC_ARGTYPE c);
void my_putstr(const char *string);
int cursor_hpos(int col);
extern struct termios saved_terminal_settings;
extern int terminal_settings_saved;
extern struct winsize winsize;
extern char *term_name;
extern char *term_backspace, term_eof, term_stop, *term_cursor_hpos,
*term_cursor_up, *term_cursor_down, *term_cursor_left, *term_rmcup, *term_rmkx;
extern int newline_came_last;
/* in filter.c */
#define TAG_INPUT 0
#define TAG_OUTPUT 1
#define TAG_HISTORY 2
#define TAG_COMPLETION 3
#define TAG_PROMPT 4
#define TAG_IGNORE 251
#define TAG_ADD_TO_COMPLETION_LIST 252
#define TAG_REMOVE_FROM_COMPLETION_LIST 253
#define TAG_OUTPUT_OUT_OF_BAND 254
#define TAG_ERROR 255
#define out_of_band(tag) (tag & 128)
extern pid_t filter_pid;
extern int filter_is_dead;
void spawn_filter(const char *filter_command);
void kill_filter(void);
char *pass_through_filter(int tag, const char *buffer);
char *filters_last_words(void);
void filter_test(void);
/* some handy macros */
#ifndef TRUE
# define TRUE 1
#endif
#ifndef FALSE
# define FALSE 0
#endif
#ifndef min
# define min(a,b) ((a) < (b) ? (a) : (b))
#endif
#ifndef max
# define max(a,b) ((a) < (b) ? (b) : (a))
#endif
#include "malloc_debug.h" /* malloc_debug.{c,h} not ready for prime time */
#define DEBUG_FILENAME "/tmp/rlwrap.debug"
#define KA_BOOM {char *p = (char *) 1; *p = 'c';} /* dump core right here */
#define KA_SCRUNCH {volatile int x=1, y=0; x = x/y;} /* force a SIGFPE */
#define KA_SCREECH kill(getpid(),SIGTRAP); /* enter the debugger - use it to set (conditional) breakpoints from within C code: if (condition) KA_SCREECH; */
/* DPRINTF0 and its ilk doesn't produce any output except when DEBUG is #defined (via --enable-debug configure option) */
#ifdef DEBUG
# define DEBUG_TERMIO 1
# define DEBUG_SIGNALS 2
# define DEBUG_READLINE 4
# define DEBUG_MEMORY_MANAGEMENT 8 /* used with malloc_debug.c */
# define DEBUG_FILTERING 16
# define DEBUG_COMPLETION 32
# define DEBUG_AD_HOC 64 /* only used during rlwrap development */
# define DEBUG_WITH_TIMESTAMPS 128 /* add timestamps to every line in debug log */
# define FORCE_HOMEGROWN_REDISPLAY 256 /* force use of my_homegrown_redisplay() */
# define DEBUG_LONG_STRINGS 512 /* log all strings completely, however long they are */
# define DEBUG_RACES 1024 /* introduce random delays */
# define DEBUG_RANDOM_FAIL 2048 /* fail tests randomly */
# define DEBUG_TEST_MAIN 4096 /* run test_main and exit */
# define DEBUG_MAX DEBUG_TEST_MAIN
# define MANGLE_LENGTH ((debug_saved & DEBUG_LONG_STRINGS) ? 0 : 20) /* debug_saved is defined within DPRINTF macro */
# define DEBUG_DEFAULT (DEBUG_TERMIO | DEBUG_SIGNALS | DEBUG_READLINE)
# define DEBUG_ALL (2*DEBUG_MAX-1)
# ifndef __GNUC__
# define __FUNCTION__ ""
# endif
# define WHERE_AND_WHEN \
int debug_saved = debug; char file_line[100], when[100]; \
if(debug & DEBUG_WITH_TIMESTAMPS) timestamp(when, sizeof(when)); else *when='\0'; \
debug = 0; /* don't debug while evaluating the DPRINTF arguments */ \
snprintf2(file_line, sizeof(file_line),"%.15s:%d:",__FILE__,__LINE__); \
fprintf(debug_fp, "%-20s %s %-25.25s ", file_line, when, __FUNCTION__);\
# define NL_AND_FLUSH fputc('\n', debug_fp) ; fflush(debug_fp); debug = debug_saved;
# define DPRINTF0(mask, format) \
if ((debug & mask) && debug_fp) {WHERE_AND_WHEN; fprintf(debug_fp, format); NL_AND_FLUSH; }
# define DPRINTF1(mask, format,arg) \
if ((debug & mask) && debug_fp) {WHERE_AND_WHEN; fprintf(debug_fp, format, arg); NL_AND_FLUSH; }
# define DPRINTF2(mask, format,arg1, arg2) \
if ((debug & mask) && debug_fp) {WHERE_AND_WHEN; fprintf(debug_fp, format, arg1, arg2); NL_AND_FLUSH; }
# define DPRINTF3(mask, format,arg1, arg2, arg3) \
if ((debug & mask) && debug_fp) {WHERE_AND_WHEN; fprintf(debug_fp, format, arg1, arg2, arg3); NL_AND_FLUSH; }
# define DPRINTF4(mask, format,arg1, arg2, arg3, arg4) \
if ((debug & mask) && debug_fp) {WHERE_AND_WHEN; fprintf(debug_fp, format, arg1, arg2, arg3,arg4); NL_AND_FLUSH; }
# define ERRMSG(b) (b && (errno != 0) ? add3strings("(", strerror(errno), ")") : "" )
# define SHOWCURSOR(c) if (debug & DEBUG_READLINE) {my_putchar(c); mymicrosleep(1200); curs_left();} /* (may work incorrectly at last column!)*/
# define DEBUG_RANDOM_SLEEP if (debug & DEBUG_RACES) {int sleeptime=rand()&31; DPRINTF1(DEBUG_RACES,"sleeping for %d msecs", sleeptime); mymicrosleep(sleeptime);}
#else
# define HEAVEN_FORBID(exp) (exp)
# define OH_PLEASE(exp) (exp)
# define MANGLE_LENGTH 0
# define DPRINTF0(mask, format)
# define DPRINTF1(mask, format,arg)
# define DPRINTF2(mask, format,arg1, arg2)
# define DPRINTF3(mask, format,arg1, arg2, arg3)
# define DPRINTF4(mask, format,arg1, arg2, arg3, arg4)
# define ERRMSG(b)
# define SHOWCURSOR
# define NDEBUG /* disable assertions */
# define DEBUG_RANDOM_SLEEP
#endif
#include
rlwrap-0.42/src/signals.c 0000644 0001751 0000144 00000041746 12404151311 012263 0000000 0000000 /* signals.c: signal handling */
/* This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License , or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
You may contact the author by:
e-mail: hlub@knoware.nl
*/
#include "rlwrap.h"
volatile int command_is_dead = FALSE;
int commands_exit_status = 0;
int filter_is_dead = FALSE;
int filters_exit_status = 0;
int deferred_adapt_commands_window_size = FALSE; /* whether we have to adapt clients winsize when accepting a line */
int signal_handlers_were_installed = FALSE;
int received_sigALRM = FALSE;
static void change_signalmask(int, int *);
static void child_died(int);
static void pass_on_signal(int);
static void handle_sigTSTP(int);
int adapt_tty_winsize(int, int);
static void wipe_textarea(struct winsize *old_size);
static int signals_program_error(int signal);
static int signals_to_be_passed_on[] = {
SIGHUP, SIGINT,
SIGQUIT, SIGTERM, SIGCONT, SIGUSR1,
SIGUSR2, SIGWINCH, 0
};
#ifndef MAX_SIG /* is this POSIX? couldn't find it, so: */
#define MAX_SIG 100
#endif
#ifdef DEBUG
static void log_named_signal(int);
#else
static void handle_program_error_signal(int);
#endif
int sigterm_received = FALSE;
void
mysignal(int sig, sighandler_type handler) {
#ifdef HAVE_SIGACTION
struct sigaction action;
DPRINTF3(DEBUG_SIGNALS,"Setting handler for signal %d (%s) to <0x%lx>", sig, signal_name(sig), (long) handler);
action.sa_handler = handler;
sigfillset(&action.sa_mask); /* don't bother making our signal handlers re-entrant (they aren't) */
action.sa_flags = (sig == SIGCHLD ? SA_NOCLDSTOP : 0); /* no SA_RESTART */
if (sigaction(sig, &action, NULL) != 0)
# else /* rlwrap running in Ye Olde Computer Museum?? */
if (signal(sig, handler) == SIG_ERR)
# endif
if(handler != SIG_DFL) /* allow e.g. KILL to be set to its default */
myerror(FATAL|USE_ERRNO, "Failed setting handler for signal %d (%s)", sig, signal_name(sig));
}
void
install_signal_handlers()
{
int i;
mysignal(SIGCHLD, &child_died);
mysignal(SIGTSTP, &handle_sigTSTP);
#ifndef DEBUG /* we want core dumps when debugging, no polite excuses! */
for (i = 1; i %d, ws.row: %d -> %d", old_winsize.ws_col, winsize.ws_col, old_winsize.ws_row, winsize.ws_row);
if (always_readline &&!dont_wrap_command_waits()) /* if --always_readline option is set, the client will probably spew a */
deferred_adapt_commands_window_size = TRUE; /* volley of control chars at us when its terminal is resized. Hence we don't do it now */
else {
ret = ioctl(to_fd, TIOCSWINSZ, &winsize);
DPRINTF1(DEBUG_SIGNALS, "ioctl (..., TIOCSWINSZ) = %d", ret);
}
DPRINTF2(DEBUG_READLINE, "rl_prompt: %s, line_buffer: %s", mangle_string_for_debug_log(rl_prompt, 100), rl_line_buffer);
rl_set_screen_size(winsize.ws_row, winsize.ws_col); /* this is safe: we know that right now rlwrap is not calling
the readline library because we keep SIGWINCH blocked all the time */
if (!within_line_edit && !skip_rlwrap()) {
wipe_textarea(&old_winsize);
received_WINCH = TRUE; /* we can't start line edit in signal handler, so we only set a flag */
} else if (within_line_edit) { /* try to keep displayed line tidy */
wipe_textarea(&old_winsize);
rl_on_new_line();
rl_redisplay();
}
return (!always_readline || dont_wrap_command_waits()); /* pass the signal on (except when always_readline is set and command is not waiting) */
} else { /* window size has not changed */
return FALSE;
}
}
/* After a resize, clear all the lines that were occupied by prompt + line buffer before the resize */
static
void wipe_textarea(struct winsize *old_winsize)
{
int point, lineheight, linelength, cursor_height, i, promptlength;
if (!prompt_is_single_line()) { /* Don't need to do anything in horizontal_scroll_mode */
promptlength = colourless_strlen((saved_rl_state.cooked_prompt ? saved_rl_state.cooked_prompt: saved_rl_state.raw_prompt), NULL, old_winsize -> ws_col);
linelength = (within_line_edit ? strlen(rl_line_buffer) : 0) + promptlength;
point = (within_line_edit ? rl_point : 0) + promptlength;
assert(old_winsize -> ws_col > 0);
lineheight = (linelength == 0 ? 0 : (1 + (max(point, (linelength - 1)) / old_winsize -> ws_col)));
if (lineheight > 1 && term_cursor_up != NULL && term_cursor_down != NULL) {
/* i.e. if we have multiple rows displayed, and we can clean them up first */
cr();
cursor_height = point / old_winsize -> ws_col; /* cursor is still on old line */
DPRINTF2(DEBUG_SIGNALS, "lineheight: %d, cursor_height: %d", lineheight, cursor_height);
for (i = 1 + cursor_height; i < lineheight; i++)
curs_down(); /* ...move it down to last line */
for (i = lineheight; i > 1; i--) { /* go up again, erasing every line */
clear_line();
curs_up();
}
}
clear_line();
cr();
}
}
static void
child_died(int unused)
{
int saved_errno;
DEBUG_RANDOM_SLEEP;
zero_select_timeout();
saved_errno = errno;
DPRINTF0(DEBUG_SIGNALS, "Caught SIGCHLD");
if(command_pid && waitpid(command_pid, &commands_exit_status, WNOHANG)) {
DPRINTF2(DEBUG_SIGNALS, "child (pid %d) has died, exit status: %x", command_pid, commands_exit_status);
command_is_dead = TRUE;
command_pid = 0; /* thus we know that there is no child anymore to pass signals to */
} else if (filter_pid && waitpid(filter_pid, &filters_exit_status, WNOHANG)) {
DPRINTF2(DEBUG_SIGNALS, "filter (pid %d) has died, exit status: %x", filter_pid, filters_exit_status);
filter_is_dead = TRUE;
filter_pid = 0;
} else {
DPRINTF0(DEBUG_ALL, "Whoa, got a SIGCHLD, but not from slave command or filter! I must have children I don't know about (blush...)!");
/* ignore */
}
errno = saved_errno;
return; /* allow remaining output from child to be processed in main loop */
/* (so that we will see childs good-bye talk) */
/* this will then clean up and terminate */
}
#ifdef DEBUG
static void
log_named_signal(int signo)
{
if (debug)
DPRINTF1(DEBUG_SIGNALS, "got %s", signal_name(signo));
}
#else
static void
handle_program_error_signal(int sig)
{ /* Even after sudden and unexpected death, leave the terminal in a tidy state */
int res;
printf("\n%s: Oops, crashed (caught %s) - this should not have happened!\n"
"If you need a core dump, re-configure with --enable-debug and rebuild\n"
"Resetting terminal and cleaning up...\n", program_name, signal_name(sig));
if (colour_the_prompt || filter_pid)
res = write(STDOUT_FILENO,"\033[0m",4); /* reset terminal colours */
if (terminal_settings_saved)
tcsetattr(STDIN_FILENO, TCSAFLUSH, &saved_terminal_settings);
exit(EXIT_FAILURE);
}
#endif
static int coredump(int status) {
#ifdef WCOREDUMP
return WCOREDUMP(status);
#else
return 0;
#endif
}
void suicide_by(int signal, int status) {
/* Some signals suggest a program error. When rlwrap kills itself with one of those,
the shell may tell the user that rlwrap itself has failed. Make clear that
it didn't. @@@ We could also try argv[0] = command_name just before dying ? */
if (signals_program_error(signal)) {
myerror(WARNING|NOERRNO, "%s crashed, killed by %s%s.\n%s itself has not crashed, but for transparency,\n"
"it will now kill itself %swith the same signal\n",
command_name, signal_name(signal), (coredump(status) ? " (core dumped)" : ""),
program_name, (coredump(status) ? "" : "(without dumping core) ") );
}
uninstall_signal_handlers();
unblock_all_signals();
set_ulimit(RLIMIT_CORE,0); /* prevent our own useless core dump from clobbering the interesting one created by command */
DPRINTF1(DEBUG_SIGNALS, "suicide by signal %s", signal_name(signal));
kill(getpid(), signal);
/* still alive? */
sleep(1);
exit(0);
}
static int myalarm_was_set = FALSE;
/* drop-in replacement for alarm (*but* with arg in msecs, not secs). Also sets global flag
myalarm_was_set */
void myalarm(int msecs) {
#ifdef HAVE_SETITIMER
struct itimerval awhile = {{0,0},{0,0}};
awhile.it_value.tv_usec = msecs * 1000;
received_sigALRM = FALSE;
setitimer(ITIMER_REAL, &awhile, NULL);
#else
received_sigALRM = FALSE;
alarm(msecs == 0 ? 0 : 1 + msecs/1000));
#endif
DPRINTF1(DEBUG_AD_HOC, "set alarm (%d msecs)", msecs);
if (msecs == 0)
return;
myalarm_was_set = TRUE;
}
void
handle_sigALRM(int signo) {
received_sigALRM = TRUE;
assert(myalarm_was_set); /* cry wolf if sigALRM is caught when none was requested by myalarm */
myalarm_was_set= FALSE;
DPRINTF0(DEBUG_SIGNALS, "got sigALRM");
}
/* Give name of signal. A case() construct is not appropriate here as on some
architectures signal values may coincide */
char *signal_name(int signal) {
return
signal == SIGHUP ? "SIGHUP" :
signal == SIGINT ? "SIGINT" :
signal == SIGQUIT ? "SIGQUIT" :
signal == SIGILL ? "SIGILL" :
signal == SIGABRT ? "SIGABRT" :
signal == SIGTRAP ? "SIGTRAP" :
#ifdef SIGIOT /* 4.2 BSD (IOT trap ) */
signal == SIGIOT ? "SIGIOT" :
#endif
#ifdef SIGEMT /* 4.2 BSD (EMT trap ) */
signal == SIGEMT ? "SIGEMT" :
#endif
signal == SIGFPE ? "SIGFPE" :
signal == SIGKILL ? "SIGKILL" :
#ifdef SIGBUS /* 4.2 BSD (Bus error ) */
signal == SIGBUS ? "SIGBUS" :
#endif
signal == SIGSEGV ? "SIGSEGV" :
#ifdef SIGSYS /* 4.2 BSD (Bad argument to system call ) */
signal == SIGSYS ? "SIGSYS" :
#endif
signal == SIGPIPE ? "SIGPIPE" :
signal == SIGALRM ? "SIGALRM" :
signal == SIGTERM ? "SIGTERM" :
signal == SIGUSR1 ? "SIGUSR1" :
signal == SIGUSR2 ? "SIGUSR2" :
signal == SIGCHLD ? "SIGCHLD" :
signal == SIGSTOP ? "SIGSTOP" :
signal == SIGTSTP ? "SIGTSTP" :
signal == SIGCONT ? "SIGCONT" :
#ifdef SIGCLD /* System V (Same as SIGCHLD ) */
signal == SIGCLD ? "SIGCLD" :
#endif
#ifdef SIGPWR /* System V (Power failure restart ) */
signal == SIGPWR ? "SIGPWR" :
#endif
signal == SIGXCPU ? "SIGXCPU" :
signal == SIGXFSZ ? "SIGXFSZ" :
signal == SIGWINCH ? "SIGWINCH" : /* non-POSIX, but present on most systems */
as_string(signal);
}
static int signals_program_error(int signal) {
return
signal == SIGILL ||
signal == SIGABRT ||
signal == SIGTRAP ||
#ifdef SIGIOT /* 4.2 BSD (IOT trap ) */
signal == SIGIOT ||
#endif
#ifdef SIGEMT /* 4.2 BSD (EMT trap ) */
signal == SIGEMT ||
#endif
signal == SIGFPE ||
#ifdef SIGBUS /* 4.2 BSD (Bus error ) */
signal == SIGBUS ||
#endif
signal == SIGSEGV ||
#ifdef SIGSYS /* 4.2 BSD (Bad argument to system call ) */
signal == SIGSYS ||
#endif
signal == SIGXCPU ||
signal == SIGXFSZ ||
FALSE ? TRUE : FALSE;
}
rlwrap-0.42/src/redblack.h 0000644 0001751 0000144 00000014042 12404151311 012364 0000000 0000000 /*
* RCS $Id: redblack.h,v 1.9 2003/10/24 01:31:21 damo Exp $
*/
/*
Redblack balanced tree algorithm
Copyright (C) Damian Ivereigh 2000
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See the file COPYING for details.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* Header file for redblack.c, should be included by any code that
** uses redblack.c since it defines the functions
*/
/* Stop multiple includes */
#ifndef _REDBLACK_H
#ifndef RB_CUSTOMIZE
/*
* Without customization, the data member in the tree nodes is a void
* pointer, and you need to pass in a comparison function to be
* applied at runtime. With customization, you specify the data type
* as the macro RB_ENTRY(data_t) (has to be a macro because compilers
* gag on typdef void) and the name of the compare function as the
* value of the macro RB_CMP. Because the comparison function is
* compiled in, RB_CMP only needs to take two arguments. If your
* content type is not a pointer, define INLINE to get direct access.
*/
#define rbdata_t void
#define RB_CMP(s, t, e) (*rbinfo->rb_cmp)(s, t, e)
#undef RB_INLINE
#define RB_ENTRY(name) rb##name
#endif /* RB_CUSTOMIZE */
#ifndef RB_STATIC
#define RB_STATIC
#endif
/* Modes for rblookup */
#define RB_NONE -1 /* None of those below */
#define RB_LUEQUAL 0 /* Only exact match */
#define RB_LUGTEQ 1 /* Exact match or greater */
#define RB_LULTEQ 2 /* Exact match or less */
#define RB_LULESS 3 /* Less than key (not equal to) */
#define RB_LUGREAT 4 /* Greater than key (not equal to) */
#define RB_LUNEXT 5 /* Next key after current */
#define RB_LUPREV 6 /* Prev key before current */
#define RB_LUFIRST 7 /* First key in index */
#define RB_LULAST 8 /* Last key in index */
/* For rbwalk - pinched from search.h */
typedef enum
{
preorder,
postorder,
endorder,
leaf
}
VISIT;
struct RB_ENTRY (lists)
{
const struct RB_ENTRY (node) * rootp;
const struct RB_ENTRY (node) * nextp;
};
#define RBLIST struct RB_ENTRY(lists)
struct RB_ENTRY (tree)
{
#ifndef RB_CUSTOMIZE
/* comparison routine */
int (*rb_cmp) (const void *, const void *, const void *);
/* config data to be passed to rb_cmp */
const void *rb_config;
/* root of tree */
#endif /* RB_CUSTOMIZE */
struct RB_ENTRY (node) * rb_root;
};
#ifndef RB_CUSTOMIZE
RB_STATIC struct RB_ENTRY (tree) *
rbinit(int (*)(const void *, const void *, const void *), const void *);
#else
RB_STATIC struct RB_ENTRY (tree) * RB_ENTRY(init) (void);
#endif /* RB_CUSTOMIZE */
#ifndef no_delete
RB_STATIC const
RB_ENTRY(data_t) *
RB_ENTRY(delete) (const RB_ENTRY(data_t) *, struct RB_ENTRY(tree) *);
#endif
#ifndef no_find
RB_STATIC const RB_ENTRY(data_t) *
RB_ENTRY(find) (const RB_ENTRY(data_t) *, struct RB_ENTRY(tree) *);
#endif
#ifndef no_lookup
RB_STATIC const RB_ENTRY(data_t) * RB_ENTRY(lookup) (int,
const
RB_ENTRY(data_t) *,
struct
RB_ENTRY(tree) *);
#endif
#ifndef no_search
RB_STATIC const RB_ENTRY(data_t) *
RB_ENTRY(search) (const RB_ENTRY(data_t) *, struct RB_ENTRY(tree) *);
#endif
#ifndef no_destroy
RB_STATIC void RB_ENTRY(destroy) (struct RB_ENTRY(tree) *);
#endif
#ifndef no_walk
RB_STATIC void RB_ENTRY(walk) (const struct RB_ENTRY(tree) *,
void (*)(const RB_ENTRY(data_t) *,
const VISIT, const int, void *),
void *);
#endif
#ifndef no_readlist
RB_STATIC RBLIST *RB_ENTRY(openlist) (const struct RB_ENTRY(tree) *);
RB_STATIC const RB_ENTRY(data_t) * RB_ENTRY(readlist) (RBLIST *);
RB_STATIC void RB_ENTRY(closelist) (RBLIST *);
#endif
/* Some useful macros */
#define rbmin(rbinfo) RB_ENTRY(lookup)(RB_LUFIRST, NULL, (rbinfo))
#define rbmax(rbinfo) RB_ENTRY(lookup)(RB_LULAST, NULL, (rbinfo))
#define _REDBLACK_H
#endif /* _REDBLACK_H */
/*
*
* $Log: redblack.h,v $
* Revision 1.9 2003/10/24 01:31:21 damo
* Patches from Eric Raymond: %prefix is implemented. Various other small
* changes avoid stepping on global namespaces and improve the documentation.
*
* Revision 1.8 2003/10/23 04:18:47 damo
* Fixed up the rbgen stuff ready for the 1.3 release
*
* Revision 1.7 2002/08/26 03:11:40 damo
* Fixed up a bunch of compiler warnings when compiling example4
*
* Tidies up the Makefile.am & Specfile.
*
* Renamed redblack to rbgen
*
* Revision 1.6 2002/08/26 01:03:35 damo
* Patch from Eric Raymond to change the way the library is used:-
*
* Eric's idea is to convert libredblack into a piece of in-line code
* generated by another program. This should be faster, smaller and easier
* to use.
*
* This is the first check-in of his code before I start futzing with it!
*
* Revision 1.5 2002/01/30 07:54:53 damo
* Fixed up the libtool versioning stuff (finally)
* Fixed bug 500600 (not detecting a NULL return from malloc)
* Fixed bug 509485 (no longer needs search.h)
* Cleaned up debugging section
* Allow multiple inclusions of redblack.h
* Thanks to Matthias Andree for reporting (and fixing) these
*
* Revision 1.4 2000/06/06 14:43:43 damo
* Added all the rbwalk & rbopenlist stuff. Fixed up malloc instead of sbrk.
* Added two new examples
*
* Revision 1.3 2000/05/24 06:45:27 damo
* Converted everything over to using const
* Added a new example1.c file to demonstrate the worst case scenario
* Minor fixups of the spec file
*
* Revision 1.2 2000/05/24 06:17:10 damo
* Fixed up the License (now the LGPL)
*
* Revision 1.1 2000/05/24 04:15:53 damo
* Initial import of files. Versions are now all over the place. Oh well
*
*/
rlwrap-0.42/src/completion.c 0000644 0001751 0000144 00000123075 12407054416 013003 0000000 0000000 #line 1 "completion.rb"
/* completion.c is generated from completion.rb by the program rbgen
(cf. http://libredblack.sourceforge.net/)
completion.rb: maintaining the completion list, my_completion_function()
(callback for readline lib)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License , or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
You may contact the author by:
e-mail: hlub@knoware.nl
*/
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#include "rlwrap.h"
#ifdef assert
#undef assert
#endif
int completion_is_case_sensitive = 1;
int
compare(const char *string1, const char *string2)
{
const char *p1;
const char *p2;
int count;
for (p1 = string1, p2 = string2, count = 0;
*p1 && *p2 && count < BUFFSIZE; p1++, p2++, count++) {
char c1 = completion_is_case_sensitive ? *p1 : tolower(*p1);
char c2 = completion_is_case_sensitive ? *p2 : tolower(*p2);
if (c1 != c2)
return (c1 < c2 ? -1 : 1);
}
if ((*p1 && *p2) || (!*p1 && !*p2))
return 0;
return (*p1 ? 1 : -1);
}
#ifdef malloc
# undef malloc
#endif
#define malloc(x) mymalloc(x) /* This is a bit evil, but there is no other way to make libredblack use mymalloc() */
/* This file has to be processed by the program rbgen */
/* rbgen generated code begins here */
/* rbgen: $Id: rbgen.in,v 1.3 2003/10/24 01:31:21 damo Exp $ */
#define RB_CUSTOMIZE
#define rbdata_t char
#define RB_CMP(s, t) compare(s, t)
#define RB_ENTRY(name) rb##name
#undef RB_INLINE
#define RB_STATIC static
#line 1 "completion.c"
/*
* RCS $Id: redblack.h,v 1.9 2003/10/24 01:31:21 damo Exp $
*/
/*
Redblack balanced tree algorithm
Copyright (C) Damian Ivereigh 2000
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See the file COPYING for details.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* Header file for redblack.c, should be included by any code that
** uses redblack.c since it defines the functions
*/
/* Stop multiple includes */
#ifndef _REDBLACK_H
#ifndef RB_CUSTOMIZE
/*
* Without customization, the data member in the tree nodes is a void
* pointer, and you need to pass in a comparison function to be
* applied at runtime. With customization, you specify the data type
* as the macro RB_ENTRY(data_t) (has to be a macro because compilers
* gag on typdef void) and the name of the compare function as the
* value of the macro RB_CMP. Because the comparison function is
* compiled in, RB_CMP only needs to take two arguments. If your
* content type is not a pointer, define INLINE to get direct access.
*/
#define rbdata_t void
#define RB_CMP(s, t, e) (*rbinfo->rb_cmp)(s, t, e)
#undef RB_INLINE
#define RB_ENTRY(name) rb##name
#endif /* RB_CUSTOMIZE */
#ifndef RB_STATIC
#define RB_STATIC
#endif
/* Modes for rblookup */
#define RB_NONE -1 /* None of those below */
#define RB_LUEQUAL 0 /* Only exact match */
#define RB_LUGTEQ 1 /* Exact match or greater */
#define RB_LULTEQ 2 /* Exact match or less */
#define RB_LULESS 3 /* Less than key (not equal to) */
#define RB_LUGREAT 4 /* Greater than key (not equal to) */
#define RB_LUNEXT 5 /* Next key after current */
#define RB_LUPREV 6 /* Prev key before current */
#define RB_LUFIRST 7 /* First key in index */
#define RB_LULAST 8 /* Last key in index */
/* For rbwalk - pinched from search.h */
typedef enum
{
preorder,
postorder,
endorder,
leaf
}
VISIT;
struct RB_ENTRY(lists) {
const struct RB_ENTRY(node) *rootp;
const struct RB_ENTRY(node) *nextp;
};
#define RBLIST struct RB_ENTRY(lists)
struct RB_ENTRY(tree) {
#ifndef RB_CUSTOMIZE
/* comparison routine */
int (*rb_cmp)(const void *, const void *, const void *);
/* config data to be passed to rb_cmp */
const void *rb_config;
/* root of tree */
#endif /* RB_CUSTOMIZE */
struct RB_ENTRY(node) *rb_root;
};
#ifndef RB_CUSTOMIZE
RB_STATIC struct RB_ENTRY(tree) *rbinit(int (*)(const void *, const void *, const void *),
const void *);
#else
RB_STATIC struct RB_ENTRY(tree) *RB_ENTRY(init)(void);
#endif /* RB_CUSTOMIZE */
#ifndef no_delete
RB_STATIC const RB_ENTRY(data_t) *RB_ENTRY(delete)(const RB_ENTRY(data_t) *, struct RB_ENTRY(tree) *);
#endif
#ifndef no_find
RB_STATIC const RB_ENTRY(data_t) *RB_ENTRY(find)(const RB_ENTRY(data_t) *, struct RB_ENTRY(tree) *);
#endif
#ifndef no_lookup
RB_STATIC const RB_ENTRY(data_t) *RB_ENTRY(lookup)(int, const RB_ENTRY(data_t) *, struct RB_ENTRY(tree) *);
#endif
#ifndef no_search
RB_STATIC const RB_ENTRY(data_t) *RB_ENTRY(search)(const RB_ENTRY(data_t) *, struct RB_ENTRY(tree) *);
#endif
#ifndef no_destroy
RB_STATIC void RB_ENTRY(destroy)(struct RB_ENTRY(tree) *);
#endif
#ifndef no_walk
RB_STATIC void RB_ENTRY(walk)(const struct RB_ENTRY(tree) *,
void (*)(const RB_ENTRY(data_t) *, const VISIT, const int, void *),
void *);
#endif
#ifndef no_readlist
RB_STATIC RBLIST *RB_ENTRY(openlist)(const struct RB_ENTRY(tree) *);
RB_STATIC const RB_ENTRY(data_t) *RB_ENTRY(readlist)(RBLIST *);
RB_STATIC void RB_ENTRY(closelist)(RBLIST *);
#endif
/* Some useful macros */
#define rbmin(rbinfo) RB_ENTRY(lookup)(RB_LUFIRST, NULL, (rbinfo))
#define rbmax(rbinfo) RB_ENTRY(lookup)(RB_LULAST, NULL, (rbinfo))
#define _REDBLACK_H
#endif /* _REDBLACK_H */
/*
*
* $Log: redblack.h,v $
* Revision 1.9 2003/10/24 01:31:21 damo
* Patches from Eric Raymond: %prefix is implemented. Various other small
* changes avoid stepping on global namespaces and improve the documentation.
*
* Revision 1.8 2003/10/23 04:18:47 damo
* Fixed up the rbgen stuff ready for the 1.3 release
*
* Revision 1.7 2002/08/26 03:11:40 damo
* Fixed up a bunch of compiler warnings when compiling example4
*
* Tidies up the Makefile.am & Specfile.
*
* Renamed redblack to rbgen
*
* Revision 1.6 2002/08/26 01:03:35 damo
* Patch from Eric Raymond to change the way the library is used:-
*
* Eric's idea is to convert libredblack into a piece of in-line code
* generated by another program. This should be faster, smaller and easier
* to use.
*
* This is the first check-in of his code before I start futzing with it!
*
* Revision 1.5 2002/01/30 07:54:53 damo
* Fixed up the libtool versioning stuff (finally)
* Fixed bug 500600 (not detecting a NULL return from malloc)
* Fixed bug 509485 (no longer needs search.h)
* Cleaned up debugging section
* Allow multiple inclusions of redblack.h
* Thanks to Matthias Andree for reporting (and fixing) these
*
* Revision 1.4 2000/06/06 14:43:43 damo
* Added all the rbwalk & rbopenlist stuff. Fixed up malloc instead of sbrk.
* Added two new examples
*
* Revision 1.3 2000/05/24 06:45:27 damo
* Converted everything over to using const
* Added a new example1.c file to demonstrate the worst case scenario
* Minor fixups of the spec file
*
* Revision 1.2 2000/05/24 06:17:10 damo
* Fixed up the License (now the LGPL)
*
* Revision 1.1 2000/05/24 04:15:53 damo
* Initial import of files. Versions are now all over the place. Oh well
*
*/
static char rcsid[]="$Id: redblack.c,v 1.9 2003/10/24 01:31:21 damo Exp $";
/*
Redblack balanced tree algorithm
Copyright (C) Damian Ivereigh 2000
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version. See the file COPYING for details.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* Implement the red/black tree structure. It is designed to emulate
** the standard tsearch() stuff. i.e. the calling conventions are
** exactly the same
*/
#include
#include
#include
#include "redblack.h"
#define assert(expr)
/* Uncomment this if you would rather use a raw sbrk to get memory
** (however the memory is never released again (only re-used). Can't
** see any point in using this these days.
*/
/* #define USE_SBRK */
enum nodecolour { BLACK, RED };
struct RB_ENTRY(node)
{
struct RB_ENTRY(node) *left; /* Left down */
struct RB_ENTRY(node) *right; /* Right down */
struct RB_ENTRY(node) *up; /* Up */
enum nodecolour colour; /* Node colour */
#ifdef RB_INLINE
RB_ENTRY(data_t) key; /* User's key (and data) */
#define RB_GET(x,y) &x->y
#define RB_SET(x,y,v) x->y = *(v)
#else
const RB_ENTRY(data_t) *key; /* Pointer to user's key (and data) */
#define RB_GET(x,y) x->y
#define RB_SET(x,y,v) x->y = v
#endif /* RB_INLINE */
};
/* Dummy (sentinel) node, so that we can make X->left->up = X
** We then use this instead of NULL to mean the top or bottom
** end of the rb tree. It is a black node.
**
** Initialization of the last field in this initializer is left implicit
** because it could be of any type. We count on the compiler to zero it.
*/
struct RB_ENTRY(node) RB_ENTRY(_null)={&RB_ENTRY(_null), &RB_ENTRY(_null), &RB_ENTRY(_null), BLACK};
#define RBNULL (&RB_ENTRY(_null))
#if defined(USE_SBRK)
static struct RB_ENTRY(node) *RB_ENTRY(_alloc)();
static void RB_ENTRY(_free)(struct RB_ENTRY(node) *);
#else
static struct RB_ENTRY(node) *RB_ENTRY(_alloc)() {return (struct RB_ENTRY(node) *) malloc(sizeof(struct RB_ENTRY(node)));}
static void RB_ENTRY(_free)(struct RB_ENTRY(node) *x) {free(x);}
#endif
/* These functions are always needed */
static void RB_ENTRY(_left_rotate)(struct RB_ENTRY(node) **, struct RB_ENTRY(node) *);
static void RB_ENTRY(_right_rotate)(struct RB_ENTRY(node) **, struct RB_ENTRY(node) *);
static struct RB_ENTRY(node) *RB_ENTRY(_successor)(const struct RB_ENTRY(node) *);
static struct RB_ENTRY(node) *RB_ENTRY(_predecessor)(const struct RB_ENTRY(node) *);
static struct RB_ENTRY(node) *RB_ENTRY(_traverse)(int, const RB_ENTRY(data_t) * , struct RB_ENTRY(tree) *);
/* These functions may not be needed */
#ifndef no_lookup
static struct RB_ENTRY(node) *RB_ENTRY(_lookup)(int, const RB_ENTRY(data_t) * , struct RB_ENTRY(tree) *);
#endif
#ifndef no_destroy
static void RB_ENTRY(_destroy)(struct RB_ENTRY(node) *);
#endif
#ifndef no_delete
static void RB_ENTRY(_delete)(struct RB_ENTRY(node) **, struct RB_ENTRY(node) *);
static void RB_ENTRY(_delete_fix)(struct RB_ENTRY(node) **, struct RB_ENTRY(node) *);
#endif
#ifndef no_walk
static void RB_ENTRY(_walk)(const struct RB_ENTRY(node) *, void (*)(const RB_ENTRY(data_t) *, const VISIT, const int, void *), void *, int);
#endif
#ifndef no_readlist
static RBLIST *RB_ENTRY(_openlist)(const struct RB_ENTRY(node) *);
static const RB_ENTRY(data_t) * RB_ENTRY(_readlist)(RBLIST *);
static void RB_ENTRY(_closelist)(RBLIST *);
#endif
/*
** OK here we go, the balanced tree stuff. The algorithm is the
** fairly standard red/black taken from "Introduction to Algorithms"
** by Cormen, Leiserson & Rivest. Maybe one of these days I will
** fully understand all this stuff.
**
** Basically a red/black balanced tree has the following properties:-
** 1) Every node is either red or black (colour is RED or BLACK)
** 2) A leaf (RBNULL pointer) is considered black
** 3) If a node is red then its children are black
** 4) Every path from a node to a leaf contains the same no
** of black nodes
**
** 3) & 4) above guarantee that the longest path (alternating
** red and black nodes) is only twice as long as the shortest
** path (all black nodes). Thus the tree remains fairly balanced.
*/
/*
* Initialise a tree. Identifies the comparison routine and any config
* data that must be sent to it when called.
* Returns a pointer to the top of the tree.
*/
#ifndef RB_CUSTOMIZE
RB_STATIC struct RB_ENTRY(tree) *
rbinit(int (*cmp)(const void *, const void *, const void *), const void *config)
#else
RB_STATIC struct RB_ENTRY(tree) *RB_ENTRY(init)(void)
#endif /* RB_CUSTOMIZE */
{
struct RB_ENTRY(tree) *retval;
char c;
c=rcsid[0]; /* This does nothing but shutup the -Wall */
if ((retval=(struct RB_ENTRY(tree) *) malloc(sizeof(struct RB_ENTRY(tree))))==NULL)
return(NULL);
#ifndef RB_CUSTOMIZE
retval->rb_cmp=cmp;
retval->rb_config=config;
#endif /* RB_CUSTOMIZE */
retval->rb_root=RBNULL;
return(retval);
}
#ifndef no_destroy
RB_STATIC void
RB_ENTRY(destroy)(struct RB_ENTRY(tree) *rbinfo)
{
if (rbinfo==NULL)
return;
if (rbinfo->rb_root!=RBNULL)
RB_ENTRY(_destroy)(rbinfo->rb_root);
free(rbinfo);
}
#endif /* no_destroy */
#ifndef no_search
RB_STATIC const RB_ENTRY(data_t) *
RB_ENTRY(search)(const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
struct RB_ENTRY(node) *x;
if (rbinfo==NULL)
return(NULL);
x=RB_ENTRY(_traverse)(1, key, rbinfo);
return((x==RBNULL) ? NULL : RB_GET(x, key));
}
#endif /* no_search */
#ifndef no_find
RB_STATIC const RB_ENTRY(data_t) *
RB_ENTRY(find)(const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
struct RB_ENTRY(node) *x;
if (rbinfo==NULL)
return(NULL);
/* If we have a NULL root (empty tree) then just return */
if (rbinfo->rb_root==RBNULL)
return(NULL);
x=RB_ENTRY(_traverse)(0, key, rbinfo);
return((x==RBNULL) ? NULL : RB_GET(x, key));
}
#endif /* no_find */
#ifndef no_delete
RB_STATIC const RB_ENTRY(data_t) *
RB_ENTRY(delete)(const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
struct RB_ENTRY(node) *x;
const RB_ENTRY(data_t) * y;
if (rbinfo==NULL)
return(NULL);
x=RB_ENTRY(_traverse)(0, key, rbinfo);
if (x==RBNULL)
{
return(NULL);
}
else
{
y=RB_GET(x, key);
RB_ENTRY(_delete)(&rbinfo->rb_root, x);
return(y);
}
}
#endif /* no_delete */
#ifndef no_walk
RB_STATIC void
RB_ENTRY(walk)(const struct RB_ENTRY(tree) *rbinfo, void (*action)(const RB_ENTRY(data_t) *, const VISIT, const int, void *), void *arg)
{
if (rbinfo==NULL)
return;
RB_ENTRY(_walk)(rbinfo->rb_root, action, arg, 0);
}
#endif /* no_walk */
#ifndef no_readlist
RB_STATIC RBLIST *
RB_ENTRY(openlist)(const struct RB_ENTRY(tree) *rbinfo)
{
if (rbinfo==NULL)
return(NULL);
return(RB_ENTRY(_openlist)(rbinfo->rb_root));
}
RB_STATIC const RB_ENTRY(data_t) *
RB_ENTRY(readlist)(RBLIST *rblistp)
{
if (rblistp==NULL)
return(NULL);
return(RB_ENTRY(_readlist)(rblistp));
}
RB_STATIC void
RB_ENTRY(closelist)(RBLIST *rblistp)
{
if (rblistp==NULL)
return;
RB_ENTRY(_closelist)(rblistp);
}
#endif /* no_readlist */
#ifndef no_lookup
RB_STATIC const RB_ENTRY(data_t) *
RB_ENTRY(lookup)(int mode, const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
struct RB_ENTRY(node) *x;
/* If we have a NULL root (empty tree) then just return NULL */
if (rbinfo==NULL || rbinfo->rb_root==NULL)
return(NULL);
x=RB_ENTRY(_lookup)(mode, key, rbinfo);
return((x==RBNULL) ? NULL : RB_GET(x, key));
}
#endif /* no_lookup */
/* --------------------------------------------------------------------- */
/* Search for and if not found and insert is true, will add a new
** node in. Returns a pointer to the new node, or the node found
*/
static struct RB_ENTRY(node) *
RB_ENTRY(_traverse)(int insert, const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
struct RB_ENTRY(node) *x,*y,*z;
int cmp;
int found=0;
int cmpmods();
y=RBNULL; /* points to the parent of x */
x=rbinfo->rb_root;
/* walk x down the tree */
while(x!=RBNULL && found==0)
{
y=x;
/* printf("key=%s, RB_GET(x, key)=%s\n", key, RB_GET(x, key)); */
#ifndef RB_CUSTOMIZE
cmp=RB_CMP(key, RB_GET(x, key), rbinfo->rb_config);
#else
cmp=RB_CMP(key, RB_GET(x, key));
#endif /* RB_CUSTOMIZE */
if (cmp<0)
x=x->left;
else if (cmp>0)
x=x->right;
else
found=1;
}
if (found || !insert)
return(x);
if ((z=RB_ENTRY(_alloc)())==NULL)
{
/* Whoops, no memory */
return(RBNULL);
}
RB_SET(z, key, key);
z->up=y;
if (y==RBNULL)
{
rbinfo->rb_root=z;
}
else
{
#ifndef RB_CUSTOMIZE
cmp=RB_CMP(RB_GET(z, key), RB_GET(y, key), rbinfo->rb_config);
#else
cmp=RB_CMP(RB_GET(z, key), RB_GET(y, key));
#endif /* RB_CUSTOMIZE */
if (cmp<0)
y->left=z;
else
y->right=z;
}
z->left=RBNULL;
z->right=RBNULL;
/* colour this new node red */
z->colour=RED;
/* Having added a red node, we must now walk back up the tree balancing
** it, by a series of rotations and changing of colours
*/
x=z;
/* While we are not at the top and our parent node is red
** N.B. Since the root node is garanteed black, then we
** are also going to stop if we are the child of the root
*/
while(x != rbinfo->rb_root && (x->up->colour == RED))
{
/* if our parent is on the left side of our grandparent */
if (x->up == x->up->up->left)
{
/* get the right side of our grandparent (uncle?) */
y=x->up->up->right;
if (y->colour == RED)
{
/* make our parent black */
x->up->colour = BLACK;
/* make our uncle black */
y->colour = BLACK;
/* make our grandparent red */
x->up->up->colour = RED;
/* now consider our grandparent */
x=x->up->up;
}
else
{
/* if we are on the right side of our parent */
if (x == x->up->right)
{
/* Move up to our parent */
x=x->up;
RB_ENTRY(_left_rotate)(&rbinfo->rb_root, x);
}
/* make our parent black */
x->up->colour = BLACK;
/* make our grandparent red */
x->up->up->colour = RED;
/* right rotate our grandparent */
RB_ENTRY(_right_rotate)(&rbinfo->rb_root, x->up->up);
}
}
else
{
/* everything here is the same as above, but
** exchanging left for right
*/
y=x->up->up->left;
if (y->colour == RED)
{
x->up->colour = BLACK;
y->colour = BLACK;
x->up->up->colour = RED;
x=x->up->up;
}
else
{
if (x == x->up->left)
{
x=x->up;
RB_ENTRY(_right_rotate)(&rbinfo->rb_root, x);
}
x->up->colour = BLACK;
x->up->up->colour = RED;
RB_ENTRY(_left_rotate)(&rbinfo->rb_root, x->up->up);
}
}
}
/* Set the root node black */
(rbinfo->rb_root)->colour = BLACK;
return(z);
}
#ifndef no_lookup
/* Search for a key according to mode (see redblack.h)
*/
static struct RB_ENTRY(node) *
RB_ENTRY(_lookup)(int mode, const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
struct RB_ENTRY(node) *x,*y;
int cmp;
int found=0;
y=RBNULL; /* points to the parent of x */
x=rbinfo->rb_root;
if (mode==RB_LUFIRST)
{
/* Keep going left until we hit a NULL */
while(x!=RBNULL)
{
y=x;
x=x->left;
}
return(y);
}
else if (mode==RB_LULAST)
{
/* Keep going right until we hit a NULL */
while(x!=RBNULL)
{
y=x;
x=x->right;
}
return(y);
}
/* walk x down the tree */
while(x!=RBNULL && found==0)
{
y=x;
/* printf("key=%s, RB_GET(x, key)=%s\n", key, RB_GET(x, key)); */
#ifndef RB_CUSTOMIZE
cmp=RB_CMP(key, RB_GET(x, key), rbinfo->rb_config);
#else
cmp=RB_CMP(key, RB_GET(x, key));
#endif /* RB_CUSTOMIZE */
if (cmp<0)
x=x->left;
else if (cmp>0)
x=x->right;
else
found=1;
}
if (found && (mode==RB_LUEQUAL || mode==RB_LUGTEQ || mode==RB_LULTEQ))
return(x);
if (!found && (mode==RB_LUEQUAL || mode==RB_LUNEXT || mode==RB_LUPREV))
return(RBNULL);
if (mode==RB_LUGTEQ || (!found && mode==RB_LUGREAT))
{
if (cmp>0)
return(RB_ENTRY(_successor)(y));
else
return(y);
}
if (mode==RB_LULTEQ || (!found && mode==RB_LULESS))
{
if (cmp<0)
return(RB_ENTRY(_predecessor)(y));
else
return(y);
}
if (mode==RB_LUNEXT || (found && mode==RB_LUGREAT))
return(RB_ENTRY(_successor)(x));
if (mode==RB_LUPREV || (found && mode==RB_LULESS))
return(RB_ENTRY(_predecessor)(x));
/* Shouldn't get here */
return(RBNULL);
}
#endif /* no_lookup */
#ifndef no_destroy
/*
* Destroy all the elements blow us in the tree
* only useful as part of a complete tree destroy.
*/
static void
RB_ENTRY(_destroy)(struct RB_ENTRY(node) *x)
{
if (x!=RBNULL)
{
if (x->left!=RBNULL)
RB_ENTRY(_destroy)(x->left);
if (x->right!=RBNULL)
RB_ENTRY(_destroy)(x->right);
RB_ENTRY(_free)(x);
}
}
#endif /* no_destroy */
/*
** Rotate our tree thus:-
**
** X rb_left_rotate(X)---> Y
** / \ / \
** A Y <---rb_right_rotate(Y) X C
** / \ / \
** B C A B
**
** N.B. This does not change the ordering.
**
** We assume that neither X or Y is NULL
*/
static void
RB_ENTRY(_left_rotate)(struct RB_ENTRY(node) **rootp, struct RB_ENTRY(node) *x)
{
struct RB_ENTRY(node) *y;
assert(x!=RBNULL);
assert(x->right!=RBNULL);
y=x->right; /* set Y */
/* Turn Y's left subtree into X's right subtree (move B)*/
x->right = y->left;
/* If B is not null, set it's parent to be X */
if (y->left != RBNULL)
y->left->up = x;
/* Set Y's parent to be what X's parent was */
y->up = x->up;
/* if X was the root */
if (x->up == RBNULL)
{
*rootp=y;
}
else
{
/* Set X's parent's left or right pointer to be Y */
if (x == x->up->left)
{
x->up->left=y;
}
else
{
x->up->right=y;
}
}
/* Put X on Y's left */
y->left=x;
/* Set X's parent to be Y */
x->up = y;
}
static void
RB_ENTRY(_right_rotate)(struct RB_ENTRY(node) **rootp, struct RB_ENTRY(node) *y)
{
struct RB_ENTRY(node) *x;
assert(y!=RBNULL);
assert(y->left!=RBNULL);
x=y->left; /* set X */
/* Turn X's right subtree into Y's left subtree (move B) */
y->left = x->right;
/* If B is not null, set it's parent to be Y */
if (x->right != RBNULL)
x->right->up = y;
/* Set X's parent to be what Y's parent was */
x->up = y->up;
/* if Y was the root */
if (y->up == RBNULL)
{
*rootp=x;
}
else
{
/* Set Y's parent's left or right pointer to be X */
if (y == y->up->left)
{
y->up->left=x;
}
else
{
y->up->right=x;
}
}
/* Put Y on X's right */
x->right=y;
/* Set Y's parent to be X */
y->up = x;
}
/* Return a pointer to the smallest key greater than x
*/
static struct RB_ENTRY(node) *
RB_ENTRY(_successor)(const struct RB_ENTRY(node) *x)
{
struct RB_ENTRY(node) *y;
if (x->right!=RBNULL)
{
/* If right is not NULL then go right one and
** then keep going left until we find a node with
** no left pointer.
*/
for (y=x->right; y->left!=RBNULL; y=y->left);
}
else
{
/* Go up the tree until we get to a node that is on the
** left of its parent (or the root) and then return the
** parent.
*/
y=x->up;
while(y!=RBNULL && x==y->right)
{
x=y;
y=y->up;
}
}
return(y);
}
/* Return a pointer to the largest key smaller than x
*/
static struct RB_ENTRY(node) *
RB_ENTRY(_predecessor)(const struct RB_ENTRY(node) *x)
{
struct RB_ENTRY(node) *y;
if (x->left!=RBNULL)
{
/* If left is not NULL then go left one and
** then keep going right until we find a node with
** no right pointer.
*/
for (y=x->left; y->right!=RBNULL; y=y->right);
}
else
{
/* Go up the tree until we get to a node that is on the
** right of its parent (or the root) and then return the
** parent.
*/
y=x->up;
while(y!=RBNULL && x==y->left)
{
x=y;
y=y->up;
}
}
return(y);
}
#ifndef no_delete
/* Delete the node z, and free up the space
*/
static void
RB_ENTRY(_delete)(struct RB_ENTRY(node) **rootp, struct RB_ENTRY(node) *z)
{
struct RB_ENTRY(node) *x, *y;
if (z->left == RBNULL || z->right == RBNULL)
y=z;
else
y=RB_ENTRY(_successor)(z);
if (y->left != RBNULL)
x=y->left;
else
x=y->right;
x->up = y->up;
if (y->up == RBNULL)
{
*rootp=x;
}
else
{
if (y==y->up->left)
y->up->left = x;
else
y->up->right = x;
}
if (y!=z)
{
RB_SET(z, key, RB_GET(y, key));
}
if (y->colour == BLACK)
RB_ENTRY(_delete_fix)(rootp, x);
RB_ENTRY(_free)(y);
}
/* Restore the reb-black properties after a delete */
static void
RB_ENTRY(_delete_fix)(struct RB_ENTRY(node) **rootp, struct RB_ENTRY(node) *x)
{
struct RB_ENTRY(node) *w;
while (x!=*rootp && x->colour==BLACK)
{
if (x==x->up->left)
{
w=x->up->right;
if (w->colour==RED)
{
w->colour=BLACK;
x->up->colour=RED;
rb_left_rotate(rootp, x->up);
w=x->up->right;
}
if (w->left->colour==BLACK && w->right->colour==BLACK)
{
w->colour=RED;
x=x->up;
}
else
{
if (w->right->colour == BLACK)
{
w->left->colour=BLACK;
w->colour=RED;
RB_ENTRY(_right_rotate)(rootp, w);
w=x->up->right;
}
w->colour=x->up->colour;
x->up->colour = BLACK;
w->right->colour = BLACK;
RB_ENTRY(_left_rotate)(rootp, x->up);
x=*rootp;
}
}
else
{
w=x->up->left;
if (w->colour==RED)
{
w->colour=BLACK;
x->up->colour=RED;
RB_ENTRY(_right_rotate)(rootp, x->up);
w=x->up->left;
}
if (w->right->colour==BLACK && w->left->colour==BLACK)
{
w->colour=RED;
x=x->up;
}
else
{
if (w->left->colour == BLACK)
{
w->right->colour=BLACK;
w->colour=RED;
RB_ENTRY(_left_rotate)(rootp, w);
w=x->up->left;
}
w->colour=x->up->colour;
x->up->colour = BLACK;
w->left->colour = BLACK;
RB_ENTRY(_right_rotate)(rootp, x->up);
x=*rootp;
}
}
}
x->colour=BLACK;
}
#endif /* no_delete */
#ifndef no_walk
static void
RB_ENTRY(_walk)(const struct RB_ENTRY(node) *x, void (*action)(const RB_ENTRY(data_t) *, const VISIT, const int, void *), void *arg, int level)
{
if (x==RBNULL)
return;
if (x->left==RBNULL && x->right==RBNULL)
{
/* leaf */
(*action)(RB_GET(x, key), leaf, level, arg);
}
else
{
(*action)(RB_GET(x, key), preorder, level, arg);
RB_ENTRY(_walk)(x->left, action, arg, level+1);
(*action)(RB_GET(x, key), postorder, level, arg);
RB_ENTRY(_walk)(x->right, action, arg, level+1);
(*action)(RB_GET(x, key), endorder, level, arg);
}
}
#endif /* no_walk */
#ifndef no_readlist
static RBLIST *
RB_ENTRY(_openlist)(const struct RB_ENTRY(node) *rootp)
{
RBLIST *rblistp;
rblistp=(RBLIST *) malloc(sizeof(RBLIST));
if (!rblistp)
return(NULL);
rblistp->rootp=rootp;
rblistp->nextp=rootp;
if (rootp!=RBNULL)
{
while(rblistp->nextp->left!=RBNULL)
{
rblistp->nextp=rblistp->nextp->left;
}
}
return(rblistp);
}
static const RB_ENTRY(data_t) *
RB_ENTRY(_readlist)(RBLIST *rblistp)
{
const RB_ENTRY(data_t) *key=NULL;
if (rblistp!=NULL && rblistp->nextp!=RBNULL)
{
key=RB_GET(rblistp->nextp, key);
rblistp->nextp=RB_ENTRY(_successor)(rblistp->nextp);
}
return(key);
}
static void
rb_closelist(RBLIST *rblistp)
{
if (rblistp)
free(rblistp);
}
#endif /* no_readlist */
#if defined(RB_USE_SBRK)
/* Allocate space for our nodes, allowing us to get space from
** sbrk in larger chucks.
*/
static struct RB_ENTRY(node) *rbfreep=NULL;
#define RB_ENTRY(NODE)ALLOC_CHUNK_SIZE 1000
static struct RB_ENTRY(node) *
RB_ENTRY(_alloc)()
{
struct RB_ENTRY(node) *x;
int i;
if (rbfreep==NULL)
{
/* must grab some more space */
rbfreep=(struct RB_ENTRY(node) *) sbrk(sizeof(struct RB_ENTRY(node)) * RB_ENTRY(NODE)ALLOC_CHUNK_SIZE);
if (rbfreep==(struct RB_ENTRY(node) *) -1)
{
return(NULL);
}
/* tie them together in a linked list (use the up pointer) */
for (i=0, x=rbfreep; iup = (x+1);
}
x->up=NULL;
}
x=rbfreep;
rbfreep = rbfreep->up;
#ifdef RB_ALLOC
RB_ALLOC(ACCESS(x, key));
#endif /* RB_ALLOC */
return(x);
}
/* free (dealloc) an RB_ENTRY(node) structure - add it onto the front of the list
** N.B. RB_ENTRY(node) need not have been allocated through rb_alloc()
*/
static void
RB_ENTRY(_free)(struct RB_ENTRY(node) *x)
{
#ifdef RB_FREE
RB_FREE(ACCESS(x, key));
#endif /* RB_FREE */
x->up=rbfreep;
rbfreep=x;
}
#endif
#if 0
int
RB_ENTRY(_check)(struct RB_ENTRY(node) *rootp)
{
if (rootp==NULL || rootp==RBNULL)
return(0);
if (rootp->up!=RBNULL)
{
fprintf(stderr, "Root up pointer not RBNULL");
dumptree(rootp, 0);
return(1);
}
if (RB_ENTRY(_check)1(rootp))
{
RB_ENTRY(dumptree)(rootp, 0);
return(1);
}
if (RB_ENTRY(count_black)(rootp)==-1)
{
RB_ENTRY(dumptree)(rootp, 0);
return(-1);
}
return(0);
}
int
RB_ENTRY(_check1)(struct RB_ENTRY(node) *x)
{
if (x->left==NULL || x->right==NULL)
{
fprintf(stderr, "Left or right is NULL");
return(1);
}
if (x->colour==RED)
{
if (x->left->colour!=BLACK && x->right->colour!=BLACK)
{
fprintf(stderr, "Children of red node not both black, x=%ld", x);
return(1);
}
}
if (x->left != RBNULL)
{
if (x->left->up != x)
{
fprintf(stderr, "x->left->up != x, x=%ld", x);
return(1);
}
if (rb_check1(x->left))
return(1);
}
if (x->right != RBNULL)
{
if (x->right->up != x)
{
fprintf(stderr, "x->right->up != x, x=%ld", x);
return(1);
}
if (rb_check1(x->right))
return(1);
}
return(0);
}
RB_ENTRY(count_black)(struct RB_ENTRY(node) *x)
{
int nleft, nright;
if (x==RBNULL)
return(1);
nleft=RB_ENTRY(count_black)(x->left);
nright=RB_ENTRY(count_black)(x->right);
if (nleft==-1 || nright==-1)
return(-1);
if (nleft != nright)
{
fprintf(stderr, "Black count not equal on left & right, x=%ld", x);
return(-1);
}
if (x->colour == BLACK)
{
nleft++;
}
return(nleft);
}
RB_ENTRY(dumptree)(struct RB_ENTRY(node) *x, int n)
{
char *prkey();
if (x!=NULL && x!=RBNULL)
{
n++;
fprintf(stderr, "Tree: %*s %ld: left=%ld, right=%ld, colour=%s, key=%s",
n,
"",
x,
x->left,
x->right,
(x->colour==BLACK) ? "BLACK" : "RED",
prkey(RB_GET(x, key)));
RB_ENTRY(dumptree)(x->left, n);
RB_ENTRY(dumptree)(x->right, n);
}
}
#endif
/*
* $Log: redblack.c,v $
* Revision 1.9 2003/10/24 01:31:21 damo
* Patches from Eric Raymond: %prefix is implemented. Various other small
* changes avoid stepping on global namespaces and improve the documentation.
*
* Revision 1.8 2002/08/26 05:33:47 damo
* Some minor fixes:-
* Stopped ./configure warning about stuff being in the wrong order
* Fixed compiler warning about const (not sure about this)
* Changed directory of redblack.c in documentation
*
* Revision 1.7 2002/08/26 03:11:40 damo
* Fixed up a bunch of compiler warnings when compiling example4
*
* Tidies up the Makefile.am & Specfile.
*
* Renamed redblack to rbgen
*
* Revision 1.6 2002/08/26 01:03:35 damo
* Patch from Eric Raymond to change the way the library is used:-
*
* Eric's idea is to convert libredblack into a piece of in-line code
* generated by another program. This should be faster, smaller and easier
* to use.
*
* This is the first check-in of his code before I start futzing with it!
*
* Revision 1.5 2002/01/30 07:54:53 damo
* Fixed up the libtool versioning stuff (finally)
* Fixed bug 500600 (not detecting a NULL return from malloc)
* Fixed bug 509485 (no longer needs search.h)
* Cleaned up debugging section
* Allow multiple inclusions of redblack.h
* Thanks to Matthias Andree for reporting (and fixing) these
*
* Revision 1.4 2000/06/06 14:43:43 damo
* Added all the rbwalk & rbopenlist stuff. Fixed up malloc instead of sbrk.
* Added two new examples
*
* Revision 1.3 2000/05/24 06:45:27 damo
* Converted everything over to using const
* Added a new example1.c file to demonstrate the worst case scenario
* Minor fixups of the spec file
*
* Revision 1.2 2000/05/24 06:17:10 damo
* Fixed up the License (now the LGPL)
*
* Revision 1.1 2000/05/24 04:15:53 damo
* Initial import of files. Versions are now all over the place. Oh well
*
*/
/* rbgen generated code ends here */
#line 77 "completion.rb"
/* forward declarations */
static struct rbtree *completion_tree;
static char *my_history_completion_function(char *prefix, int state);
static void print_list(void);
static void
my_rbdestroy(struct rbtree *rb)
{ /* destroy rb tree, freeing the keys first */
const char *key, *lastkey;
for (key = rbmin(rb);
key;
lastkey = key, key =
rblookup(RB_LUGREAT, key, rb), free((void *)lastkey))
rbdelete(key, rb);
rbdestroy(rb);
}
static void
print_list()
{
const char *word;
RBLIST *completion_list = rbopenlist(completion_tree); /* uses mymalloc() internally, so no chance of getting a NULL pointer back */
printf("Completions:\n");
while ((word = rbreadlist(completion_list)))
printf("%s\n", word);
rbcloselist(completion_list);
}
static char *rbtree_to_string(const struct rbtree *rb, int max_items) {
const char *word;
char *result = NULL;
int i;
RBLIST *list = rbopenlist(rb);
for (i = 0; (word = rbreadlist(list)) && (i < max_items); i++) {
if (i > 0)
result = append_and_free_old(result, ", ");
result = append_and_free_old(result, word);
}
if (i >= max_items)
result = append_and_free_old(result, "...");
rbcloselist(list);
return result;
}
void
init_completer()
{
completion_tree = rbinit();
}
void
add_word_to_completions(const char *word)
{
rbsearch(mysavestring(word), completion_tree); /* the tree stores *pointers* to the words, we have to allocate copies of them ourselves
freeing the tree will call free on the pointers to the words
valgrind reports the copies as lost, I don't understand this.' */
}
void
remove_word_from_completions(const char *word)
{
free((char *) rbdelete(word, completion_tree)); /* why does rbdelete return a const *? I want to be able to free it! */
}
void
feed_line_into_completion_list(const char *line)
{
char **words = split_with(line, rl_basic_word_break_characters);
char **plist, *word;
for(plist = words;(word = *plist); plist++)
add_word_to_completions(word);
free_splitlist(words);
}
void
feed_file_into_completion_list(const char *completions_file)
{
FILE *compl_fp;
char buffer[BUFFSIZE];
if ((compl_fp = fopen(completions_file, "r")) == NULL)
myerror(FATAL|USE_ERRNO, "Could not open %s", completions_file);
while (fgets(buffer, BUFFSIZE - 1, compl_fp) != NULL) {
buffer[BUFFSIZE - 1] = '\0'; /* make sure buffer is properly terminated (it should be anyway, according to ANSI) */
feed_line_into_completion_list(buffer);
}
if (! feof(compl_fp) && ferror(compl_fp)) /* at least in GNU libc, errno will be set in this case. If not, no harm is done */
myerror(FATAL|USE_ERRNO, "Couldn't read completions from %s", completions_file);
fclose(compl_fp);
/* print_list(); */
}
#define COMPLETE_FILENAMES 1
#define COMPLETE_FROM_LIST 2
#define COMPLETE_USERNAMES 4
#define FILTER_COMPLETIONS 8
#define COMPLETE_PARANORMALLY 16 /* read user's thoughts */
int
get_completion_type()
{ /* some day, this function will inspect the current line and make rlwrap complete
differently according to the word *preceding* the one we're completing ' */
return (COMPLETE_FROM_LIST | (complete_filenames ? COMPLETE_FILENAMES : 0) | (filter_pid ? FILTER_COMPLETIONS : 0));
}
/* helper function for my_completion_function */
static int
is_prefix(const char *s0, const char *s1)
{ /* s0 is prefix of s1 */
const char *p0, *p1;
int count;
for (count = 0, p0 = s0, p1 = s1; *p0; count++, p0++, p1++) {
char c0 = completion_is_case_sensitive ? *p0 : tolower(*p0);
char c1 = completion_is_case_sensitive ? *p1 : tolower(*p1);
if (c0 != c1 || count == BUFFSIZE)
return FALSE;
}
return TRUE;
}
/* See readline doumentation: this function is called by readline whenever a completion is needed. The first time state == 0,
whwnever the user presses TAB to cycle through the list, my_completion_function() is called again, but then with state != 0
It should return the completion, which then will be freed by readline (so we'll hand back a copy instead of the real thing) ' */
char *
my_completion_function(char *prefix, int state)
{
static struct rbtree *scratch_tree = NULL;
static RBLIST *scratch_list = NULL; /* should remain unchanged between invocations */
int completion_type, count;
const char *word;
const char *completion;
rl_completion_append_character = *extra_char_after_completion;
if (*prefix == '!')
return my_history_completion_function(prefix + 1, state);
if (state == 0) { /* first time we're called for this prefix ' */
if (scratch_list)
rbcloselist(scratch_list);
if (scratch_tree)
my_rbdestroy(scratch_tree);
scratch_tree = rbinit(); /* allocate scratch_tree. We will use this to get a sorted list of completions */
/* now find all possible completions: */
completion_type = get_completion_type();
DPRINTF2(DEBUG_ALL, "completion_type: %d, filter_pid: %d", completion_type, filter_pid);
if (completion_type & COMPLETE_FROM_LIST) {
for (word = rblookup(RB_LUGTEQ, prefix, completion_tree); /* start with first word >= prefix */
word && is_prefix(prefix, word); /* as long as prefix is really prefix of word */
word = rblookup(RB_LUGREAT, word, completion_tree)) { /* find next word in list */
rbsearch(mysavestring(word), scratch_tree); /* insert fresh copy of the word */
/* DPRINTF1(DEBUG_COMPLETION, "Adding %s to completion list ", word); */
}
}
if (completion_type & COMPLETE_FILENAMES) {
change_working_directory();
DPRINTF1(DEBUG_COMPLETION, "Starting milking of rl_filename_completion_function, prefix = <%s> ", prefix);
for (count = 0;
(word = copy_and_free_string_for_malloc_debug(rl_filename_completion_function(prefix, count)));
count++) { /* using rl_filename_completion_function means
that completing filenames will always be case-sensitive */
DPRINTF1(DEBUG_COMPLETION, "Adding <%s> to completion list ", word);
rbsearch(word, scratch_tree);
}
}
scratch_list = rbopenlist(scratch_tree); /* OK, we now have our list with completions. We may have to filter it: */
if (completion_type & FILTER_COMPLETIONS) {
/* build message (filter_food) consisting of: input line, TAB, prefix, TAB, completion_1 SPACE completion_2 .... */
char *word, *filtered, **words, **plist, **fragments;
int length = strlen(rl_line_buffer) + strlen(prefix) + 3;
char *filter_food = mymalloc(length);
assert(strchr(rl_line_buffer,'\n') == NULL);
sprintf(filter_food, "%s\t%s\t", rl_line_buffer, prefix);
while((completion = rbreadlist(scratch_list))) {
filter_food = append_and_free_old(filter_food, completion);
filter_food = append_and_free_old(filter_food, " ");
}
/* feed message to filter */
filtered = pass_through_filter(TAG_COMPLETION, filter_food);
free(filter_food);
rbcloselist(scratch_list); /* throw away old list, and */
DPRINTF1(DEBUG_ALL, "Filtered: %s", mangle_string_for_debug_log(filtered, 40));
/* parse contents */
fragments = split_on_single_char(filtered, '\t');
if (!fragments[0] || ! fragments[1] || !fragments[2] ||
strncmp(fragments[0], rl_line_buffer, length) || strncmp(fragments[1], prefix,length)) {
myerror(FATAL|NOERRNO, "filter has illegally messed with completion message\n"); /* it should ONLY have changed the completion word list */
}
my_rbdestroy(scratch_tree); /* burn the old scratch tree (but leave the completion tree alone) */
scratch_tree = rbinit(); /* now grow a new one */
words = split_with(fragments[2], " ");
for(plist = words;(word = *plist); plist++) {
if (!*word)
continue; /* empty space at beginning or end of the word list results in an empty word. skip it now */
rbsearch(mysavestring(word), scratch_tree); /* add the filtered completions to the new scratch tree */
DPRINTF1(DEBUG_COMPLETION, "Adding %s to completion list ", word);
}
free_splitlist(words);
free_splitlist(fragments);
free(filtered);
scratch_list = rbopenlist(scratch_tree); /* flatten the tree into a new list */
}
DPRINTF1(DEBUG_COMPLETION, "scratch list: %s", rbtree_to_string(scratch_tree, 6));
} /* if state == 0 */
/* we get here each time the user presses TAB to cycle through the list */
assert(scratch_tree != NULL);
assert(scratch_list != NULL);
if ((completion = rbreadlist(scratch_list))) { /* read next possible completion */
struct stat buf;
char *copy_for_readline = malloc_foreign(strlen(completion)+1);
strcpy(copy_for_readline, completion);
/* This doesn ... (comment disappeared) */
rl_filename_completion_desired = rl_filename_quoting_desired = (stat(completion, &buf) ? FALSE : TRUE);
DPRINTF1(DEBUG_COMPLETION, "Returning completion to readline: <%s>", copy_for_readline);
return copy_for_readline; /* we cannot just return it as readline will free it (and make rlwrap explode) */
} else {
return NULL;
}
}
static char *
my_history_completion_function(char *prefix, int state)
{
while (next_history());
if (state || history_search_prefix(prefix, -1) < 0)
return NULL;
return mysavestring(current_history()->line);
}
/* The following sets edit modes for GNU EMACS
Local Variables:
mode:c
End: */
rlwrap-0.42/src/filter.c 0000644 0001751 0000144 00000024146 12406251175 012116 0000000 0000000 /* filter.c : spawning a filter and using it to re-write input, output, history and
* (C) 2000-2007 Hans Lub
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License , or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
* You may contact the author by e-mail: hlub@knoware.nl
*/
/* A filter is an external program run by rlwrap in order to examine
and possibly re-write user input, command output, prompts, history
entries and completion requests. There can be at most one filter,
but this can be a pipeline ('pipeline filter1 : filter2')
The filter communicates with rlwrap by reading and writing messages
on two pipes.
A message is a byte sequence as follows:
Tag 1 byte (can be TAG_INPUT, TAG_OUTPUT, TAG_HISTORY,
TAG_COMPLETION, TAG_PROMPT, TAG_OUTPUT_OUT_OF_BAND, TAG_ERROR)
Length 4 bytes (length of text + closing newline)
Text bytes
'\n' (so that the filter can be line buffered without
hanging rlwrap)
Communication is synchronous: after sending a message (and only
then) rlwrap waits for an answer, which must have the same tag, but
may be preceded by one or more "out of band" messages. If the
filter is slow or hangs, rlwrap does the same. A filter can (and
should) signal an error by using TAG_ERROR (which will terminate
rlwrap). Filter output on stderr is displayed normally, but will
mess up the display.
Length may be 0. (Example: If we have a prompt-less command, rlwrap
will send an empty TAG_PROMPT message, and the filter can send a
fancy prompt back. The converse is also possible, of course)
A few environment variables are used to inform the filter about
file descriptors etc.
*/
#include "rlwrap.h"
static int filter_input_fd = -1;
static int filter_output_fd = -1;
pid_t filter_pid = 0;
static int expected_tag = -1;
static char*read_from_filter(int tag);
static void write_message(int fd, int tag, const char *string, const char *description);
static void write_to_filter(int tag, const char *string);
static char* tag2description(int tag);
static char *read_tagless(void);
void handle_out_of_band(int tag, char *message);
static void mypipe(int filedes[2]) {
int retval;
retval = pipe(filedes);
if (retval < 0)
myerror(FATAL|USE_ERRNO, "Couldn't create pipe");
}
void spawn_filter(const char *filter_command) {
int input_pipe_fds[2];
int output_pipe_fds[2];
mypipe(input_pipe_fds);
filter_input_fd = input_pipe_fds[1]; /* rlwrap writes filter input to this */
mypipe(output_pipe_fds);
filter_output_fd = output_pipe_fds[0]; /* rlwrap reads filter output from here */
DPRINTF1(DEBUG_FILTERING, "preparing to spawn filter <%s>", filter_command);
assert(!command_pid || signal_handlers_were_installed); /* if there is a command, then signal handlers are installed */
if ((filter_pid = fork()) < 0)
myerror(FATAL|USE_ERRNO, "Cannot spawn filter '%s'", filter_command);
else if (filter_pid == 0) { /* child */
int signals_to_allow[] = {SIGPIPE, SIGCHLD, SIGALRM, SIGUSR1, SIGUSR2};
char **argv;
unblock_signals(signals_to_allow); /* when we run a pager from a filter we want to catch these */
DEBUG_RANDOM_SLEEP;
i_am_child = TRUE;
/* set environment for filter (it needs to know at least the file descriptors for its input and output) */
if (!getenv("RLWRAP_FILTERDIR"))
mysetenv("RLWRAP_FILTERDIR", add2strings(DATADIR,"/rlwrap/filters"));
mysetenv("PATH", add3strings(getenv("RLWRAP_FILTERDIR"),":",getenv("PATH")));
mysetenv("RLWRAP_VERSION", VERSION);
mysetenv("RLWRAP_COMMAND_PID", as_string(command_pid));
mysetenv("RLWRAP_COMMAND_LINE", command_line);
if (impatient_prompt)
mysetenv("RLWRAP_IMPATIENT", "1");
mysetenv("RLWRAP_INPUT_PIPE_FD", as_string(input_pipe_fds[0]));
mysetenv("RLWRAP_OUTPUT_PIPE_FD", as_string(output_pipe_fds[1]));
mysetenv("RLWRAP_MASTER_PTY_FD", as_string(master_pty_fd));
close(filter_input_fd);
close(filter_output_fd);
if (scan_metacharacters(filter_command, "'|\"><")) { /* if filter_command contains shell metacharacters, let the shell unglue them */
char *exec_command = add3strings("exec", " ", filter_command);
argv = list4("sh", "-c", exec_command, NULL);
} else { /* if not, split and feed to execvp directly (cheaper, better error message) */
argv = split_with(filter_command, " ");
}
assert(argv[0]);
if(execvp(argv[0], argv) < 0) {
char *sorry = add3strings("Cannot exec filter '", argv[0], add2strings("': ", strerror(errno)));
write_message(output_pipe_fds[1], TAG_ERROR, sorry, "to stdout"); /* this will kill rlwrap */
mymicrosleep(100 * 1000); /* 100 sec for rlwrap to go away should be enough */
exit (-1);
}
assert(!"not reached");
} else {
DEBUG_RANDOM_SLEEP;
signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE - we have othere ways to deal with filter death */
DPRINTF1(DEBUG_FILTERING, "spawned filter with pid %d", filter_pid);
close (input_pipe_fds[0]);
close (output_pipe_fds[1]);
}
}
void kill_filter() {
int status;
assert (filter_pid && filter_input_fd);
close(filter_input_fd); /* filter will see EOF and should exit */
myalarm(40); /* give filter 0.04seconds to go away */
if(!filter_is_dead && /* filter's SIGCHLD hasn't been caught */
waitpid(filter_pid, &status, WNOHANG) < 0 && /* interrupted .. */
WTERMSIG(status) == SIGALRM) { /* .. by alarm (and not e.g. by SIGCHLD) */
myerror(WARNING|NOERRNO, "filter didn't die - killing it now");
}
if (filter_pid)
kill(filter_pid, SIGKILL); /* do this as a last resort */
myalarm(0);
}
char *filters_last_words() {
assert (filter_is_dead);
return read_from_filter(TAG_OUTPUT);
}
char *pass_through_filter(int tag, const char *buffer) {
char *filtered;
DPRINTF3(DEBUG_FILTERING, "to filter (%s, %d bytes) %s", tag2description(tag), (int) strlen(buffer), mangle_string_for_debug_log(buffer, MANGLE_LENGTH));
if (filter_pid ==0)
return mysavestring(buffer);
write_to_filter((expected_tag = tag), buffer);
filtered = read_from_filter(tag);
DPRINTF2(DEBUG_FILTERING, "from filter (%d bytes) %s", (int) strlen(filtered), mangle_string_for_debug_log(filtered, MANGLE_LENGTH));
return filtered;
}
static char *read_from_filter(int tag) {
uint8_t tag8;
DEBUG_RANDOM_SLEEP;
assert (!out_of_band(tag));
while (read_patiently2(filter_output_fd, &tag8, sizeof(uint8_t), 1000, "from filter"), out_of_band(tag8))
handle_out_of_band(tag8, read_tagless());
if (tag8 != tag)
myerror(FATAL|USE_ERRNO, "Tag mismatch, expected %s from filter, but got %s", tag2description(tag), tag2description(tag8));
return read_tagless();
}
static char *read_tagless() {
uint32_t length32;
char *buffer;
read_patiently2(filter_output_fd, &length32, sizeof(uint32_t), 1000, "from filter");
buffer = mymalloc(length32);
read_patiently2(filter_output_fd, buffer, length32, 1000,"from filter");
if (buffer[length32 -1 ] != '\n')
myerror(FATAL|USE_ERRNO, "filter output without closing newline");
buffer[length32 -1 ] = '\0';
return buffer;
}
void handle_out_of_band(int tag, char *message) {
int split_em_up = FALSE;
switch (tag) {
case TAG_ERROR:
if (expected_tag == TAG_COMPLETION) /* start new line when completing (looks better) */
fprintf(stderr, "\n"); /* @@@ error reporting (still) uses bufered I/O */
myerror(FATAL|NOERRNO, message);
case TAG_OUTPUT_OUT_OF_BAND:
my_putstr(message);
break;
case TAG_ADD_TO_COMPLETION_LIST:
case TAG_REMOVE_FROM_COMPLETION_LIST:
split_em_up = TRUE;
break;
case TAG_IGNORE:
break;
default:
myerror(FATAL|USE_ERRNO, "out-of-band message with unknown tag %d: <%20s>", tag, message);
}
if (split_em_up) {
char **words = split_with(message, " \n\t");
char **plist, *word;
for(plist = words;(word = *plist); plist++)
if (tag == TAG_ADD_TO_COMPLETION_LIST)
add_word_to_completions(word);
else
remove_word_from_completions(word);
free_splitlist(words);
}
free(message);
}
static void write_to_filter(int tag, const char *string) {
write_message(filter_input_fd, tag, string, "to filter");
}
static void write_message(int fd, int tag, const char *string, const char *description) {
uint8_t tag8 = tag;
uint32_t length32 = strlen(string) + 1;
write_patiently2(fd, &tag8, sizeof (uint8_t) , 1000, description);
write_patiently2(fd, &length32, sizeof(uint32_t), 1000, description);
write_patiently2(fd, string, length32 - 1 , 1000, description);
write_patiently2(fd, "\n", 1 , 1000, description);
}
static char* tag2description(int tag) {
switch (tag) {
case TAG_INPUT: return "INPUT";
case TAG_OUTPUT: return "OUTPUT";
case TAG_HISTORY: return "HISTORY";
case TAG_COMPLETION: return "COMPLETION";
case TAG_PROMPT: return "PROMPT";
case TAG_IGNORE: return "TAG_IGNORE";
case TAG_ADD_TO_COMPLETION_LIST: return "ADD_TO_COMPLETION_LIST";
case TAG_REMOVE_FROM_COMPLETION_LIST:return "REMOVE_FROM_COMPLETION_LIST";
case TAG_OUTPUT_OUT_OF_BAND: return "OUTPUT_OUT_OF_BAND";
case TAG_ERROR: return "ERROR";
default: return as_string(tag);
}
}
rlwrap-0.42/src/ptytty.c 0000644 0001751 0000144 00000022577 12404151311 012201 0000000 0000000 /*
* Shamelessly ripped out of rxvt-2.7.10 (Copyright (c) 1999-2001
* Geoff Wing ) by Hans Lub
*
* All portions of code are copyright by their respective author/s.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*---------------------------------------------------------------------*/
#include "rlwrap.h"
#include
#ifdef HAVE_STDLIB_H
# include
#endif
#ifdef HAVE_SYS_TYPES_H
# include
#endif
#ifdef HAVE_UNISTD_H
# include
#endif
#if defined(HAVE_STRING_H)
# include
#endif
#ifdef HAVE_FCNTL_H
# include
#endif
#ifdef HAVE_SYS_IOCTL_H
# include
#endif
#if defined(PTYS_ARE_PTMX) && !defined(__CYGWIN32__)
# include /* for I_PUSH */
#endif
/* ------------------------------------------------------------------------- *
* GET PSEUDO TELETYPE - MASTER AND SLAVE *
* ------------------------------------------------------------------------- */
/*
* Returns pty file descriptor, or -1 on failure
* If successful, ttydev is set to the name of the slave device.
* fd_tty _may_ also be set to an open fd to the slave device
*/
#define O_RWNN O_RDWR | O_NDELAY | O_NOCTTY
int
ptytty_get_pty(int *fd_tty, const char **ttydev)
{
int pfd;
#ifdef PTYS_ARE_OPENPTY
char tty_name[sizeof "/dev/pts/????\0"];
if (openpty(&pfd, fd_tty, tty_name, NULL, NULL) != -1) {
*ttydev = strdup(tty_name);
return pfd;
}
#endif
#ifdef PTYS_ARE__GETPTY
*ttydev = _getpty(&pfd, O_RWNN, 0622, 0);
if (*ttydev != NULL)
return pfd;
#endif
#ifdef PTYS_ARE_GETPTY
char *ptydev;
while ((ptydev = getpty()) != NULL)
if ((pfd = open(ptydev, O_RWNN, 0)) >= 0) {
*ttydev = ptydev;
return pfd;
}
#endif
#if defined(HAVE_GRANTPT) && defined(HAVE_UNLOCKPT)
# if defined(PTYS_ARE_GETPT) || defined(PTYS_ARE_PTMX)
{
extern char *ptsname();
# ifdef PTYS_ARE_GETPT
pfd = getpt();
# else
pfd = open("/dev/ptmx", O_RWNN, 0);
# endif
if (pfd >= 0) {
if (grantpt(pfd) == 0 /* change slave permissions */
&& unlockpt(pfd) == 0) { /* slave now unlocked */
*ttydev = ptsname(pfd); /* get slave's name */
return pfd;
}
close(pfd);
}
}
# endif
#endif
#ifdef PTYS_ARE_PTC
if ((pfd = open("/dev/ptc", O_RWNN, 0)) >= 0) {
*ttydev = ttyname(pfd);
return pfd;
}
#endif
#ifdef PTYS_ARE_CLONE /* HP-UX */
if ((pfd = open("/dev/ptym/clone", O_RWNN, 0)) >= 0) {
*ttydev = ptsname(pfd);
return pfd;
}
#endif
#ifdef PTYS_ARE_NUMERIC
{
int idx;
char *c1, *c2;
char pty_name[] = "/dev/ptyp???";
char tty_name[] = "/dev/ttyp???";
c1 = &(pty_name[sizeof(pty_name) - 4]);
c2 = &(tty_name[sizeof(tty_name) - 4]);
for (idx = 0; idx < 256; idx++) {
snprintf1(c1, strlen(c1), "%d", idx);
snprintf1(c2, strlen(c2), "%d", idx);
if (access(tty_name, F_OK) < 0) {
idx = 256;
break;
}
if ((pfd = open(pty_name, O_RWNN, 0)) >= 0) {
if (access(tty_name, R_OK | W_OK) == 0) {
*ttydev = strdup(tty_name);
return pfd;
}
close(pfd);
}
}
}
#endif
#ifdef PTYS_ARE_SEARCHED
{
const char *c1, *c2;
char pty_name[] = "/dev/pty??";
char tty_name[] = "/dev/tty??";
# ifndef PTYCHAR1
# define PTYCHAR1 "pqrstuvwxyz"
# endif
# ifndef PTYCHAR2
# define PTYCHAR2 "0123456789abcdef"
# endif
for (c1 = PTYCHAR1; *c1; c1++) {
pty_name[(sizeof(pty_name) - 3)] =
tty_name[(sizeof(pty_name) - 3)] = *c1;
for (c2 = PTYCHAR2; *c2; c2++) {
pty_name[(sizeof(pty_name) - 2)] =
tty_name[(sizeof(pty_name) - 2)] = *c2;
if ((pfd = open(pty_name, O_RWNN, 0)) >= 0) {
if (access(tty_name, R_OK | W_OK) == 0) {
*ttydev = strdup(tty_name);
return pfd;
}
close(pfd);
}
}
}
}
#endif
return -1;
}
/*----------------------------------------------------------------------*/
/*
* Returns tty file descriptor, or -1 on failure
*/
/* EXTPROTO */
int
ptytty_get_tty(const char *ttydev)
{
return open(ttydev, O_RDWR | O_NOCTTY, 0);
}
/*----------------------------------------------------------------------*/
/*
* Make our tty a controlling tty so that /dev/tty points to us
*/
/* EXTPROTO */
int
ptytty_control_tty(int fd_tty, const char *ttydev)
{
DPRINTF3(DEBUG_TERMIO, "pid: %d, tty fd: %d, dev: %s", getpid(), fd_tty,
ttydev);
DPRINTF2(DEBUG_TERMIO, "tcgetpgrp(): %d getpgrp(): %d", tcgetpgrp(fd_tty),
getpgrp());
/* ------------------- Become leader of our own session: --------------------- */
# ifdef HAVE_SETSID
{
pid_t ret = setsid();
DPRINTF2(DEBUG_TERMIO, "setsid() returned %d %s", (int)ret,
ERRMSG(ret < 0));
}
# endif
/* ------------------- Get controlling tty --------------------- */
#ifndef __QNX__ /* in QNX, the only way to get a controlling tty is at process creation time, using
qnx_spawn() instead of fork(). I'm too lazy to re-write my_pty_fork(), so I let rlwrap
soldier on without a controlling tty */
{
int fd;
# ifdef TIOCNOTTY
fd = open("/dev/tty", O_RDWR | O_NOCTTY);
DPRINTF1(DEBUG_TERMIO, "Voiding tty associations: previous=%s",
fd < 0 ? "no" : "yes");
if (fd >= 0) {
int ret = ioctl(fd, TIOCNOTTY, NULL); /* void tty associations */
DPRINTF2(DEBUG_TERMIO, "ioctl(..., TIOCNOTTY): %d %s", ret,
ERRMSG(ret < 0));
close(fd);
}
# endif
/* ---------------------------------------- */
fd = open("/dev/tty", O_RDWR | O_NOCTTY);
DPRINTF1(DEBUG_TERMIO,
"ptytty_control_tty(): /dev/tty has controlling tty? %s",
fd < 0 ? "no (good)" : "yes (bad)");
if (fd >= 0)
close(fd); /* ouch: still have controlling tty */
/* ---------------------------------------- */
#if defined(PTYS_ARE_PTMX) && defined(I_PUSH)
/*
* Push STREAMS modules:
* ptem: pseudo-terminal hardware emulation module.
* ldterm: standard terminal line discipline.
* ttcompat: V7, 4BSD and XENIX STREAMS compatibility module.
*
* After we push the STREAMS modules, the first open() on the slave side
* (i.e. the next section between the dashes giving us "tty opened OK")
* should make the "ptem" (or "ldterm" depending upon either which OS
* version or which set of manual pages you have) module give us a
* controlling terminal. We must already have close()d the master side
* fd in this child process before we push STREAMS modules on because the
* documentation is really unclear about whether it is any close() on
* the master side or the last close() - i.e. a proper STREAMS dismantling
* close() - on the master side which causes a hang up to be sent
* through - Geoff Wing
*/
# ifdef HAVE_ISASTREAM
if (isastream(fd_tty) == 1)
# endif
{
DPRINTF0(DEBUG_TERMIO, "Pushing STREAMS modules");
ioctl(fd_tty, I_PUSH, "ptem");
ioctl(fd_tty, I_PUSH, "ldterm");
ioctl(fd_tty, I_PUSH, "ttcompat");
}
#endif
/* ---------------------------------------- */
# if defined(TIOCSCTTY)
fd = ioctl(fd_tty, TIOCSCTTY, NULL);
DPRINTF2(DEBUG_TERMIO, "ioctl(..,TIOCSCTTY): %d %s", fd, ERRMSG(fd < 0));
# elif defined(TIOCSETCTTY)
fd = ioctl(fd_tty, TIOCSETCTTY, NULL);
DPRINTF2(DEBUG_TERMIO, "ioctl(..,TIOCSETCTTY): %d %s", fd, ERRMSG(fd < 0));
# else
fd = open(ttydev, O_RDWR);
DPRINTF2(DEBUG_TERMIO, "tty open%s %s", (fd < 0 ? " failure" : "ed OK"),
ERRMSG(fd < 0));
if (fd >= 0)
close(fd);
# endif
/* ---------------------------------------- */
fd = open("/dev/tty", O_WRONLY);
DPRINTF2(DEBUG_TERMIO, "do we have controlling tty now: %s %s",
(fd < 0 ? "no (fatal)" : "yes (good)"), ERRMSG(fd < 0));
if (fd < 0)
myerror(WARNING|USE_ERRNO, "Could not get controlling terminal for %s", program_name); /* mywarn called from child */
else
close(fd);
/* ---------------------------------------- */
DPRINTF2(DEBUG_TERMIO, "tcgetpgrp(): %d getpgrp(): %d", tcgetpgrp(fd_tty),
getpgrp());
/* ---------------------------------------- */
}
#endif /* ! __QNX__ */
return 0;
}
int
ptytty_openpty(int *amaster, int *aslave, const char **name)
{
const char *scrap;
*aslave = -1;
*amaster = ptytty_get_pty(aslave, &scrap);
if (*amaster < 0)
myerror(FATAL|USE_ERRNO, "Could not open master pty");
if (*aslave < 0)
*aslave = ptytty_get_tty(scrap);
if (*aslave < 0)
myerror(FATAL|USE_ERRNO, "Could not open slave pty %s", scrap);
else
if (name != NULL)
*name = scrap;
return 0;
}
rlwrap-0.42/src/malloc_debug.h 0000644 0001751 0000144 00000001277 12404151311 013240 0000000 0000000
#ifdef DEBUG
void *debug_malloc(size_t size, char *file, int line);
void debug_free(void *ptr, char *file, int line);
void debug_postmortem(void);
void free_foreign(void *ptr);
void *malloc_foreign(size_t size);
void *copy_and_free_for_malloc_debug(void *ptr, size_t size);
char *copy_and_free_string_for_malloc_debug(char* str);
#define free(ptr) debug_free(ptr,__FILE__,__LINE__)
#define mymalloc(size) debug_malloc(size, __FILE__, __LINE__)
#else
#define free_foreign free
#define malloc_foreign malloc
#define copy_and_free_for_malloc_debug(ptr,size) (ptr)
#define copy_and_free_string_for_malloc_debug(str) (str)
#define debug_postmortem() do_nothing(0)
#endif
rlwrap-0.42/src/Makefile.am 0000644 0001751 0000144 00000001221 12431405504 012501 0000000 0000000 bin_PROGRAMS = rlwrap
#EXTRA_PROGRAMS=rltest1 rltest2 rltest3 kaboom
rlwrap_SOURCES = main.c signals.c readline.c pty.c completion.c term.c ptytty.c utils.c string_utils.c malloc_debug.c filter.c
#rltest1_SOURCES=rltest1.c
#rltest2_SOURCES=rltest2.c
#rltest3_SOURCES=rltest3.c
#kaboom_SOURCES=kaboom.c
AM_CFLAGS=-DDATADIR=\"@datadir@\"
# use old-fashioned suffix rule for non-GNU make
.rb.c :
rbgen $< $@ || echo "You don't seem to have rbgen (http://libredblack.sourceforge.net/). If you didn't change any .rb files, this is not a problem"
#clean-local:
# rm -f *~ kaboom rltest1 rltest2 rltest3
#all-local: kaboom rltest1 rltest2 rltest3
rlwrap-0.42/src/readline.c 0000644 0001751 0000144 00000077041 12404151311 012403 0000000 0000000 /* readline.c: interacting with the GNU readline library
(C) 2000-2007 Hans Lub
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License , or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
You may contact the author by:
e-mail: hlub@knoware.nl
*/
#include "rlwrap.h"
/* global vars */
int remember_for_completion = FALSE; /* whether we should put al words from in/output on the list */
char *multiline_separator = NULL; /* character sequence to use in lieu of newline when storing multi-line input in a single history line */
char *pre_given = NULL; /* pre-given user input when rlwrap starts up */
struct rl_state saved_rl_state = { "", "", 0, 0 }; /* saved state of readline */
static char return_key; /* Key pressed to enter line */
static int forget_line;
static char *colour_start, *colour_end; /* colour codes */
int multiline_prompts = TRUE;
/* forward declarations */
static void line_handler(char *);
static void my_add_history(char *);
static int my_accept_line(int, int);
static int my_accept_line_and_forget(int, int);
static int dump_all_keybindings(int,int);
static int munge_line_in_editor(int, int);
static int please_update_alaf(int,int);
static int please_update_ce(int,int);
static Keymap getmap(const char *name);
static void bindkey(int key, rl_command_func_t *function, const char *maplist);
void
init_readline(char *prompt)
{
DPRINTF1(DEBUG_READLINE, "Initialising readline version %x", rl_readline_version);
rl_add_defun("rlwrap-accept-line", my_accept_line,-1);
rl_add_defun("rlwrap-accept-line-and-forget", my_accept_line_and_forget,-1);
rl_add_defun("rlwrap-dump-all-keybindings", dump_all_keybindings,-1);
rl_add_defun("rlwrap-call-editor", munge_line_in_editor, -1);
/* rlwrap bindable function names with underscores are deprecated: */
rl_add_defun("rlwrap_accept_line_and_forget", please_update_alaf,-1);
rl_add_defun("rlwrap_call_editor", please_update_ce,-1);
rl_variable_bind("blink-matching-paren","on"); /* Shouldn't this be on by default? */
bindkey('\n', my_accept_line, "emacs-standard; vi-insert; vi-command");
bindkey('\r', my_accept_line, "emacs-standard; vi-insert; vi-command");
bindkey(15, my_accept_line_and_forget, "emacs-standard; vi-insert; vi-command"); /* ascii #15 (Control-O) is unused in readline's emacs and vi keymaps */
if (multiline_separator)
bindkey(30, munge_line_in_editor, "emacs-standard;vi-insert;vi-command"); /* CTRL-^: unused in vi-insert-mode, hardly used in emacs (doubles arrow-up) */
if (debug)
bindkey(7, dump_all_keybindings,"emacs-standard; vi-insert; vi-move; vi-command" /* "emacs-ctlx; emacs-meta" */); /* CTRL-G */
/* rl_variable_bind("gnah","gnerp"); It is not possible to create new readline variables (only functions) */
rl_catch_signals = 0;
rl_initialize(); /* This has to happen *before* we set rl_redisplay_function, otherwise
readline will not bother to call tgetent(), will be agnostic about terminal
capabilities and hence not be able to honour e.g. a set horizontal-scroll-mode off
in .inputrc */
using_history();
rl_redisplay_function = my_redisplay;
rl_completion_entry_function =
(rl_compentry_func_t *) & my_completion_function;
rl_catch_signals = FALSE;
rl_catch_sigwinch = FALSE;
saved_rl_state.input_buffer = mysavestring("");
saved_rl_state.raw_prompt = mysavestring("");
saved_rl_state.cooked_prompt = NULL;
}
/* save readline internal state in rl_state, redisplay the prompt
(so that client output gets printed at the right place) */
void
save_rl_state()
{
free(saved_rl_state.input_buffer); /* free(saved_rl_state.raw_prompt) */;
saved_rl_state.input_buffer = mysavestring(rl_line_buffer);
/* saved_rl_state.raw_prompt = mysavestring(rl_prompt); */
saved_rl_state.point = rl_point; /* and point */
rl_line_buffer[0] = '\0';
if (saved_rl_state.already_saved)
return;
saved_rl_state.already_saved = 1;
rl_delete_text(0, rl_end); /* clear line (after prompt) */
rl_point = 0;
my_redisplay(); /* and redisplay (this time without user input, cf the comments for the line_handler() function below) */
rl_callback_handler_remove(); /* restore original terminal settings */
rl_deprep_terminal();
}
/* Restore readline internal state from rl_state. */
void
restore_rl_state()
{
char *newprompt;
move_cursor_to_start_of_prompt(impatient_prompt ? ERASE : DONT_ERASE);
cook_prompt_if_necessary();
newprompt = mark_invisible(saved_rl_state.cooked_prompt); /* bracket (colour) control sequences with \001 and \002 */
rl_expand_prompt(newprompt);
mirror_slaves_echo_mode(); /* don't show passwords etc */
DPRINTF1(DEBUG_READLINE,"newprompt now %s", mangle_string_for_debug_log(newprompt,MANGLE_LENGTH));
rl_callback_handler_install(newprompt, &line_handler);
DPRINTF0(DEBUG_AD_HOC, "freeing newprompt");
free(newprompt); /* readline docs don't say it, but we can free newprompt now (readline apparently
uses its own copy) */
rl_insert_text(saved_rl_state.input_buffer);
rl_point = saved_rl_state.point;
saved_rl_state.already_saved = 0;
DPRINTF0(DEBUG_AD_HOC, "Starting redisplay");
rl_redisplay();
rl_prep_terminal(1);
prompt_is_still_uncooked = FALSE; /* has been done right now */
}
static void
line_handler(char *line)
{
char *rewritten_line, *filtered_line;
if (line == NULL) { /* EOF on input, forward it */
DPRINTF1(DEBUG_READLINE, "EOF detected, writing character %d", term_eof);
/* colour_the_prompt = FALSE; don't mess with the cruft that may come out of dying command @@@ but command may not die!*/
write_EOF_to_master_pty();
} else {
if (*line && /* forget empty lines */
redisplay && /* forget passwords */
!forget_line && /* forget lines entered by CTRL-O */
!match_regexp(line, forget_regexp, TRUE)) { /* forget lines (case-inseitively) matching -g option regexp */
my_add_history(line);
}
forget_line = FALSE; /* until CTRL-O is used again */
/* Time for a design decision: when we send the accepted line to the client command, it will most probably be echoed
back. We have two choices: we leave the entered line on screen and suppress just enough of the clients output (I
believe this is what rlfe does), or we remove the entered input (but not the prompt!) and let it be replaced by
the echo.
This is what we do; as a bonus, if the program doesn't echo, e.g. at a password prompt, the **** which has been
put there by our homegrown_redisplay function will be removed (@@@is this what we want?)
I think this method is more natural for multi-line input as well, (we will actually see our multi-line input as
multiple lines) but not everyone will agree with that.
O.K, we know for sure that cursor is at start of line. When clients output arrives, it will be printed at
just the right place - but first we 'll erase the user input (as it may be about to be changed by the filter) */
rl_delete_text(0, rl_end); /* clear line (after prompt) */
rl_point = 0;
my_redisplay(); /* and redisplay (this time without user input, cf the comments for the line_handler() function below) */
rewritten_line =
(multiline_separator ?
search_and_replace(multiline_separator, "\n", line, 0, NULL,
NULL) : mysavestring(line));
if (redisplay)
filtered_line = pass_through_filter(TAG_INPUT, rewritten_line);
else { /* password, none of filters business */
pass_through_filter(TAG_INPUT, "***"); /* filter some input anyway, to keep filter in sync (result is discarded). */
filtered_line = mysavestring(rewritten_line);
}
free(rewritten_line);
/* do we have to adapt clients winzsize now? */
if (deferred_adapt_commands_window_size) {
adapt_tty_winsize(STDIN_FILENO, master_pty_fd);
kill(-command_pid, SIGWINCH);
deferred_adapt_commands_window_size = FALSE;
}
/*OK, now feed line to underlying command and wait for the echo to come back */
put_in_output_queue(filtered_line);
DPRINTF2(DEBUG_READLINE, "putting %d bytes %s in output queue", (int) strlen(rewritten_line),
mangle_string_for_debug_log(rewritten_line, 40));
write_EOL_to_master_pty(return_key ? &return_key : "\n");
accepted_lines++;
free_foreign(line); /* free_foreign because line was malloc'ed by readline, not by rlwrap */
free(filtered_line); /* we're done with them */
return_key = 0;
within_line_edit = FALSE;
rl_callback_handler_remove();
set_echo(FALSE);
free(saved_rl_state.input_buffer);
free(saved_rl_state.raw_prompt);
free(saved_rl_state.cooked_prompt);
saved_rl_state.input_buffer = mysavestring("");
saved_rl_state.raw_prompt = mysavestring("");
saved_rl_state.cooked_prompt = NULL;
saved_rl_state.point = 0;
saved_rl_state.already_saved = TRUE;
redisplay = TRUE;
}
}
/* this function (drop-in replacement for readline's own accept-line())
will be bound to RETURN key: */
static int
my_accept_line(int count, int key)
{
rl_point = 0; /* leave cursor on predictable place */
my_redisplay();
rl_done = 1;
return_key = (char)key;
return 0;
}
/* this function will be bound to rl_accept_key_and_forget key (normally CTRL-O) */
static int
my_accept_line_and_forget(int count, int key)
{
forget_line = 1;
return my_accept_line(count, '\n');
}
static int
dump_all_keybindings(int count, int key)
{
rl_dump_functions(count,key);
rl_variable_dumper(FALSE);
rl_macro_dumper(FALSE);
return 0;
}
/* format line and add it to history list, avoiding duplicates if necessary */
static void
my_add_history(char *line)
{
int lookback, count, here;
char *new_entry, *filtered_line;
filtered_line = pass_through_filter(TAG_HISTORY, line);
switch (history_duplicate_avoidance_policy) {
case KEEP_ALL_DOUBLES:
lookback = 0; break;
case ELIMINATE_SUCCESIVE_DOUBLES:
lookback = 1; break;
case ELIMINATE_ALL_DOUBLES:
lookback = history_length; break;
}
new_entry = filtered_line;
lookback = min(history_length, lookback);
for (count = 0, here = history_length + history_base - 1;
count < lookback ;
count++, here--) {
/* DPRINTF3(DEBUG_READLINE, "strcmping <%s> and <%s> (count = %d)", line, history_get(here)->line ,count); */
if (strncmp(new_entry, history_get(here) -> line, 10000) == 0) {
HIST_ENTRY *entry = remove_history (here - history_base); /* according to the history library doc this should be
remove_history(here) @@@?*/
DPRINTF2(DEBUG_READLINE, "removing duplicate entry #%d (%s)", here, entry->line);
free_foreign(entry->line);
free_foreign(entry);
}
}
add_history(new_entry);
free(new_entry);
}
/* Homegrown redisplay function - erases current line and prints the
new one. Used for passwords (where we want to show **** instead of
user input) and whenever HOMEGROWN_REDISPLAY is defined (for
systems where rl_redisplay() misbehaves, like sometimes on
Solaris). Otherwise we use the much faster and smoother
rl_redisplay() This function cannot display multiple lines: it will
only scroll horizontally (even if horizontal-scroll-mode is off in
.inputrc)
*/
static void
my_homegrown_redisplay(int hide_passwords)
{
static int line_start = 0; /* at which position of prompt_plus_line does the printed line start? */
static int line_extends_right = 0;
static int line_extends_left = 0;
static char *previous_line = NULL;
int width = winsize.ws_col;
int skip = max(1, min(width / 5, 10)); /* jumpscroll this many positions when cursor reaches edge of terminal */
char *prompt_without_ignore_markers;
int colourless_promptlen = colourless_strlen(rl_prompt, &prompt_without_ignore_markers,0);
int promptlen = strlen(prompt_without_ignore_markers);
int invisible_chars_in_prompt = promptlen - colourless_promptlen;
char *prompt_plus_line = add2strings(prompt_without_ignore_markers, rl_line_buffer);
char *new_line;
int total_length = strlen(prompt_plus_line);
int curpos = promptlen + rl_point; /* cursor position within prompt_plus_line */
int i, printed_length,
new_curpos, /* cursor position on screen */
keep_old_line, vlinestart, printwidth, last_column;
DPRINTF3(DEBUG_AD_HOC,"rl_prompt: <%s>, prompt_without_ignore_markers: <%s>, prompt_plus_line: <%s>", rl_prompt, prompt_without_ignore_markers, prompt_plus_line);
/* In order to handle prompt with colour we either print the whole prompt, or start past it:
starting in the middle is too difficult (i.e. I am too lazy) to get it right.
We use a "virtual line start" vlinestart, which is the number of invisible chars in prompt in the former case, or
linestart in the latter (which then must be >= strlen(prompt))
At all times (before redisplay and after) the following is true:
- the cursor is at column (curpos - vlinestart) (may be < 0 or > width)
- the character under the cursor is prompt_plus_line[curpos]
- the character at column 0 is prompt_plus_line[linestart]
- the last column is at - vlinestart
the goal of this function is to display (part of) prompt_plus_line such
that the cursor is visible again */
if (hide_passwords)
for (i = promptlen; i < total_length; i++)
prompt_plus_line[i] = '*'; /* hide a pasword by making user input unreadable */
if (rl_point == 0) /* (re)set at program start and after accept_line (where rl_point is zeroed) */
line_start = 0;
assert(line_start == 0 || line_start >= promptlen); /* the line *never* starts in the middle of the prompt (too complicated to handle)*/
vlinestart = (line_start > promptlen ? line_start : invisible_chars_in_prompt);
if (curpos - vlinestart > width - line_extends_right) /* cursor falls off right edge ? */
vlinestart = (curpos - width + line_extends_right) + skip; /* jumpscroll left */
else if (curpos < vlinestart + line_extends_left) { /* cursor falls off left edge ? */
if (curpos == total_length) /* .. but still at end of line? */
vlinestart = max(0, total_length - width); /* .. try to display entire line */
else /* in not at end of line .. */
vlinestart = curpos - line_extends_left - skip; /* ... jumpscroll right .. */
}
if (vlinestart <= invisible_chars_in_prompt) {
line_start = 0; /* ... but not past start of line! */
vlinestart = invisible_chars_in_prompt;
} else if (vlinestart > invisible_chars_in_prompt && vlinestart <= promptlen) {
line_start = vlinestart = promptlen;
} else {
line_start = vlinestart;
}
printwidth = (line_start > 0 ? width : width + invisible_chars_in_prompt);
printed_length = min(printwidth, total_length - line_start); /* never print more than width */
last_column = printed_length - vlinestart;
/* some invariants : 0 <= line_start <= curpos <= line_start + printed_length <= total_length */
/* these are interesting: ^ ^ */
assert(0 <= line_start);
assert(line_start <= curpos);
assert(curpos <= line_start + printed_length); /* <=, rather than <, as cursor may be past eol */
assert(line_start + printed_length <= total_length);
new_line = prompt_plus_line + line_start;
new_line[printed_length] = '\0';
new_curpos = curpos - vlinestart;
/* indicate whether line extends past right or left edge (i.e. whether the "interesting
inequalities marked ^ above are really unequal) */
line_extends_left = (line_start > 0 ? 1 : 0);
line_extends_right = (total_length - vlinestart > width ? 1 : 0);
if (line_extends_left)
new_line[0] = '<';
if (line_extends_right)
new_line[printwidth - 1] = '>';
keep_old_line = FALSE;
if (term_cursor_hpos) {
if (previous_line && strcmp(new_line, previous_line) == 0) {
keep_old_line = TRUE;
} else {
if (previous_line)
free(previous_line);
previous_line = mysavestring(new_line);
}
}
/* DPRINTF2(DEBUG_AD_HOC, "keep_old_line=%d, new_line=<%s>", keep_old_line, new_line); */
/* keep_old_line = TRUE; */
if (!keep_old_line) {
clear_line();
cr();
write_patiently(STDOUT_FILENO, new_line, printed_length, "to stdout");
}
assert(term_cursor_hpos || !keep_old_line); /* if we cannot position cursor, we must have reprinted ... */
if (term_cursor_hpos)
cursor_hpos(new_curpos);
else /* ... so we know we're 1 past last position on line */
backspace(last_column - new_curpos);
free(prompt_plus_line);
free(prompt_without_ignore_markers);
}
void
my_redisplay()
{
int debug_force_homegrown_redisplay = 0;
#ifdef DEBUG
debug_force_homegrown_redisplay = debug & FORCE_HOMEGROWN_REDISPLAY;
#endif
#ifndef HOMEGROWN_REDISPLAY
if (redisplay && !debug_force_homegrown_redisplay) {
rl_redisplay();
} else
#endif
my_homegrown_redisplay(!redisplay);
}
static int
munge_line_in_editor(int count, int key)
{
int line_number = 0, column_number = 0, ret, tmpfile_fd, bytes_read;
size_t tmpfilesize;
char *p, *tmpfilename, *text_to_edit;
char *editor_command1, *editor_command2, *editor_command3, *editor_command4,
*line_number_as_string, *column_number_as_string;
char *input, *rewritten_input, *rewritten_input2, **possible_editor_commands;
if (!multiline_separator)
return 0;
tmpfile_fd = open_unique_tempfile(multi_line_tmpfile_ext, &tmpfilename);
text_to_edit =
search_and_replace(multiline_separator, "\n", rl_line_buffer, rl_point,
&line_number, &column_number);
write_patiently(tmpfile_fd, text_to_edit, strlen(text_to_edit), "to temporary file");
if (close(tmpfile_fd) != 0) /* improbable */
myerror(FATAL|USE_ERRNO, "couldn't close temporary file %s", tmpfilename);
/* find out which editor command we have to use */
possible_editor_commands = list4(getenv("RLWRAP_EDITOR"), getenv("EDITOR"), getenv("VISUAL"), "vi +%L");
editor_command1 = first_of(possible_editor_commands);
line_number_as_string = as_string(line_number);
column_number_as_string = as_string(column_number);
editor_command2 =
search_and_replace("%L", line_number_as_string, editor_command1, 0, NULL,
NULL);
editor_command3 =
search_and_replace("%C", column_number_as_string, editor_command2, 0,
NULL, NULL);
editor_command4 = add3strings(editor_command3, " ", tmpfilename);
/* call editor, temporarily restoring terminal settings */
if (terminal_settings_saved && (tcsetattr(STDIN_FILENO, TCSAFLUSH, &saved_terminal_settings) < 0)) /* reset terminal */
myerror(FATAL|USE_ERRNO, "tcsetattr error on stdin");
DPRINTF1(DEBUG_READLINE, "calling %s", editor_command4);
if ((ret = system(editor_command4))) {
if (WIFSIGNALED(ret)) {
fprintf(stderr, "\n");
myerror(FATAL|NOERRNO, "editor killed by signal");
} else {
myerror(FATAL|USE_ERRNO, "failed to invoke editor with '%s'", editor_command4);
}
}
completely_mirror_slaves_terminal_settings();
ignore_queued_input = TRUE;
/* read back edited input, replacing real newline with substitute */
tmpfile_fd = open(tmpfilename, O_RDONLY);
if (tmpfile_fd < 0)
myerror(FATAL|USE_ERRNO, "could not read temp file %s", tmpfilename);
tmpfilesize = filesize(tmpfilename);
input = mymalloc(tmpfilesize + 1);
bytes_read = read(tmpfile_fd, input, tmpfilesize);
if (bytes_read < 0)
myerror(FATAL|USE_ERRNO, "unreadable temp file %s", tmpfilename);
input[bytes_read] = '\0';
rewritten_input = search_and_replace("\t", " ", input, 0, NULL, NULL); /* rlwrap cannot handle tabs in input lines */
rewritten_input2 =
search_and_replace("\n", multiline_separator, rewritten_input, 0, NULL, NULL);
for(p = rewritten_input2; *p ;p++)
if(*p >= 0 && *p < ' ') /* @@@FIXME: works for UTF8, but not UTF16 or UTF32 (Mention this in manpage?)*/
*p = ' '; /* replace all control characters (like \r) by spaces */
rl_delete_text(0, strlen(rl_line_buffer));
rl_point = 0;
clear_line();
cr();
my_putstr(saved_rl_state.cooked_prompt);
rl_insert_text(rewritten_input2);
rl_point = 0; /* leave cursor on predictable place */
rl_done = 1; /* accept line immediately */
/* wash those dishes */
if (unlink(tmpfilename))
myerror(FATAL|USE_ERRNO, "could not delete temporary file %s", tmpfilename);
free(editor_command2);
free(editor_command3);
free(editor_command4);
free(line_number_as_string);
free(column_number_as_string);
free(tmpfilename);
free(text_to_edit);
free(input);
free(rewritten_input);
free(rewritten_input2);
return_key = (char)'\n';
return 0;
}
void
initialise_colour_codes(char *colour)
{
int attributes, foreground, background;
DPRINTF1(DEBUG_READLINE, "initialise_colour_codes(\"%s\")", colour);
attributes = foreground = -1;
background = 40; /* don't need to specify background; 40 passes the test automatically */
sscanf(colour, "%d;%d;%d", &attributes, &foreground, &background);
#define OUTSIDE(lo,hi,val) (val < lo || val > hi)
if (OUTSIDE(0,8,attributes) || OUTSIDE(30,37,foreground) || OUTSIDE(40,47,background))
myerror(FATAL|NOERRNO, "\n"
" prompt colour spec should be ;[;]\n"
" where ranges over [0...8], over [30...37] and over [40...47]\n"
" example: 0;33 for yellow on current background, 1;31;40 for bold red on black ");
colour_start= add3strings("\033[", colour,"m");
colour_end = "\033[0m";
}
/* returns a colourised copy of prompt, trailing space is not colourised */
char*
colourise (const char *prompt)
{
char *prompt_copy, *trailing_space, *colour_end_with_space, *result, *p;
prompt_copy = mysavestring(prompt);
if (strchr(prompt_copy, '\033') || strchr(prompt_copy, RL_PROMPT_START_IGNORE) ) { /* prompt contains escape codes? */
DPRINTF1(DEBUG_READLINE, "colourise %s: left as-is", prompt);
return prompt_copy; /* if so, leave prompt alone */
}
for (p = prompt_copy + strlen(prompt_copy); p > prompt_copy && *(p-1) == ' '; p--)
; /* skip back over trailing space */
trailing_space = mysavestring(p); /* p now points at first trailing space, or else the final NULL */
*p = '\0';
colour_end_with_space = add2strings(colour_end, trailing_space);
result = add3strings(colour_start, prompt_copy, colour_end_with_space);
free (prompt_copy); free(trailing_space); free(colour_end_with_space);
DPRINTF1(DEBUG_READLINE, "colourise %s: colour added ", prompt);
return result;
}
void
move_cursor_to_start_of_prompt(int erase)
{
int termwidth = winsize.ws_col;
int promptlen_on_screen, number_of_lines_in_prompt, curpos, count;
int cooked = (saved_rl_state.cooked_prompt != NULL);
DPRINTF2(DEBUG_READLINE,"prompt_is_still_uncooked: %d, impatient_prompt: %d", prompt_is_still_uncooked, impatient_prompt);
if (prompt_is_still_uncooked && ! impatient_prompt)
return; /* @@@ is this necessary ?*/
promptlen_on_screen = colourless_strlen_unmarked(saved_rl_state.cooked_prompt ? saved_rl_state.cooked_prompt : saved_rl_state.raw_prompt, termwidth);
curpos = (within_line_edit ? 1 : 0); /* if the user has pressed a key the cursor will be 1 past the current prompt */
assert(termwidth > 0);
number_of_lines_in_prompt = 1 + ((promptlen_on_screen + curpos -1) / termwidth); /* integer arithmetic! (e.g. 171/80 = 2) */
cr();
for (count = 0; count < number_of_lines_in_prompt -1; count++) {
if (erase)
clear_line();
curs_up();
}
clear_line();
DPRINTF4(DEBUG_READLINE,"moved cursor up %d lines (erase = %d, len=%d, cooked=%d)", number_of_lines_in_prompt - 1, erase, promptlen_on_screen, cooked);
}
int
prompt_is_single_line(void)
{
int homegrown_redisplay= FALSE;
int force_homegrown_redisplay = FALSE;
int retval;
#ifndef SPY_ON_READLINE
# define _rl_horizontal_scroll_mode FALSE
# define rl_variable_value(s) "off"
#else
# ifndef HAVE_RL_VARIABLE_VALUE
# define rl_variable_value(s) "off"
# endif
#endif
#ifdef HOMEGROWN_REDISPLAY
homegrown_redisplay=TRUE;
#endif
#ifdef DEBUG
force_homegrown_redisplay = debug & FORCE_HOMEGROWN_REDISPLAY;
#endif
retval = _rl_horizontal_scroll_mode ||
strncmp(rl_variable_value("horizontal-scroll-mode"),"on",3) == 0 ||
homegrown_redisplay ||
force_homegrown_redisplay;
DPRINTF1(DEBUG_READLINE, "prompt is %s-line", (retval ? "single" : "multi"));
return retval;
}
char *process_new_output(const char* buffer, struct rl_state* state) {
char*last_nl, *old_prompt_plus_new_output, *new_prompt, *result;
old_prompt_plus_new_output = append_and_free_old(saved_rl_state.raw_prompt, buffer);
last_nl = strrchr(old_prompt_plus_new_output, '\n');
if (last_nl != NULL) { /* newline seen, will get new prompt: */
new_prompt = mysavestring(last_nl +1); /* chop off the part after the last newline - this will be the new prompt */
*last_nl = '\0';
old_prompt_plus_new_output = append_and_free_old (old_prompt_plus_new_output, "\n");
result = (impatient_prompt ? mysavestring (old_prompt_plus_new_output): pass_through_filter(TAG_OUTPUT, old_prompt_plus_new_output));
if (remember_for_completion) {
feed_line_into_completion_list(result); /* feed output into completion list *after* filtering */
}
} else {
new_prompt = mysavestring(old_prompt_plus_new_output);
result = mysavestring("");
}
free(old_prompt_plus_new_output);
saved_rl_state.raw_prompt = new_prompt;
if (saved_rl_state.cooked_prompt) {
free (saved_rl_state.cooked_prompt);
saved_rl_state.cooked_prompt = NULL;
}
return result;
}
int cook_prompt_if_necessary () {
char *pre_cooked, *rubbish_from_alternate_screen, *filtered, *uncoloured, *cooked, *p, *non_rubbish = NULL;
static char **term_ctrl_seqs[]
= {&term_rmcup, &term_rmkx, NULL}; /* (NULL-terminated) list of (pointers to) term control sequences that may be
used by clients to return from an 'alternate screen'. If we spot one of those,
assume that it, and anything before it, is rubbish and better left untouched */
char ***tcptr;
filtered = NULL;
DPRINTF2(DEBUG_READLINE, "Prompt <%s>: %s", saved_rl_state.raw_prompt, prompt_is_still_uncooked ? "still raw" : "cooked already");
if (saved_rl_state.cooked_prompt) /* if (!prompt_is_still_uncooked) bombs with multi-line paste. Apparently
prompt_is_still_uncooked can be FALSE while saved_rl_state.cooked_prompt = NULL. Ouch!@@@! */
return FALSE; /* cooked already */
pre_cooked = mysavestring(saved_rl_state.raw_prompt);
for (tcptr = term_ctrl_seqs; *tcptr; tcptr++) {
/* find last occurence of one of term_ctrl_seq */
if (**tcptr && (p = mystrstr(pre_cooked, **tcptr))) {
p += strlen(**tcptr); /* p now points 1 char past term control sequence */
if (p > non_rubbish)
non_rubbish = p;
}
}
/* non_rubbish now points 1 past the last 'alternate screen terminating' control char in prompt */
if (non_rubbish) {
rubbish_from_alternate_screen = pre_cooked;
pre_cooked = mysavestring(non_rubbish);
*non_rubbish = '\0'; /* 0-terminate rubbish_from_alternate_screen */
} else {
rubbish_from_alternate_screen = mysavestring("");
}
unbackspace(pre_cooked); /* programs that display a running counter would otherwise make rlwrap keep prompts
like " 1%\r 2%\r 3%\ ......" */
if ( /* raw prompt doesn't match '--only-cook' regexp */
(prompt_regexp && ! match_regexp(pre_cooked, prompt_regexp, FALSE)) ||
/* now filter it, but filter may "refuse" the prompt */
(strcmp((filtered = pass_through_filter(TAG_PROMPT, pre_cooked)), "_THIS_CANNOT_BE_A_PROMPT_")== 0)) {
/* don't cook, eat raw (and eat nothing if patient) */
saved_rl_state.cooked_prompt = (impatient_prompt ? mysavestring(pre_cooked) : mysavestring(""));
/* NB: if impatient, the rubbish_from_alternate_screen has been output already, no need to send it again */
free(pre_cooked);
free(filtered); /* free(NULL) is never an error */
return FALSE;
}
free(pre_cooked);
if(substitute_prompt) {
uncoloured = mysavestring(substitute_prompt);
free(filtered);
} else {
uncoloured = filtered;
}
if (colour_the_prompt) {
cooked = colourise(uncoloured);
free(uncoloured);
} else {
cooked = uncoloured;
}
if (! impatient_prompt) /* in this case our rubbish hasn't been output yet. Output it now, but don't store
it in the prompt, as this may be re-printed e.g. after resuming a suspended rlwrap */
write_patiently(STDOUT_FILENO,rubbish_from_alternate_screen, strlen(rubbish_from_alternate_screen), "to stdout");
saved_rl_state.cooked_prompt = cooked;
return TRUE;
}
/* Utility functions for binding keys. */
static int please_update(const char *varname) {
myerror(FATAL|NOERRNO, "since version 0.35, the readline function '%s' is called '%s'\n"
"(hyphens instead of underscores). Please update your .inputrc",
varname, search_and_replace("_","-", varname, 0, NULL, NULL));
return 0;
}
static int please_update_alaf(int count, int key) {
return please_update("rlwrap_accept_line_and_forget");
}
static int please_update_ce(int count, int key) {
return please_update("rlwrap_call_editor");
}
/*
From the readline documentation: Acceptable keymap names are emacs, emacs-standard, emacs-meta, emacs-ctlx, vi,
vi-move, vi-command, and vi-insert. vi is equivalent to vi-command; emacs is equivalent to emacs-standard. The
default value is emacs. The value of the editing-mode variable also affects the default keymap.
*/
static Keymap getmap(const char *name) {
Keymap km = rl_get_keymap_by_name(name);
if (!km)
myerror(FATAL|NOERRNO, "Could not get keymap '%s'", name);
return km;
}
static void bindkey(int key, rl_command_func_t *function, const char *maplist) {
char *mapnames[] = {"emacs-standard","emacs-ctlx","emacs-meta","vi-insert","vi-move","vi-command",NULL};
char **mapname;
for (mapname = mapnames; *mapname; mapname++)
if(strstr(maplist, *mapname)) {
Keymap kmap = getmap(*mapname);
DPRINTF4(DEBUG_READLINE,"Binding key %d (%s) in keymap '%s' to <0x%lx>", key, mangle_char_for_debug_log(key,TRUE), *mapname, (long) function);
if (rl_bind_key_in_map(key, function, kmap))
myerror(FATAL|NOERRNO, "Could not bind key %d (%s) in keymap '%s'", key, mangle_char_for_debug_log(key,TRUE), *mapname);
}
}
rlwrap-0.42/src/malloc_debug.c 0000644 0001751 0000144 00000016032 12407256446 013250 0000000 0000000 /* malloc_debug.c: attempt at malloc/free replacement for debugging
configure with --enable-malloc-debugger to use it
*/
/* This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License , or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
You may contact the author by:
e-mail: hlub@knoware.nl
*/
#include "rlwrap.h"
#ifdef DEBUG
# define USE_MALLOC_DEBUGGER
# undef mymalloc
# undef free
#endif
#ifdef USE_MALLOC_DEBUGGER
#define SLAVERY_SLOGAN "rlwrap is boss!"
#define FREEDOM_SLOGAN "free at last!"
#define SLOGAN_MAXLEN 20
extern int debug;
typedef RETSIGTYPE (*sighandler_t)(int);
typedef struct freed_stamp
{
char magic[SLOGAN_MAXLEN]; /* magical string that tells us this something about this memory: malloced or freed? */
char *file; /* source file where we were malloced/freed */
int line; /* source line where we were malloced/freed */
int size;
void *previous; /* maintain a linked list of malloced/freed memory for post-mortem investigations*/
} *Freed_stamp;
static void* blocklist = 0; /* start of linked list of allocated blocks. when freed, blocks stay on the list */
static int memory_usage = 0;
static char *offending_sourcefile;
static int offending_line;
sighandler_t old_segfault_handler;
/* local segfault handler, installed just before we dereference a pointer to test its writability */
static RETSIGTYPE
handle_segfault(int unused)
{
fprintf(stderr, "free() called on bad (unallocated) memory at %s:%d\n", offending_sourcefile, offending_line);
exit(1);
}
/* allocates chunk of memory including a freed_stamp, in which we write
line and file where we were alllocated, and a slogan to testify that
we have been allocated and not yet freed. returns the address past the stamp
If you think this memory will ever be freed by a normal free() use malloc_foreign instead
*/
void *
debug_malloc(size_t size, char *file, int line)
{
void *chunk;
Freed_stamp stamp;
if (!(debug & DEBUG_MEMORY_MANAGEMENT))
return mymalloc(size);
chunk = mymalloc(sizeof(struct freed_stamp) + size);
stamp = (Freed_stamp) chunk;
memory_usage += size;
DPRINTF4(DEBUG_MEMORY_MANAGEMENT, "malloc size: %d at %s:%d: (total usage now: %d)", (int) size, file, line, memory_usage);
strncpy(stamp->magic, SLAVERY_SLOGAN, SLOGAN_MAXLEN);
stamp -> file = file;
stamp -> line = line;
stamp -> size = size;
stamp -> previous = blocklist;
blocklist = chunk;
return (char *) chunk + sizeof(struct freed_stamp);
}
/* Verifies that ptr indeed points to memory allocaded by debug_malloc,
and has not yet been freed. Doesn't really free it, but marks it as freed
so that we easily notice double frees */
void
debug_free(void *ptr, char *file, int line)
{
Freed_stamp stamp;
if (!(debug & DEBUG_MEMORY_MANAGEMENT)) {
free(ptr);
return;
}
stamp = ((Freed_stamp) ptr) - 1;
offending_sourcefile = file; /* use static variables to communicate with signal handler */
offending_line = line;
old_segfault_handler = signal(SIGSEGV, &handle_segfault);
* (char *) ptr = 'x'; /* this, or the next statement will provoke a segfault when address is not writable, i.e. in read-only memory or
not in a mamory-mapped area */
if (strcmp(FREEDOM_SLOGAN, stamp -> magic) == 0) { /* Argghh! this memory has been freed before! */
fprintf(stderr, "free() called twice, at %s:%d: (on memory already freed at %s:%d)\n",
file, line, stamp->file, stamp->line);
exit(1);
} else if (strcmp(SLAVERY_SLOGAN, stamp -> magic) == 0) {
DPRINTF4(DEBUG_MEMORY_MANAGEMENT, "free() (called at %s:%d) of memory malloced at %s:%d", file, line, stamp->file, stamp->line);
strncpy(stamp->magic, FREEDOM_SLOGAN, SLOGAN_MAXLEN);
stamp -> file = file;
stamp -> line = line;
memory_usage -= stamp -> size;
signal(SIGSEGV, old_segfault_handler);
/* don't really free ptr */
} else {
fprintf(stderr, "free() called (at %s:%d) on unmalloced memory <%s>, or memory not malloced by debug_malloc()\n",
file, line, mangle_string_for_debug_log(ptr, 30));
close_logfile();
exit(1);
}
}
/* this function calls free() directly, and should be used on memory that was malloc'ed outside our own jurisdiction,
i.e. not by debug_malloc(); */
void free_foreign(void *ptr) {
free(ptr);
}
/* this function calls malloc() directly, and should be used on memory that could be freed outside our own jurisdiction,
i.e. not by debug_free(); */
void *malloc_foreign(size_t size) {
return malloc(size);
}
/* sometimes we put in one structure objects that were malloced elsewhere and our own mymalloced objects.
we cannot free such a structure with free(), nor with free_foreign(). Solution: before using the "foreign" objects,
copy them to mymalloced memory and free them immediately
This function will be redefined to a NOP (i.e. just return its first argument) unless DEBUG is defined */
void *copy_and_free_for_malloc_debug(void *ptr, size_t size) {
void *copy;
if (ptr == NULL)
return NULL;
copy = debug_malloc(size,"foreign",0);
memcpy(copy, ptr, size);
free(ptr);
return copy;
}
char *copy_and_free_string_for_malloc_debug(char* str) {
if (str == NULL)
return NULL;
return copy_and_free_for_malloc_debug(str, strlen(str)+1);
}
/* this function logs all non-freed memory blocks (in order to hunt for memory leaks) */
/* blocklist = NULL, hence it is a no-op unless DEBUG_MALLOC has been defined */
void debug_postmortem() {
Freed_stamp p;
char *block;
DPRINTF0(DEBUG_MEMORY_MANAGEMENT,"Postmortem list of unfree memory blocks (most recently allocated first): ");
for (p = (Freed_stamp) blocklist; p; p = p ->previous) {
if (strcmp(FREEDOM_SLOGAN, p -> magic) == 0)
continue;
else if (strcmp(SLAVERY_SLOGAN, p -> magic) == 0) {
block = (char *) p + sizeof(struct freed_stamp);
DPRINTF4(DEBUG_MEMORY_MANAGEMENT, "%d bytes malloced at %s:%d, contents: <%s>", p->size, p ->file, p ->line, mangle_string_for_debug_log(block, MANGLE_LENGTH));
} else {
DPRINTF0(DEBUG_MEMORY_MANAGEMENT, "Hmmm, unmalloced memory, or memory not malloced by debug_malloc()");
}
}
}
int test_main() {
char **list = split_with("a bee ceee", " ");
char **word = list;
while(*word) {
printf("word: %s\n", *word++);
}
free_splitlist(list);
return 0;
}
#endif /* def USE_MALLOC_DEBUGGER */
rlwrap-0.42/src/Makefile.in 0000644 0001751 0000144 00000044453 12431405512 012527 0000000 0000000 # Makefile.in generated by automake 1.14.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994-2013 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
am__make_running_with_option = \
case $${target_option-} in \
?) ;; \
*) echo "am__make_running_with_option: internal error: invalid" \
"target option '$${target_option-}' specified" >&2; \
exit 1;; \
esac; \
has_opt=no; \
sane_makeflags=$$MAKEFLAGS; \
if $(am__is_gnu_make); then \
sane_makeflags=$$MFLAGS; \
else \
case $$MAKEFLAGS in \
*\\[\ \ ]*) \
bs=\\; \
sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
esac; \
fi; \
skip_next=no; \
strip_trailopt () \
{ \
flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
}; \
for flg in $$sane_makeflags; do \
test $$skip_next = yes && { skip_next=no; continue; }; \
case $$flg in \
*=*|--*) continue;; \
-*I) strip_trailopt 'I'; skip_next=yes;; \
-*I?*) strip_trailopt 'I';; \
-*O) strip_trailopt 'O'; skip_next=yes;; \
-*O?*) strip_trailopt 'O';; \
-*l) strip_trailopt 'l'; skip_next=yes;; \
-*l?*) strip_trailopt 'l';; \
-[dEDm]) skip_next=yes;; \
-[JT]) skip_next=yes;; \
esac; \
case $$flg in \
*$$target_option*) has_opt=yes; break;; \
esac; \
done; \
test $$has_opt = yes
am__make_dryrun = (target_option=n; $(am__make_running_with_option))
am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
bin_PROGRAMS = rlwrap$(EXEEXT)
subdir = src
DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
$(top_srcdir)/tools/depcomp
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
am__installdirs = "$(DESTDIR)$(bindir)"
PROGRAMS = $(bin_PROGRAMS)
am_rlwrap_OBJECTS = main.$(OBJEXT) signals.$(OBJEXT) \
readline.$(OBJEXT) pty.$(OBJEXT) completion.$(OBJEXT) \
term.$(OBJEXT) ptytty.$(OBJEXT) utils.$(OBJEXT) \
string_utils.$(OBJEXT) malloc_debug.$(OBJEXT) filter.$(OBJEXT)
rlwrap_OBJECTS = $(am_rlwrap_OBJECTS)
rlwrap_LDADD = $(LDADD)
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
am__v_P_0 = false
am__v_P_1 = :
AM_V_GEN = $(am__v_GEN_@AM_V@)
am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
am__v_GEN_0 = @echo " GEN " $@;
am__v_GEN_1 =
AM_V_at = $(am__v_at_@AM_V@)
am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
am__v_at_0 = @
am__v_at_1 =
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/tools/depcomp
am__depfiles_maybe = depfiles
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
AM_V_CC = $(am__v_CC_@AM_V@)
am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
am__v_CC_0 = @echo " CC " $@;
am__v_CC_1 =
CCLD = $(CC)
LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
AM_V_CCLD = $(am__v_CCLD_@AM_V@)
am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
am__v_CCLD_0 = @echo " CCLD " $@;
am__v_CCLD_1 =
SOURCES = $(rlwrap_SOURCES)
DIST_SOURCES = $(rlwrap_SOURCES)
am__can_run_installinfo = \
case $$AM_UPDATE_INFO_DIR in \
n|no|NO) false;; \
*) (install-info --version) >/dev/null 2>&1;; \
esac
am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
# Read a list of newline-separated strings from the standard input,
# and print each of them once, without duplicates. Input order is
# *not* preserved.
am__uniquify_input = $(AWK) '\
BEGIN { nonempty = 0; } \
{ items[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in items) print i; }; } \
'
# Make sure the list of sources is unique. This is necessary because,
# e.g., the same source file might be shared among _SOURCES variables
# for different programs/libraries.
am__define_uniq_tagged_files = \
list='$(am__tagged_files)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | $(am__uniquify_input)`
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
GREP = @GREP@
HAVE_LONG_OPTS = @HAVE_LONG_OPTS@
HAVE_OPTIONAL_ARGS = @HAVE_OPTIONAL_ARGS@
HAVE_PROC_PID_CWD = @HAVE_PROC_PID_CWD@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LTLIBOBJS = @LTLIBOBJS@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
OBJEXT = @OBJEXT@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PERL = @PERL@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
#EXTRA_PROGRAMS=rltest1 rltest2 rltest3 kaboom
rlwrap_SOURCES = main.c signals.c readline.c pty.c completion.c term.c ptytty.c utils.c string_utils.c malloc_debug.c filter.c
#rltest1_SOURCES=rltest1.c
#rltest2_SOURCES=rltest2.c
#rltest3_SOURCES=rltest3.c
#kaboom_SOURCES=kaboom.c
AM_CFLAGS = -DDATADIR=\"@datadir@\"
all: all-am
.SUFFIXES:
.SUFFIXES: .c .o .obj .rb
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu src/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
install-binPROGRAMS: $(bin_PROGRAMS)
@$(NORMAL_INSTALL)
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
if test -n "$$list"; then \
echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
$(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
fi; \
for p in $$list; do echo "$$p $$p"; done | \
sed 's/$(EXEEXT)$$//' | \
while read p p1; do if test -f $$p \
; then echo "$$p"; echo "$$p"; else :; fi; \
done | \
sed -e 'p;s,.*/,,;n;h' \
-e 's|.*|.|' \
-e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
sed 'N;N;N;s,\n, ,g' | \
$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
{ d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
if ($$2 == $$4) files[d] = files[d] " " $$1; \
else { print "f", $$3 "/" $$4, $$1; } } \
END { for (d in files) print "f", d, files[d] }' | \
while read type dir files; do \
if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
test -z "$$files" || { \
echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
$(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
} \
; done
uninstall-binPROGRAMS:
@$(NORMAL_UNINSTALL)
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
files=`for p in $$list; do echo "$$p"; done | \
sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
-e 's/$$/$(EXEEXT)/' \
`; \
test -n "$$list" || exit 0; \
echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
cd "$(DESTDIR)$(bindir)" && rm -f $$files
clean-binPROGRAMS:
-test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS)
rlwrap$(EXEEXT): $(rlwrap_OBJECTS) $(rlwrap_DEPENDENCIES) $(EXTRA_rlwrap_DEPENDENCIES)
@rm -f rlwrap$(EXEEXT)
$(AM_V_CCLD)$(LINK) $(rlwrap_OBJECTS) $(rlwrap_LDADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/completion.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/filter.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/malloc_debug.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pty.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ptytty.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/readline.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/signals.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/string_utils.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/term.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/utils.Po@am__quote@
.c.o:
@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
.c.obj:
@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
ID: $(am__tagged_files)
$(am__define_uniq_tagged_files); mkid -fID $$unique
tags: tags-am
TAGS: tags
tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
set x; \
here=`pwd`; \
$(am__define_uniq_tagged_files); \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: ctags-am
CTAGS: ctags
ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
$(am__define_uniq_tagged_files); \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
cscopelist: cscopelist-am
cscopelist-am: $(am__tagged_files)
list='$(am__tagged_files)'; \
case "$(srcdir)" in \
[\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
*) sdir=$(subdir)/$(srcdir) ;; \
esac; \
for i in $$list; do \
if test -f "$$i"; then \
echo "$(subdir)/$$i"; \
else \
echo "$$sdir/$$i"; \
fi; \
done >> $(top_builddir)/cscope.files
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(PROGRAMS)
installdirs:
for dir in "$(DESTDIR)$(bindir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
if test -z '$(STRIP)'; then \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
install; \
else \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
"INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
fi
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-binPROGRAMS clean-generic mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am:
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am: install-binPROGRAMS
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-binPROGRAMS
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
clean-binPROGRAMS clean-generic cscopelist-am ctags ctags-am \
distclean distclean-compile distclean-generic distclean-tags \
distdir dvi dvi-am html html-am info info-am install \
install-am install-binPROGRAMS install-data install-data-am \
install-dvi install-dvi-am install-exec install-exec-am \
install-html install-html-am install-info install-info-am \
install-man install-pdf install-pdf-am install-ps \
install-ps-am install-strip installcheck installcheck-am \
installdirs maintainer-clean maintainer-clean-generic \
mostlyclean mostlyclean-compile mostlyclean-generic pdf pdf-am \
ps ps-am tags tags-am uninstall uninstall-am \
uninstall-binPROGRAMS
# use old-fashioned suffix rule for non-GNU make
.rb.c :
rbgen $< $@ || echo "You don't seem to have rbgen (http://libredblack.sourceforge.net/). If you didn't change any .rb files, this is not a problem"
#clean-local:
# rm -f *~ kaboom rltest1 rltest2 rltest3
#all-local: kaboom rltest1 rltest2 rltest3
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
rlwrap-0.42/TODO 0000644 0001751 0000144 00000000466 12404151311 010352 0000000 0000000 TODO:
SHORT-TERM:
- fix the BUGS (cf BUGS)
- improve handling of SIGSTP and SIGWINCH when using filters that launch pagers or editors
- write a RlwrapFilter.py
- find analogues of /proc/$command_pid/wchan on other unices
- create $RLWRAP_DIR if it doesn't exist
- fix cross-compilation
LONG-TERM:
rlwrap-0.42/BUGS 0000644 0001751 0000144 00000005625 12404151311 010347 0000000 0000000 Whenever you suspect a bug, if possible, please reconfigure with
./configure --enable-debug and run rlwrap with a -d7 option. This will
create a file /tmp/rlwrap.debug that will help you (or me) find the
problem.
Many (most) bug reports, especially the really weird ones, stem from
"version skew" on distributions (RedHat, Debian) that have separate
development packages (e.g. readline and readline-dev). For some reason
it can happen that the devel package is out of sync with the main
package, and then really strange things may happen. So: always update your
{readline, ncurses}-devel packages before you complain to me!
* General inadequacy and weak spots:
The more sophisticated the terminal handling of rlwrapped program (the
"client") gets, the less rlwrap will be able to maintain its
transparency. Of course, more sophisticated programs generally have
less need for rlwrap.
rlwrap cannot handle prompts that contain control characters (except
ANSI colour), though you may not notice this until your cursor almost
reaches end-of-line
---
Christoffer Dam Bruun reported:
"I have just installed rlwrap along with readline on Solaris 8 and
found that rlwrap did not work properly with readline 4.3. After
linking rlwrap with readline 4.2 it works correctly.
What happended using readline 4.3 was that an extra prompt would be
written after the first letter on a line, e.g. with a sqlplus prompt:
SQL>
(now writing select )
SQL> sSQL> select"
I (HL) have not been able to reproduce this, but there have been a few
more reports about this. In a few cases, the display was even more
garbled, like
SQL> sSQL> se>SQL> selSQL> sele>SQL> selec> ....
Remedy: first make sure that your readline headers and runtime
libraries are in sync. May people have a readline-dev package that is
older than their runtime libraries. If this doesn't help: configure
rlwrap with --enable-homegrown-redisplay and recompile.
---
Readline 5.0 has a slight bug where scrolling up through history and
then back again ends on a non-empty line (the first history line, in
fact).
---
The -m option uses the system() (3) library function to call an
external editor. I'm not quite sure how system() handles signals like
TSTP an WINCH (and "system" is a difficult name to Google for...)
Re-sizing the terminal may confuse the editor
--
Paolo Casaschi reported that his rlwrap failed with the message
rlwrap: error: Could not open slave pty: Permission denied
This turned out to be a problem with /etc/fstab, where the entry for
/dev/pty was:
none /dev/pts devpts gid=5,mode=20 0 0
instead of
none /dev/pts devpts gid=5,mode=620 0 0
which fixed the problem
--
The code that determines whether a cooked prompt should be overwritten
(when it turns out to not have been a prompt) is needlessly complex
and not quite correct (e.g. substitute prompts may be left standing
when they should be erased).
rlwrap-0.42/doc/ 0000755 0001751 0000144 00000000000 12431413017 010505 5 0000000 0000000 rlwrap-0.42/doc/rlwrap.man.in 0000644 0001751 0000144 00000051432 12431411103 013035 0000000 0000000 .TH rlwrap 1 "November 14, 2014"
.SH NAME
rlwrap \- readline wrapper
.de OP
.ie \\n(.$-1 .RI "[\ \fB\\$1\fP " "\\$2" "\ ]"
.el .RB "[\ " "\\$1" "\ ]"
..
.de CW
.ie '@HAVE_PROC_PID_CWD@'yes' When doing this, rlwrap keeps track \
of \fIcommand\fPs working directory.
.el This is not always useful, as rlwrap cannot keep track of \
\fIcommand\fP's working directory.
..
.de OA
.ie '@HAVE_OPTIONAL_ARGS@'yes' The argument is optional; if given, it has to \
directly follow the option without an
intervening space.
.el On this system, you \fBmust\fP give a (dummy) argument.
..
.de OL
.ie '@HAVE_LONG_OPTS@'yes' .B \\$1, \\$2 \\$3
.el .B \\$1 \\$3
..
.SH SYNOPSIS
.B rlwrap
.I [rlwrap\-options]
.I command \.\.\.
.SH DESCRIPTION
\fBrlwrap\fP runs the specified \fIcommand\fP, intercepting user input
in order to provide \fBreadline\fP's line editing, persistent history
and completion.
\fBrlwrap\fP tries to be completely transparent \- you
(or your shell) shouldn't notice any difference between \fBcommand\fP and \fBrlwrap
command\fP \- except the added readline functionality, of course.
This should even hold true when you are re\-directing, piping and
sending signals from and to \fIcommand\fP, or when \fIcommand\fP
manipulates its terminal settings.
There are many options to add
(programmable) completion, handle multi\-line input, colour and
re\-write prompts. If you don't need them (and you probably don't),
you can skip the rest of this manpage.
.SH OPTIONS
.TP
.OL \-a \-\-always\-readline [\fIpassword_prompt\fP]
Always remain in "readline mode", regardless of \fIcommand\fP's terminal settings.
Use this option if you want to use \fBrlwrap\fP with \fIcommand\fPs that already
use readline.
\fBNB\fP: With this
option, rlwrap will echo (and save) passwords, unless you give \fIcommand\fP's
password prompt as an argument.
.OA \-a \-\-always\-readline Password:
On a linux machine you can use the \fB\-N\fP (\fB\-\-no\-children\fP) option to prevent the wrapping of
pagers and editors called from \fIcommand\fP; this should make them much more usable
Many commands that need \fB\-\-always\-readline\fP may also need
\fB\-t dumb\fP to prevent terminal control sequences from confusing
\fBrlwrap\fP (although this will annoy the above\-mentioned pagers and
editors)
.TP
.OL \-A \-\-ansi\-colour\-aware
Prompts that use colour will confuse rlwrap, especially at the end of
long input lines. This option will make rlwrap better behaved in such cases.
If the prompt contains anything fancier than ANSI colour codes, this option
may actually make things worse.
.TP
.OL \-b \-\-break\-chars \fIlist_of_characters\fP
Consider the specified characters word\-breaking (whitespace is
always word\-breaking). This determines what is considered a "word",
both when completing and when building a completion word list from
files specified by \fB\-f\fP options following (not preceding!) it.
Default list (){}[],'+\-=&^%$#@"";|\\ Unless \-c is specified, \" twice " to keep emacs happy :\-(
/ and \. (period) are included in the default list.
.TP
.OL \-c \-\-complete\-filenames
Complete filenames (filename completion is always case\-sensitive, even with the
\-i option)
.CW
.TP
.OL \-C \-\-command\-name \fIcommand_name|N\fP
Use \fIcommand_name\fP instead of \fIcommand\fP to determine the names of
history and completion files, and to initialise readline (as specified in
~/.inputrc). A numeric argument N > 0 means: use the Nth argument counting
backwards from the end of the argument list
.TP
.OL \-D \-\-history\-no\-dupes \fIn\fP
How agressively to weed out duplicate entries from the input history.
If \fIn\fP = \fB0\fP, all inputs are kept in the history list, if
\fIn\fP = \fB1\fP (this is the default) consecutive duplicates are dropped
from the list, while \fIn\fP = \fB2\fP will make \fBrlwrap\fP drop all
previous occurrences of the current input from the list.
.TP
.OL \-e \-\-extra-char-after-completion \fIchar\fP
By default, rlwrap appends a space after any inserted completion text. Use this
option to change this to '' (don't insert anything) or some other character.
.TP
.OL \-f \-\-file \fIfile\fP
Split \fIfile\fP into words and add them to the completion word list. This
option can be given more than once, and \fIadds\fP to the default
completion list in $RLWRAP_HOME or @DATADIR@/rlwrap/completions.
Specifying \fB\-f .\fP will make \fBrlwrap\fP use the current history file as a
completion word list.
.TP
.OL \-g \-\-forget\-matching \fIregexp\fP
Forget (i.e. drop from history list) all input lines that match
the POSIX 1003.2 regular expression \fIregexp\fP.
The match is always case\-insensitive. \fIregexp\fP may be an ordinary
string. For more about regular expressions, see \fBregex (7)\fP
.TP
.OL \-h \-\-help
Print a short help message.
.TP
.OL \-H \-\-history\-filename \fIfile\fP
Read command history from \fIfile\fP (and write it back there if
\-\-histsize >= 0)
.TP
.OL \-i \-\-case\-insensitive
Ignore case when completing (filename completion remains case\-sensitive). This option has to come before any \-f options.
.TP
.OL \-I \-\-pass\-sigint\-as\-sigterm
Send a TERM signal to \fIcommand\fP when an INT is received (e.g. when you
press CTRL\-C).
.TP
.OL \-l \-\-logfile \fIfile\fP
When in readline mode, append \fIcommand\fP's output (including echo'ed user input) to
\fIfile\fP (creating \fIfile\fP when it doesn't exist).
.TP
.OL \-n \-\-no\-warnings
Don't print warnings.
.TP
.OL \-N \-\-no\-children
Don't rlwrap \fIcommand\fP's children: whenever \fBrlwrap\fP notices that
\fIcommand\fP is waiting for one of its children, it switches to direct mode, handing down all keypresses immediately.
With this option commands that need \-\-always\-readline can call editors and pagers and still be usable.
This option needs /proc/\fIcommand\fP_pid/wchan, so it only works with linux kernels configured with CONFIG_KALLSYMS.
.TP
.OL \-m \-\-multi\-line [\fInewline_substitute\fP]
Enable multi\-line input using a "newline substitute" character
sequence (" \\ ", [space\-backslash\-space] by default). Newline
substitutes are translated to newlines before sending the input to
\fIcommand\fP. With this option, you can call an external editor
$RLWRAP_EDITOR on the (expanded) current input with the
\fIrlwrap_call_editor\fP key (CTRL\-^ by default)
.OA \-m \-\-multi\-line ';;'
.TP
.OL \-M \-\-multi\-line\-ext \fI.ext\fP
Call multi-line-editor on temporary files with filename extension \fI.ext\fP (useful for e.g. automatic syntax colouring)
.TP
.OL \-o \-\-one\-shot
Send an EOF to \fIcommand\fP after accepting the first line of input
.TP
.OL \-O \-\-only\-cook \fIregexp\fP
Only ever "cook" prompts that match \fIregexp\fP
.TP
.OL \-p \-\-prompt\-colour [\fIcolour_name|Colour_name|colour_spec\fP]
Use one of the colour names \fIblack, red, green, yellow, blue, cyan, purple (=magenta)\fP or \fIwhite\fP, or an ANSI\-conformant to colour any prompt displayed by
\fIcommand\fP. An uppercase colour name (\fIYellow\fP or \fIYELLOW\fP ) gives a bold prompt. Prompts that already contain
(colour) escape sequences or one of the readline "ignore markers" (ASCII 0x01 and 0x02) are not coloured. This option implies \-\-ansi\-colour\-aware.
\fIcolour spec\fP has the form
;[;] Example: \-p'1;31' will give a bold red prompt on the
current background (this is the default when no argument is
given). Google for 'ANSI color' to learn more about colour codes.
.OA \-p \-\-prompt\-colour '0;31'
.TP
.OL \-P \-\-pre\-given \fItext\fP
Start \fBrlwrap\fP with \fItext\fP in its edit buffer (this will automatically
set the \-\-always\-readline option).
.TP
.OL \-q \-\-quote\-characters \fIlist_of_characters\fP
Assume that the given characters act as quotes, e.g. when matching
parentheses. Take care to escape the list properly for your shell (example: \-q "\\"'", which happens to be the
default, or \-q "\\"" which will be better for Lisp users)
.TP
.OL \-r \-\-remember
Put all words seen on in\- and output on the completion list.
.TP
.OL \-R \-\-renice
Make \fBrlwrap\fP nicer than \fIcommand\fP (cf \fBnice (1)\fP). This may prevent \fBrlwrap\fP from
interrupting \fIcommand\fP to display a prompt when \fIcommand\fP is still "thinking" about what to output next.
.TP
.OL \-s \-\-histsize \fIN\fP
Limit the history list to N entries, truncating the history file
(default: 300). A negative size \-N means the same as N, but treats the history file as read\-only.
.TP
.OL \-S \-\-substitute\-prompt \fIprompt\fP
Substitute the specified prompt for \fIcommand\fP's own prompt. Mainly useful when \fIcommand\fP doesn't have a prompt.
.TP
.OL \-t \-\-set\-term\-name \fIname\fP
Set \fIcommand\fP's TERM to \fIname\fP. Programs that confuse \fBrlwrap\fP with fancy screen control codes can sometimes be tamed by specifying \fB\-t dumb\fP
.TP
.OL \-U \-\-mirror-arguments
(linux only) Keep track of \fIcommand\fP's arguments as seen by the \fBps (1)\fP command, and mirror them in \fBrlwrap\fP's own arguments
This is mainly useful for commands that overwrite command-line password arguments that would be exposed by rlwrap without this option.
.TP
.OL \-v \-\-version
Print rlwrap version.
.TP
.OL \-w \-\-wait\-before\-prompt \fItimeout\fP
In order to determine if \fIcommand\fP's last output is a prompt, \fBrlwrap\fP waits \fItimeout\fP millisecs after receiving it.
Only when no more output has arrived, it is cooked (coloured, filtered and/or replaced by a substitute prompt) and displayed as a prompt.
Before this the prompt is displayed "uncooked". Most users won't notice, but heavy cookers can prepend the timeout with a minus sign,
making rlwrap hold back the prompt until it has been cooked ("patient mode"). This will prevent flashing of the prompt, but it will also interfere with long output lines and make switches from direct to readline mode less reliable. Default timeout: 40 ms
.TP
.OL \-W \-\-polling
EXPERIMENTAL: Wake up every \fItimeout\fP millisecs, where \fItimeout\fP is the same as for the \-w (\-\-wait\-before\-prompt) option, 40 ms by default. This is used to sense the slave's interrupt character and ISIG flag and to adjust stdin's terminal settings accordingly, even before you press a key. Try this option e.g. when CTRL-C acts differently on \fIcommand\fP with, and without, rlwrap.
.TP
.OL \-z \-\-filter \fIfilter\fP
Use a filter to change \fBrlwrap\fP's behaviour. A filter can be used to keep certain input out of the history,
to change the prompt, to implement simple macros or programmable completion.. \fBrlwrap\fP comes with a special \fBperl\fP module
(cf. \fBRlwrapFilter(3pm)\fP) for easy filter writing. A number of example filters are installed in the directory
@DATADIR@/rlwrap/filters. "rlwrap \-z \fIfilter\fP" displays information about a filter, "rlwrap \-z listing" lists all currently installed filters.
If \fIfilter\fP needs arguments, you should quote the whole filter command line:
.nf
rlwrap \-z 'filter args' command
.fi
If this command line contains shell metacharacters, \fBrlwrap\fP passes it to the system shell for parsing.
.SH EXAMPLES
.TP 3
Run \fBnc\fP (netcat) with command\-line editing and history
.B rlwrap\ nc
.TP
Wrap \fBsmbclient\fP (which uses readline itself), keep passwords out of the history and don't wrap commands launched from smbclient (like \fBmore\fP)
.B rlwrap\ \-aPassword:\ \-N\ smbclient //PEANUT/C
.TP
Wrap \fBgauche\fP (a Scheme interpreter) with a bold blue prompt, enable multi\-line editing (using .scm as filename extension) and don't consider single quotes as quotes (so that the parentheses in e.g. (print 'q) match)
.B rlwrap\ \-pBlue \-m\ \-M\ .scm\ \-q'"' gosh
.TP
Get a list of all currently installed filters
.B rlwrap\ \-z\ listing
.TP
Get help for the filter \fBpipeto\fP
.B rlwrap\ \-z\ pipeto
.TP
Wrap \fBsqlite3\fP, use the \fBpipeto\fP filter to be able to pipe the output of SQL commands through \fBgrep\fP and/or \fBless\fP, complete (case\-insensitively) on the SQL keywords in 'sql_words'
.B rlwrap\ \-a\ \-z\ pipeto\ \-i\ \-f\ sql_words\ sqlite3\ contacts.db
.TP
In a shell script, use \fBrlwrap\fP in 'one\-shot' mode as a replacement for \fBread\fP
.B order=$(rlwrap\ -pYellow\ \-S\ 'Your pizza?\ '\ \-H past_orders\ \-P\ Margherita\ \-o\ cat)
.SH DIRECT MODE AND READLINE MODE
Most simple console commands put your terminal either in "cooked" or
in "raw" mode. In cooked mode the terminal will wait until you press
the ENTER key before handing the entire line to the program, in raw
mode every key you press is handed down immediately. In cooked mode
you generally can use the backspace key, but not the arrow keys, to
edit your input. Most simple console commands use cooked mode whenever
they want whole input lines, and raw mode when they want single
keypresses. More sophisticated commands tend to use raw mode all the
time; they may sometimes be rlwrappable with the \fB\-a\fP (and \fB\-N\fP) options.
When you \fBrlwrap\fP \fIcommand\fP, \fBrlwrap\fP will run it a
in a separate session, with its own "pseudo\-terminal" (pty),
and monitor this pty to see whether the pty is in raw mode or in
cooked mode. In the first case, \fBrlwrap\fP will copy all input
and output directly between \fIcommand\fP and your terminal ("direct
mode"). In the second case, \fBrlwrap\fP will use readline to edit your input ("readline mode"), and monitor
\fBcommand\fP's output \- every last line that doesn't end with a newline is a potential prompt. How it handles such a candidate prompt depends on its being in "patient" or "impatient" mode:
.SH PATIENT AND IMPATIENT MODE
If \fIcommand\fP writes a lot of output, it tends to be written (and
read) in "chunks". Not all chunks will end with a newline, and we need
to distinguish their last lines from real prompts, especially if we
want to re\-write ("cook") prompts. \fBrlwrap\fP solves this (almost)
by waiting a little, to see if there is more to come. "A little" is 40
msec by default, but this can be changed with the \fB\-w\fP option.
Normally \fBrlwrap\fP writes the suspected prompt as soon as it is
received, replacing it with a "cooked" version afer the wait
time. This is called "impatient" mode. If you don't like the flashing
effect (which can become annoying when you "cook" the prompt heavily) you
can put \fBrlwrap\fP in "patient mode" by specifying a negative value with \fB\-w\fP (e.g. \-w \-40). Rlwrap
will then hold back the prompt and only print if after cooking.
.SH COOKING PROMPTS
If and when \fBrlwrap\fP decides that it has a prompt, it will
perform a number of actions on it, depending on the given options:
filtering (\fB\-z\fP), substituting (\fB\-S\fP) and colouring
(\fB\-p\fP), in this order. The resulting "cooked" prompt is then
printed (after erasing the "raw" prompt, if necessary)
.SH SPECIAL KEYS
.TP
.B Control + O
Accept the current line, but don't put it in the history list. This action
has a \fBreadline\fP command name \fIrlwrap\-accept\-line\-and\-forget\fP
.TP
.B Control + ^
Use an external editor to edit the current input (this will only work if the \-m
option is set). This action
has a \fBreadline\fP command name \fIrlwrap\-call\-editor\fP
.PP
These special keys were chosen for no other reason than that they are not currently bound to any
readline action. If you don't like them, (or your window manager swallows them) they
can be re\-bound more sensibly by including lines like the
following in your \fB~/.inputrc\fP:
.PP
.nf
"\eM\-\eC\-m": rlwrap\-accept\-line\-and\-forget # ESC\-ENTER
"\eC\-xe": rlwrap\-call\-editor # CTRL\-x e
.fi
.PP
cf. the \fBreadline(3)\fP manpage
.SH ENVIRONMENT
.TP
\fBRLWRAP_HOME\fP:
directory in which the history and completion files are kept.
.TP
\fBRLWRAP_EDITOR\fP (or else \fBEDITOR\fP, or else \fBVISUAL\fP):
editor to use for multi\-line input. Example:
.PP
.nf
export RLWRAP_EDITOR="vi\ +%L"
export RLWRAP_EDITOR="vim\ '+call\ cursor(%L,%C)'"
.fi
.PP
The first example above is the default; %L and %C are replaced by
line and column numbers corresponding to the cursor position in
\fBrlwrap\fP's edit buffer
.TP
\fBRLWRAP_FILTERDIR\fP:
Any executable along your PATH can in theory
be used as a filter, but because filters have to follow a rather outlandish
protocol (cf. \fBRlwrapFilter (3)\fP) it is a good idea to keep them
separate. This is why \fBrlwrap\fP adds a special filter directory to $PATH just before launching a filter. By default, this is
@DATADIR@/rlwrap/filters, but $RLWRAP_FILTERDIR is used if set.
.SH SIGNALS
.PP
A number of signals are forwarded to \fIcommand\fP:
HUP INT QUIT USR1 USR2 TERM and (by way of resizing
\fIcommand\fP's terminal) WINCH. Some care is taken to handle
TSTP (usually a result of a CTRL\-Z from the terminal) sensibly \- for example, after suspending \fBrlwrap\fP in the middle of a line edit, continuing (by typing 'fg') will land you at the exact spot where you suspended it.
Filters that take more than 1 second to respond can be
interrupted by a CTRL\-C from the terminal (although \fBrlwrap\fP will not survive this)
If \fIcommand\fP changes the keystrokes that send a particular signal
from the keyboard (like emacs, which uses CTRL\-G instead of CTRL\-C)
\fBrlwrap\fP will do the same (but only after the next keystroke - use the
\fB\-\-polling\fP option to make rlwrap more transparent in this respect)
When \fIcommand\fP is killed by a signal, \fBrlwrap\fP will clean up,
reset its signal handlers an then commit suicide by sending the same
signal to itself. This means that your shell sees the same exit status as it
would have seen without \fBrlwrap\fP.
.SH REDIRECTION
When the standard input is not a terminal, editing input doesn't make
sense, so \fBrlwrap\fP will ignore all options and simply
execute \fIcommand\fP. When stdout (or stderr) is not a terminal, rlwrap will re\-open
it to /dev/tty (the users terminal) after it has started
\fIcommand\fP, so that \fIcommand\fP's output is redirected as
expected, but keyboard input and \fBrlwrap\fP error messages are still visible.
The upshot of this is that \fBrlwrap\fP \fIcommand\fP behaves more or
less like \fIcommand\fP when redirecting.
.SH EXIT STATUS
non\-zero after a \fBrlwrap\fP error, or else \fIcommand\fP's exit
status. \fBrlwrap\fP will always leave the terminal in a tidy state,
even after a crash.
.SH FILES
\fBrlwrap\fP expects its history and completion files in $RLWRAP_HOME, but uses .dotfiles in the user's
home directory if this variable is not set. This will quickly become messy if you use \fBrlwrap\fP for many different commands.
.TP
$RLWRAP_HOME/\fIcommand\fP_history, ~/.\fIcommand\fP_history
History for \fIcommand\fP
.TP
$RLWRAP_HOME/\fIcommand\fP_completions, ~/.\fIcommand\fP_completions
Per\-user completion word list for \fIcommand\fP. \fBrlwrap\fP never
writes into this list, but one can combine \fB\-l\fP and \fB\-f\fP
options to to simulate the effect of a \fB\-r\fP option that works
across invocations.
.TP
@DATADIR@/rlwrap/completions/\fIcommand\fP
System\-wide completion word list for \fIcommand\fP. This file is only
consulted if the per\-user completion word list is not found.
.TP
$INPUTRC, ~/.inputrc
Individual \fBreadline\fP initialisation file (See \fBreadline\fP (3) for
its format). \fBrlwrap\fP sets its \fIapplication name\fP to
\fIcommand\fP (this can be overridden by the \fB\-C\fP option), enabling different behaviours for different commands.
One could e.g. put the following lines in \fB~/.inputrc\fP:
.RS
.nf
.if t .ft CW
$if coqtop
set show\-all\-if\-ambiguous On
$endif
.if t .ft P
.fi
making \fBrlwrap\fP show all completions whenever it runs \fBcoqtop\fP
.SH BUGS and LIMITATIONS
Though it is flexible, delivers the goods (readline functionality), and adheres to the Unix
"many small tools" paradigm, \fBrlwrap\fP is a kludge. It cannot know anything about
\fIcommand\fP's internal state, which makes context\-sensitive completion
impossible. Using the readline library from within \fIcommand\fP is
still the best option.
Also, because "it takes two to tango" there is no way for \fBrlwrap\fP
to synchronise its internal state with \fIcommand\fP, resulting in a
number of subtle race conditions, where e.g. \fIcommand\fP may have
changed the state of its terminal before \fBrlwrap\fP has read
\fIcommand\fP output that was written before the state change. You
will notice these races especially on a busy machine and with heavy
"cooking" and filtering, when suddenly (and unpredictably) promtps or
command output are garbled or incorrectly coloured.
\fBrlwrap\fP can try, but often fails to, handle prompts that contain
control characters. A flter may be used to clean up the prompt.
.SH VERSION
This manpage documents rlwrap version @VERSION@
.SH AUTHORS
The readline library (written by Brian Fox and Chet Ramey) does all the hard work
behind the scenes, the pty\-handling code has been taken practically
unchanged from rxvt\-2.7.10 (currently maintained by Geoff C. Wing),
and completion word lists are managed by Damian Ivereigh's libredblack
library. The few remaining lines of code were written by Hans Lub
(hanslub42@gmail.com).
.SH SEE ALSO
.TP
.B readline(3), RlwrapFilter(3pm)
\" Local variables:
\" mode:nroff
\" End:
rlwrap-0.42/doc/Makefile.am 0000644 0001751 0000144 00000000232 12404151311 012452 0000000 0000000 man_MANS = rlwrap.1
# EXTRA_DIST = $(man_MANS)
CLEANFILES = $(man_MANS)
rlwrap.1: rlwrap.man
sed -e 's#@DATADIR@#$(datadir)#' rlwrap.man > rlwrap.1
rlwrap-0.42/doc/Makefile.in 0000644 0001751 0000144 00000034365 12431353234 012511 0000000 0000000 # Makefile.in generated by automake 1.14.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994-2013 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
am__make_running_with_option = \
case $${target_option-} in \
?) ;; \
*) echo "am__make_running_with_option: internal error: invalid" \
"target option '$${target_option-}' specified" >&2; \
exit 1;; \
esac; \
has_opt=no; \
sane_makeflags=$$MAKEFLAGS; \
if $(am__is_gnu_make); then \
sane_makeflags=$$MFLAGS; \
else \
case $$MAKEFLAGS in \
*\\[\ \ ]*) \
bs=\\; \
sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
| sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \
esac; \
fi; \
skip_next=no; \
strip_trailopt () \
{ \
flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
}; \
for flg in $$sane_makeflags; do \
test $$skip_next = yes && { skip_next=no; continue; }; \
case $$flg in \
*=*|--*) continue;; \
-*I) strip_trailopt 'I'; skip_next=yes;; \
-*I?*) strip_trailopt 'I';; \
-*O) strip_trailopt 'O'; skip_next=yes;; \
-*O?*) strip_trailopt 'O';; \
-*l) strip_trailopt 'l'; skip_next=yes;; \
-*l?*) strip_trailopt 'l';; \
-[dEDm]) skip_next=yes;; \
-[JT]) skip_next=yes;; \
esac; \
case $$flg in \
*$$target_option*) has_opt=yes; break;; \
esac; \
done; \
test $$has_opt = yes
am__make_dryrun = (target_option=n; $(am__make_running_with_option))
am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
subdir = doc
DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
$(srcdir)/rlwrap.man.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES = rlwrap.man
CONFIG_CLEAN_VPATH_FILES =
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
am__v_P_0 = false
am__v_P_1 = :
AM_V_GEN = $(am__v_GEN_@AM_V@)
am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
am__v_GEN_0 = @echo " GEN " $@;
am__v_GEN_1 =
AM_V_at = $(am__v_at_@AM_V@)
am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
am__v_at_0 = @
am__v_at_1 =
SOURCES =
DIST_SOURCES =
am__can_run_installinfo = \
case $$AM_UPDATE_INFO_DIR in \
n|no|NO) false;; \
*) (install-info --version) >/dev/null 2>&1;; \
esac
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
am__install_max = 40
am__nobase_strip_setup = \
srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
am__nobase_strip = \
for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
am__nobase_list = $(am__nobase_strip_setup); \
for p in $$list; do echo "$$p $$p"; done | \
sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
$(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
if (++n[$$2] == $(am__install_max)) \
{ print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
END { for (dir in files) print dir, files[dir] }'
am__base_list = \
sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
am__uninstall_files_from_dir = { \
test -z "$$files" \
|| { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
|| { echo " ( cd '$$dir' && rm -f" $$files ")"; \
$(am__cd) "$$dir" && rm -f $$files; }; \
}
man1dir = $(mandir)/man1
am__installdirs = "$(DESTDIR)$(man1dir)"
NROFF = nroff
MANS = $(man_MANS)
am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
GREP = @GREP@
HAVE_LONG_OPTS = @HAVE_LONG_OPTS@
HAVE_OPTIONAL_ARGS = @HAVE_OPTIONAL_ARGS@
HAVE_PROC_PID_CWD = @HAVE_PROC_PID_CWD@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LTLIBOBJS = @LTLIBOBJS@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
OBJEXT = @OBJEXT@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PERL = @PERL@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
man_MANS = rlwrap.1
# EXTRA_DIST = $(man_MANS)
CLEANFILES = $(man_MANS)
all: all-am
.SUFFIXES:
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu doc/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu doc/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
rlwrap.man: $(top_builddir)/config.status $(srcdir)/rlwrap.man.in
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@
install-man1: $(man_MANS)
@$(NORMAL_INSTALL)
@list1=''; \
list2='$(man_MANS)'; \
test -n "$(man1dir)" \
&& test -n "`echo $$list1$$list2`" \
|| exit 0; \
echo " $(MKDIR_P) '$(DESTDIR)$(man1dir)'"; \
$(MKDIR_P) "$(DESTDIR)$(man1dir)" || exit 1; \
{ for i in $$list1; do echo "$$i"; done; \
if test -n "$$list2"; then \
for i in $$list2; do echo "$$i"; done \
| sed -n '/\.1[a-z]*$$/p'; \
fi; \
} | while read p; do \
if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
echo "$$d$$p"; echo "$$p"; \
done | \
sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \
-e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \
sed 'N;N;s,\n, ,g' | { \
list=; while read file base inst; do \
if test "$$base" = "$$inst"; then list="$$list $$file"; else \
echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man1dir)/$$inst'"; \
$(INSTALL_DATA) "$$file" "$(DESTDIR)$(man1dir)/$$inst" || exit $$?; \
fi; \
done; \
for i in $$list; do echo "$$i"; done | $(am__base_list) | \
while read files; do \
test -z "$$files" || { \
echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man1dir)'"; \
$(INSTALL_DATA) $$files "$(DESTDIR)$(man1dir)" || exit $$?; }; \
done; }
uninstall-man1:
@$(NORMAL_UNINSTALL)
@list=''; test -n "$(man1dir)" || exit 0; \
files=`{ for i in $$list; do echo "$$i"; done; \
l2='$(man_MANS)'; for i in $$l2; do echo "$$i"; done | \
sed -n '/\.1[a-z]*$$/p'; \
} | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \
-e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \
dir='$(DESTDIR)$(man1dir)'; $(am__uninstall_files_from_dir)
tags TAGS:
ctags CTAGS:
cscope cscopelist:
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(MANS)
installdirs:
for dir in "$(DESTDIR)$(man1dir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
if test -z '$(STRIP)'; then \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
install; \
else \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
"INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
fi
mostlyclean-generic:
clean-generic:
-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-generic mostlyclean-am
distclean: distclean-am
-rm -f Makefile
distclean-am: clean-am distclean-generic
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am: install-man
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am:
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man: install-man1
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-generic
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-man
uninstall-man: uninstall-man1
.MAKE: install-am install-strip
.PHONY: all all-am check check-am clean clean-generic cscopelist-am \
ctags-am distclean distclean-generic distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am install-info \
install-info-am install-man install-man1 install-pdf \
install-pdf-am install-ps install-ps-am install-strip \
installcheck installcheck-am installdirs maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-generic pdf \
pdf-am ps ps-am tags-am uninstall uninstall-am uninstall-man \
uninstall-man1
rlwrap.1: rlwrap.man
sed -e 's#@DATADIR@#$(datadir)#' rlwrap.man > rlwrap.1
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
rlwrap-0.42/configure 0000755 0001751 0000144 00000717733 12431353233 011614 0000000 0000000 #! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.69 for rlwrap 0.42.
#
#
# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
#
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##
# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
# is contrary to our usage. Disable this feature.
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else
case `(set -o) 2>/dev/null` in #(
*posix*) :
set -o posix ;; #(
*) :
;;
esac
fi
as_nl='
'
export as_nl
# Printing a long string crashes Solaris 7 /usr/bin/printf.
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
&& (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
as_echo='print -r --'
as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
as_echo='printf %s\n'
as_echo_n='printf %s'
else
if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
as_echo_n='/usr/ucb/echo -n'
else
as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
as_echo_n_body='eval
arg=$1;
case $arg in #(
*"$as_nl"*)
expr "X$arg" : "X\\(.*\\)$as_nl";
arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
esac;
expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
'
export as_echo_n_body
as_echo_n='sh -c $as_echo_n_body as_echo'
fi
export as_echo_body
as_echo='sh -c $as_echo_body as_echo'
fi
# The user is always right.
if test "${PATH_SEPARATOR+set}" != set; then
PATH_SEPARATOR=:
(PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
(PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
PATH_SEPARATOR=';'
}
fi
# IFS
# We need space, tab and new line, in precisely that order. Quoting is
# there to prevent editors from complaining about space-tab.
# (If _AS_PATH_WALK were called with IFS unset, it would disable word
# splitting by setting IFS to empty value.)
IFS=" "" $as_nl"
# Find who we are. Look in the path if we contain no directory separator.
as_myself=
case $0 in #((
*[\\/]* ) as_myself=$0 ;;
*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
done
IFS=$as_save_IFS
;;
esac
# We did not find ourselves, most probably we were run as `sh COMMAND'
# in which case we are not to be found in the path.
if test "x$as_myself" = x; then
as_myself=$0
fi
if test ! -f "$as_myself"; then
$as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
exit 1
fi
# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there. '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
&& ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
PS4='+ '
# NLS nuisances.
LC_ALL=C
export LC_ALL
LANGUAGE=C
export LANGUAGE
# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
# Use a proper internal environment variable to ensure we don't fall
# into an infinite loop, continuously re-executing ourselves.
if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
_as_can_reexec=no; export _as_can_reexec;
# We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
*v*x* | *x*v* ) as_opts=-vx ;;
*v* ) as_opts=-v ;;
*x* ) as_opts=-x ;;
* ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
as_fn_exit 255
fi
# We don't want this to propagate to other subprocesses.
{ _as_can_reexec=; unset _as_can_reexec;}
if test "x$CONFIG_SHELL" = x; then
as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
# is contrary to our usage. Disable this feature.
alias -g '\${1+\"\$@\"}'='\"\$@\"'
setopt NO_GLOB_SUBST
else
case \`(set -o) 2>/dev/null\` in #(
*posix*) :
set -o posix ;; #(
*) :
;;
esac
fi
"
as_required="as_fn_return () { (exit \$1); }
as_fn_success () { as_fn_return 0; }
as_fn_failure () { as_fn_return 1; }
as_fn_ret_success () { return 0; }
as_fn_ret_failure () { return 1; }
exitcode=0
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
else
exitcode=1; echo positional parameters were not saved.
fi
test x\$exitcode = x0 || exit 1
test -x / || exit 1"
as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
test \$(( 1 + 1 )) = 2 || exit 1"
if (eval "$as_required") 2>/dev/null; then :
as_have_required=yes
else
as_have_required=no
fi
if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
as_found=:
case $as_dir in #(
/*)
for as_base in sh bash ksh sh5; do
# Try only shells that exist, to save several forks.
as_shell=$as_dir/$as_base
if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
{ $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
CONFIG_SHELL=$as_shell as_have_required=yes
if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
break 2
fi
fi
done;;
esac
as_found=false
done
$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
{ $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
CONFIG_SHELL=$SHELL as_have_required=yes
fi; }
IFS=$as_save_IFS
if test "x$CONFIG_SHELL" != x; then :
export CONFIG_SHELL
# We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
# Preserve -v and -x to the replacement shell.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
case $- in # ((((
*v*x* | *x*v* ) as_opts=-vx ;;
*v* ) as_opts=-v ;;
*x* ) as_opts=-x ;;
* ) as_opts= ;;
esac
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
# Admittedly, this is quite paranoid, since all the known shells bail
# out after a failed `exec'.
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
exit 255
fi
if test x$as_have_required = xno; then :
$as_echo "$0: This script requires a shell more modern than all"
$as_echo "$0: the shells that I found on your system."
if test x${ZSH_VERSION+set} = xset ; then
$as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
$as_echo "$0: be upgraded to zsh 4.3.4 or later."
else
$as_echo "$0: Please tell bug-autoconf@gnu.org about your system,
$0: including any error possibly output before this
$0: message. Then install a modern shell, or manually run
$0: the script under such a shell if you do have one."
fi
exit 1
fi
fi
fi
SHELL=${CONFIG_SHELL-/bin/sh}
export SHELL
# Unset more variables known to interfere with behavior of common tools.
CLICOLOR_FORCE= GREP_OPTIONS=
unset CLICOLOR_FORCE GREP_OPTIONS
## --------------------- ##
## M4sh Shell Functions. ##
## --------------------- ##
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
{ eval $1=; unset $1;}
}
as_unset=as_fn_unset
# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
return $1
} # as_fn_set_status
# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
set +e
as_fn_set_status $1
exit $1
} # as_fn_exit
# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{
case $as_dir in #(
-*) as_dir=./$as_dir;;
esac
test -d "$as_dir" || eval $as_mkdir_p || {
as_dirs=
while :; do
case $as_dir in #(
*\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
*) as_qdir=$as_dir;;
esac
as_dirs="'$as_qdir' $as_dirs"
as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
X"$as_dir" : 'X\(//\)[^/]' \| \
X"$as_dir" : 'X\(//\)$' \| \
X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
}
/^X\(\/\/\)[^/].*/{
s//\1/
q
}
/^X\(\/\/\)$/{
s//\1/
q
}
/^X\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
test -d "$as_dir" && break
done
test -z "$as_dirs" || eval "mkdir $as_dirs"
} || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
} # as_fn_mkdir_p
# as_fn_executable_p FILE
# -----------------------
# Test if FILE is an executable regular file.
as_fn_executable_p ()
{
test -f "$1" && test -x "$1"
} # as_fn_executable_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
eval 'as_fn_append ()
{
eval $1+=\$2
}'
else
as_fn_append ()
{
eval $1=\$$1\$2
}
fi # as_fn_append
# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
eval 'as_fn_arith ()
{
as_val=$(( $* ))
}'
else
as_fn_arith ()
{
as_val=`expr "$@" || test $? -eq 1`
}
fi # as_fn_arith
# as_fn_error STATUS ERROR [LINENO LOG_FD]
# ----------------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with STATUS, using 1 if that was 0.
as_fn_error ()
{
as_status=$1; test $as_status -eq 0 && as_status=1
if test "$4"; then
as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
$as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
fi
$as_echo "$as_me: error: $2" >&2
as_fn_exit $as_status
} # as_fn_error
if expr a : '\(a\)' >/dev/null 2>&1 &&
test "X`expr 00001 : '.*\(...\)'`" = X001; then
as_expr=expr
else
as_expr=false
fi
if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
as_basename=basename
else
as_basename=false
fi
if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
as_dirname=dirname
else
as_dirname=false
fi
as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
X"$0" : 'X\(//\)$' \| \
X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
sed '/^.*\/\([^/][^/]*\)\/*$/{
s//\1/
q
}
/^X\/\(\/\/\)$/{
s//\1/
q
}
/^X\/\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits
as_lineno_1=$LINENO as_lineno_1a=$LINENO
as_lineno_2=$LINENO as_lineno_2a=$LINENO
eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
# Blame Lee E. McMahon (1931-1989) for sed's syntax. :-)
sed -n '
p
/[$]LINENO/=
' <$as_myself |
sed '
s/[$]LINENO.*/&-/
t lineno
b
:lineno
N
:loop
s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
t loop
s/-\n.*//
' >$as_me.lineno &&
chmod +x "$as_me.lineno" ||
{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
# If we had to re-execute with $CONFIG_SHELL, we're ensured to have
# already done that, so ensure we don't try to do so again and fall
# in an infinite loop. This has already happened in practice.
_as_can_reexec=no; export _as_can_reexec
# Don't try to exec as it changes $[0], causing all sort of problems
# (the dirname of $[0] is not the place where we might find the
# original and so on. Autoconf is especially sensitive to this).
. "./$as_me.lineno"
# Exit status is that of the last command.
exit
}
ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in #(((((
-n*)
case `echo 'xy\c'` in
*c*) ECHO_T=' ';; # ECHO_T is single tab character.
xy) ECHO_C='\c';;
*) echo `echo ksh88 bug on AIX 6.1` > /dev/null
ECHO_T=' ';;
esac;;
*)
ECHO_N='-n';;
esac
rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
rm -f conf$$.dir/conf$$.file
else
rm -f conf$$.dir
mkdir conf$$.dir 2>/dev/null
fi
if (echo >conf$$.file) 2>/dev/null; then
if ln -s conf$$.file conf$$ 2>/dev/null; then
as_ln_s='ln -s'
# ... but there are two gotchas:
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
# In both cases, we have to default to `cp -pR'.
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
as_ln_s='cp -pR'
elif ln conf$$.file conf$$ 2>/dev/null; then
as_ln_s=ln
else
as_ln_s='cp -pR'
fi
else
as_ln_s='cp -pR'
fi
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null
if mkdir -p . 2>/dev/null; then
as_mkdir_p='mkdir -p "$as_dir"'
else
test -d ./-p && rmdir ./-p
as_mkdir_p=false
fi
as_test_x='test -x'
as_executable_p=as_fn_executable_p
# Sed expression to map a string onto a valid CPP name.
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
# Sed expression to map a string onto a valid variable name.
as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
test -n "$DJDIR" || exec 7<&0 &1
# Name of the host.
# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
# so uname gets run too.
ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
#
# Initializations.
#
ac_default_prefix=/usr/local
ac_clean_files=
ac_config_libobj_dir=.
LIBOBJS=
cross_compiling=no
subdirs=
MFLAGS=
MAKEFLAGS=
# Identity of this package.
PACKAGE_NAME='rlwrap'
PACKAGE_TARNAME='rlwrap'
PACKAGE_VERSION='0.42'
PACKAGE_STRING='rlwrap 0.42'
PACKAGE_BUGREPORT=''
PACKAGE_URL=''
ac_unique_file="src/main.c"
# Factoring default headers for most tests.
ac_includes_default="\
#include
#ifdef HAVE_SYS_TYPES_H
# include
#endif
#ifdef HAVE_SYS_STAT_H
# include
#endif
#ifdef STDC_HEADERS
# include
# include
#else
# ifdef HAVE_STDLIB_H
# include
# endif
#endif
#ifdef HAVE_STRING_H
# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
# include
# endif
# include
#endif
#ifdef HAVE_STRINGS_H
# include
#endif
#ifdef HAVE_INTTYPES_H
# include
#endif
#ifdef HAVE_STDINT_H
# include
#endif
#ifdef HAVE_UNISTD_H
# include
#endif"
ac_subst_vars='am__EXEEXT_FALSE
am__EXEEXT_TRUE
LTLIBOBJS
LIBOBJS
HAVE_PROC_PID_CWD
HAVE_LONG_OPTS
HAVE_OPTIONAL_ARGS
PERL
EGREP
GREP
CPP
am__fastdepCC_FALSE
am__fastdepCC_TRUE
CCDEPMODE
am__nodep
AMDEPBACKSLASH
AMDEP_FALSE
AMDEP_TRUE
am__quote
am__include
DEPDIR
OBJEXT
EXEEXT
ac_ct_CC
CPPFLAGS
LDFLAGS
CC
CFLAGS
AM_BACKSLASH
AM_DEFAULT_VERBOSITY
AM_DEFAULT_V
AM_V
am__untar
am__tar
AMTAR
am__leading_dot
SET_MAKE
AWK
mkdir_p
MKDIR_P
INSTALL_STRIP_PROGRAM
STRIP
install_sh
MAKEINFO
AUTOHEADER
AUTOMAKE
AUTOCONF
ACLOCAL
VERSION
PACKAGE
CYGPATH_W
am__isrc
INSTALL_DATA
INSTALL_SCRIPT
INSTALL_PROGRAM
host_os
host_vendor
host_cpu
host
build_os
build_vendor
build_cpu
build
target_alias
host_alias
build_alias
LIBS
ECHO_T
ECHO_N
ECHO_C
DEFS
mandir
localedir
libdir
psdir
pdfdir
dvidir
htmldir
infodir
docdir
oldincludedir
includedir
localstatedir
sharedstatedir
sysconfdir
datadir
datarootdir
libexecdir
sbindir
bindir
program_transform_name
prefix
exec_prefix
PACKAGE_URL
PACKAGE_BUGREPORT
PACKAGE_STRING
PACKAGE_VERSION
PACKAGE_TARNAME
PACKAGE_NAME
PATH_SEPARATOR
SHELL'
ac_subst_files=''
ac_user_opts='
enable_option_checking
enable_silent_rules
enable_debug
enable_homegrown_redisplay
enable_spy_on_readline
enable_proc_mountpoint
enable_dependency_tracking
'
ac_precious_vars='build_alias
host_alias
target_alias
CC
CFLAGS
LDFLAGS
LIBS
CPPFLAGS
CPP'
# Initialize some variables set by options.
ac_init_help=
ac_init_version=false
ac_unrecognized_opts=
ac_unrecognized_sep=
# The variables have the same names as the options, with
# dashes changed to underlines.
cache_file=/dev/null
exec_prefix=NONE
no_create=
no_recursion=
prefix=NONE
program_prefix=NONE
program_suffix=NONE
program_transform_name=s,x,x,
silent=
site=
srcdir=
verbose=
x_includes=NONE
x_libraries=NONE
# Installation directory options.
# These are left unexpanded so users can "make install exec_prefix=/foo"
# and all the variables that are supposed to be based on exec_prefix
# by default will actually change.
# Use braces instead of parens because sh, perl, etc. also accept them.
# (The list follows the same order as the GNU Coding Standards.)
bindir='${exec_prefix}/bin'
sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datarootdir='${prefix}/share'
datadir='${datarootdir}'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
includedir='${prefix}/include'
oldincludedir='/usr/include'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
infodir='${datarootdir}/info'
htmldir='${docdir}'
dvidir='${docdir}'
pdfdir='${docdir}'
psdir='${docdir}'
libdir='${exec_prefix}/lib'
localedir='${datarootdir}/locale'
mandir='${datarootdir}/man'
ac_prev=
ac_dashdash=
for ac_option
do
# If the previous option needs an argument, assign it.
if test -n "$ac_prev"; then
eval $ac_prev=\$ac_option
ac_prev=
continue
fi
case $ac_option in
*=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
*=) ac_optarg= ;;
*) ac_optarg=yes ;;
esac
# Accept the important Cygnus configure options, so we can diagnose typos.
case $ac_dashdash$ac_option in
--)
ac_dashdash=yes ;;
-bindir | --bindir | --bindi | --bind | --bin | --bi)
ac_prev=bindir ;;
-bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
bindir=$ac_optarg ;;
-build | --build | --buil | --bui | --bu)
ac_prev=build_alias ;;
-build=* | --build=* | --buil=* | --bui=* | --bu=*)
build_alias=$ac_optarg ;;
-cache-file | --cache-file | --cache-fil | --cache-fi \
| --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
ac_prev=cache_file ;;
-cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
| --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
cache_file=$ac_optarg ;;
--config-cache | -C)
cache_file=config.cache ;;
-datadir | --datadir | --datadi | --datad)
ac_prev=datadir ;;
-datadir=* | --datadir=* | --datadi=* | --datad=*)
datadir=$ac_optarg ;;
-datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
| --dataroo | --dataro | --datar)
ac_prev=datarootdir ;;
-datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
| --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
datarootdir=$ac_optarg ;;
-disable-* | --disable-*)
ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid feature name: $ac_useropt"
ac_useropt_orig=$ac_useropt
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"enable_$ac_useropt"
"*) ;;
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
ac_unrecognized_sep=', ';;
esac
eval enable_$ac_useropt=no ;;
-docdir | --docdir | --docdi | --doc | --do)
ac_prev=docdir ;;
-docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
docdir=$ac_optarg ;;
-dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
ac_prev=dvidir ;;
-dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
dvidir=$ac_optarg ;;
-enable-* | --enable-*)
ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid feature name: $ac_useropt"
ac_useropt_orig=$ac_useropt
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"enable_$ac_useropt"
"*) ;;
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
ac_unrecognized_sep=', ';;
esac
eval enable_$ac_useropt=\$ac_optarg ;;
-exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
| --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
| --exec | --exe | --ex)
ac_prev=exec_prefix ;;
-exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
| --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
| --exec=* | --exe=* | --ex=*)
exec_prefix=$ac_optarg ;;
-gas | --gas | --ga | --g)
# Obsolete; use --with-gas.
with_gas=yes ;;
-help | --help | --hel | --he | -h)
ac_init_help=long ;;
-help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
ac_init_help=recursive ;;
-help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
ac_init_help=short ;;
-host | --host | --hos | --ho)
ac_prev=host_alias ;;
-host=* | --host=* | --hos=* | --ho=*)
host_alias=$ac_optarg ;;
-htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
ac_prev=htmldir ;;
-htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
| --ht=*)
htmldir=$ac_optarg ;;
-includedir | --includedir | --includedi | --included | --include \
| --includ | --inclu | --incl | --inc)
ac_prev=includedir ;;
-includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
| --includ=* | --inclu=* | --incl=* | --inc=*)
includedir=$ac_optarg ;;
-infodir | --infodir | --infodi | --infod | --info | --inf)
ac_prev=infodir ;;
-infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
infodir=$ac_optarg ;;
-libdir | --libdir | --libdi | --libd)
ac_prev=libdir ;;
-libdir=* | --libdir=* | --libdi=* | --libd=*)
libdir=$ac_optarg ;;
-libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
| --libexe | --libex | --libe)
ac_prev=libexecdir ;;
-libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
| --libexe=* | --libex=* | --libe=*)
libexecdir=$ac_optarg ;;
-localedir | --localedir | --localedi | --localed | --locale)
ac_prev=localedir ;;
-localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
localedir=$ac_optarg ;;
-localstatedir | --localstatedir | --localstatedi | --localstated \
| --localstate | --localstat | --localsta | --localst | --locals)
ac_prev=localstatedir ;;
-localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
| --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
localstatedir=$ac_optarg ;;
-mandir | --mandir | --mandi | --mand | --man | --ma | --m)
ac_prev=mandir ;;
-mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
mandir=$ac_optarg ;;
-nfp | --nfp | --nf)
# Obsolete; use --without-fp.
with_fp=no ;;
-no-create | --no-create | --no-creat | --no-crea | --no-cre \
| --no-cr | --no-c | -n)
no_create=yes ;;
-no-recursion | --no-recursion | --no-recursio | --no-recursi \
| --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
no_recursion=yes ;;
-oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
| --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
| --oldin | --oldi | --old | --ol | --o)
ac_prev=oldincludedir ;;
-oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
| --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
| --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
oldincludedir=$ac_optarg ;;
-prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
ac_prev=prefix ;;
-prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
prefix=$ac_optarg ;;
-program-prefix | --program-prefix | --program-prefi | --program-pref \
| --program-pre | --program-pr | --program-p)
ac_prev=program_prefix ;;
-program-prefix=* | --program-prefix=* | --program-prefi=* \
| --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
program_prefix=$ac_optarg ;;
-program-suffix | --program-suffix | --program-suffi | --program-suff \
| --program-suf | --program-su | --program-s)
ac_prev=program_suffix ;;
-program-suffix=* | --program-suffix=* | --program-suffi=* \
| --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
program_suffix=$ac_optarg ;;
-program-transform-name | --program-transform-name \
| --program-transform-nam | --program-transform-na \
| --program-transform-n | --program-transform- \
| --program-transform | --program-transfor \
| --program-transfo | --program-transf \
| --program-trans | --program-tran \
| --progr-tra | --program-tr | --program-t)
ac_prev=program_transform_name ;;
-program-transform-name=* | --program-transform-name=* \
| --program-transform-nam=* | --program-transform-na=* \
| --program-transform-n=* | --program-transform-=* \
| --program-transform=* | --program-transfor=* \
| --program-transfo=* | --program-transf=* \
| --program-trans=* | --program-tran=* \
| --progr-tra=* | --program-tr=* | --program-t=*)
program_transform_name=$ac_optarg ;;
-pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
ac_prev=pdfdir ;;
-pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
pdfdir=$ac_optarg ;;
-psdir | --psdir | --psdi | --psd | --ps)
ac_prev=psdir ;;
-psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
psdir=$ac_optarg ;;
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
| -silent | --silent | --silen | --sile | --sil)
silent=yes ;;
-sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
ac_prev=sbindir ;;
-sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
| --sbi=* | --sb=*)
sbindir=$ac_optarg ;;
-sharedstatedir | --sharedstatedir | --sharedstatedi \
| --sharedstated | --sharedstate | --sharedstat | --sharedsta \
| --sharedst | --shareds | --shared | --share | --shar \
| --sha | --sh)
ac_prev=sharedstatedir ;;
-sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
| --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
| --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
| --sha=* | --sh=*)
sharedstatedir=$ac_optarg ;;
-site | --site | --sit)
ac_prev=site ;;
-site=* | --site=* | --sit=*)
site=$ac_optarg ;;
-srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
ac_prev=srcdir ;;
-srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
srcdir=$ac_optarg ;;
-sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
| --syscon | --sysco | --sysc | --sys | --sy)
ac_prev=sysconfdir ;;
-sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
| --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
sysconfdir=$ac_optarg ;;
-target | --target | --targe | --targ | --tar | --ta | --t)
ac_prev=target_alias ;;
-target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
target_alias=$ac_optarg ;;
-v | -verbose | --verbose | --verbos | --verbo | --verb)
verbose=yes ;;
-version | --version | --versio | --versi | --vers | -V)
ac_init_version=: ;;
-with-* | --with-*)
ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid package name: $ac_useropt"
ac_useropt_orig=$ac_useropt
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"with_$ac_useropt"
"*) ;;
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
ac_unrecognized_sep=', ';;
esac
eval with_$ac_useropt=\$ac_optarg ;;
-without-* | --without-*)
ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
as_fn_error $? "invalid package name: $ac_useropt"
ac_useropt_orig=$ac_useropt
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
*"
"with_$ac_useropt"
"*) ;;
*) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
ac_unrecognized_sep=', ';;
esac
eval with_$ac_useropt=no ;;
--x)
# Obsolete; use --with-x.
with_x=yes ;;
-x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
| --x-incl | --x-inc | --x-in | --x-i)
ac_prev=x_includes ;;
-x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
| --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
x_includes=$ac_optarg ;;
-x-libraries | --x-libraries | --x-librarie | --x-librari \
| --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
ac_prev=x_libraries ;;
-x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
| --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
x_libraries=$ac_optarg ;;
-*) as_fn_error $? "unrecognized option: \`$ac_option'
Try \`$0 --help' for more information"
;;
*=*)
ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
# Reject names that are not valid shell variable names.
case $ac_envvar in #(
'' | [0-9]* | *[!_$as_cr_alnum]* )
as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
esac
eval $ac_envvar=\$ac_optarg
export $ac_envvar ;;
*)
# FIXME: should be removed in autoconf 3.0.
$as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
$as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
: "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
;;
esac
done
if test -n "$ac_prev"; then
ac_option=--`echo $ac_prev | sed 's/_/-/g'`
as_fn_error $? "missing argument to $ac_option"
fi
if test -n "$ac_unrecognized_opts"; then
case $enable_option_checking in
no) ;;
fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
*) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
esac
fi
# Check all directory arguments for consistency.
for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \
datadir sysconfdir sharedstatedir localstatedir includedir \
oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
libdir localedir mandir
do
eval ac_val=\$$ac_var
# Remove trailing slashes.
case $ac_val in
*/ )
ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
eval $ac_var=\$ac_val;;
esac
# Be sure to have absolute directory names.
case $ac_val in
[\\/$]* | ?:[\\/]* ) continue;;
NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
esac
as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
done
# There might be people who depend on the old broken behavior: `$host'
# used to hold the argument of --host etc.
# FIXME: To remove some day.
build=$build_alias
host=$host_alias
target=$target_alias
# FIXME: To remove some day.
if test "x$host_alias" != x; then
if test "x$build_alias" = x; then
cross_compiling=maybe
elif test "x$build_alias" != "x$host_alias"; then
cross_compiling=yes
fi
fi
ac_tool_prefix=
test -n "$host_alias" && ac_tool_prefix=$host_alias-
test "$silent" = yes && exec 6>/dev/null
ac_pwd=`pwd` && test -n "$ac_pwd" &&
ac_ls_di=`ls -di .` &&
ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
as_fn_error $? "working directory cannot be determined"
test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
as_fn_error $? "pwd does not report name of working directory"
# Find the source files, if location was not specified.
if test -z "$srcdir"; then
ac_srcdir_defaulted=yes
# Try the directory containing this script, then the parent directory.
ac_confdir=`$as_dirname -- "$as_myself" ||
$as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
X"$as_myself" : 'X\(//\)[^/]' \| \
X"$as_myself" : 'X\(//\)$' \| \
X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_myself" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
}
/^X\(\/\/\)[^/].*/{
s//\1/
q
}
/^X\(\/\/\)$/{
s//\1/
q
}
/^X\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
srcdir=$ac_confdir
if test ! -r "$srcdir/$ac_unique_file"; then
srcdir=..
fi
else
ac_srcdir_defaulted=no
fi
if test ! -r "$srcdir/$ac_unique_file"; then
test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
fi
ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
ac_abs_confdir=`(
cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
pwd)`
# When building in place, set srcdir=.
if test "$ac_abs_confdir" = "$ac_pwd"; then
srcdir=.
fi
# Remove unnecessary trailing slashes from srcdir.
# Double slashes in file names in object file debugging info
# mess up M-x gdb in Emacs.
case $srcdir in
*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
esac
for ac_var in $ac_precious_vars; do
eval ac_env_${ac_var}_set=\${${ac_var}+set}
eval ac_env_${ac_var}_value=\$${ac_var}
eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
eval ac_cv_env_${ac_var}_value=\$${ac_var}
done
#
# Report the --help message.
#
if test "$ac_init_help" = "long"; then
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
\`configure' configures rlwrap 0.42 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
To assign environment variables (e.g., CC, CFLAGS...), specify them as
VAR=VALUE. See below for descriptions of some of the useful variables.
Defaults for the options are specified in brackets.
Configuration:
-h, --help display this help and exit
--help=short display options specific to this package
--help=recursive display the short help of all the included packages
-V, --version display version information and exit
-q, --quiet, --silent do not print \`checking ...' messages
--cache-file=FILE cache test results in FILE [disabled]
-C, --config-cache alias for \`--cache-file=config.cache'
-n, --no-create do not create output files
--srcdir=DIR find the sources in DIR [configure dir or \`..']
Installation directories:
--prefix=PREFIX install architecture-independent files in PREFIX
[$ac_default_prefix]
--exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
[PREFIX]
By default, \`make install' will install all the files in
\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify
an installation prefix other than \`$ac_default_prefix' using \`--prefix',
for instance \`--prefix=\$HOME'.
For better control, use the options below.
Fine tuning of the installation directories:
--bindir=DIR user executables [EPREFIX/bin]
--sbindir=DIR system admin executables [EPREFIX/sbin]
--libexecdir=DIR program executables [EPREFIX/libexec]
--sysconfdir=DIR read-only single-machine data [PREFIX/etc]
--sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]
--localstatedir=DIR modifiable single-machine data [PREFIX/var]
--libdir=DIR object code libraries [EPREFIX/lib]
--includedir=DIR C header files [PREFIX/include]
--oldincludedir=DIR C header files for non-gcc [/usr/include]
--datarootdir=DIR read-only arch.-independent data root [PREFIX/share]
--datadir=DIR read-only architecture-independent data [DATAROOTDIR]
--infodir=DIR info documentation [DATAROOTDIR/info]
--localedir=DIR locale-dependent data [DATAROOTDIR/locale]
--mandir=DIR man documentation [DATAROOTDIR/man]
--docdir=DIR documentation root [DATAROOTDIR/doc/rlwrap]
--htmldir=DIR html documentation [DOCDIR]
--dvidir=DIR dvi documentation [DOCDIR]
--pdfdir=DIR pdf documentation [DOCDIR]
--psdir=DIR ps documentation [DOCDIR]
_ACEOF
cat <<\_ACEOF
Program names:
--program-prefix=PREFIX prepend PREFIX to installed program names
--program-suffix=SUFFIX append SUFFIX to installed program names
--program-transform-name=PROGRAM run sed PROGRAM on installed program names
System types:
--build=BUILD configure for building on BUILD [guessed]
--host=HOST cross-compile to build programs to run on HOST [BUILD]
_ACEOF
fi
if test -n "$ac_init_help"; then
case $ac_init_help in
short | recursive ) echo "Configuration of rlwrap 0.42:";;
esac
cat <<\_ACEOF
Optional Features:
--disable-option-checking ignore unrecognized --enable/--with options
--disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
--enable-FEATURE[=ARG] include FEATURE [ARG=yes]
--enable-silent-rules less verbose build output (undo: "make V=1")
--disable-silent-rules verbose build output (undo: "make V=0")
--enable-debug enable debugging [[default=NO]]
--enable-homegrown-redisplay
try this only if rlwrap messes up the prompt
[[default=NO]]
--enable-spy-on-readline default=YES
use private readline variable to keep screen tidy
when resizing terminal [[default=YES]]
--enable-proc-mountpoint default=/proc
specify mountpoint for Linux-style procfs (used for
determination of command's PWD) [[default=/proc]]
--enable-dependency-tracking
do not reject slow dependency extractors
--disable-dependency-tracking
speeds up one-time build
Some influential environment variables:
CC C compiler command
CFLAGS C compiler flags
LDFLAGS linker flags, e.g. -L if you have libraries in a
nonstandard directory
LIBS libraries to pass to the linker, e.g. -l
CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if
you have headers in a nonstandard directory
CPP C preprocessor
Use these variables to override the choices made by `configure' or to help
it to find libraries and programs with nonstandard names/locations.
Report bugs to the package provider.
_ACEOF
ac_status=$?
fi
if test "$ac_init_help" = "recursive"; then
# If there are subdirs, report their specific --help.
for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
test -d "$ac_dir" ||
{ cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
continue
ac_builddir=.
case "$ac_dir" in
.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
*)
ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
# A ".." for each directory in $ac_dir_suffix.
ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
case $ac_top_builddir_sub in
"") ac_top_builddir_sub=. ac_top_build_prefix= ;;
*) ac_top_build_prefix=$ac_top_builddir_sub/ ;;
esac ;;
esac
ac_abs_top_builddir=$ac_pwd
ac_abs_builddir=$ac_pwd$ac_dir_suffix
# for backward compatibility:
ac_top_builddir=$ac_top_build_prefix
case $srcdir in
.) # We are building in place.
ac_srcdir=.
ac_top_srcdir=$ac_top_builddir_sub
ac_abs_top_srcdir=$ac_pwd ;;
[\\/]* | ?:[\\/]* ) # Absolute name.
ac_srcdir=$srcdir$ac_dir_suffix;
ac_top_srcdir=$srcdir
ac_abs_top_srcdir=$srcdir ;;
*) # Relative name.
ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
ac_top_srcdir=$ac_top_build_prefix$srcdir
ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
esac
ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
cd "$ac_dir" || { ac_status=$?; continue; }
# Check for guested configure.
if test -f "$ac_srcdir/configure.gnu"; then
echo &&
$SHELL "$ac_srcdir/configure.gnu" --help=recursive
elif test -f "$ac_srcdir/configure"; then
echo &&
$SHELL "$ac_srcdir/configure" --help=recursive
else
$as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
fi || ac_status=$?
cd "$ac_pwd" || { ac_status=$?; break; }
done
fi
test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
cat <<\_ACEOF
rlwrap configure 0.42
generated by GNU Autoconf 2.69
Copyright (C) 2012 Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it.
_ACEOF
exit
fi
## ------------------------ ##
## Autoconf initialization. ##
## ------------------------ ##
# ac_fn_c_try_compile LINENO
# --------------------------
# Try to compile conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_compile ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
rm -f conftest.$ac_objext
if { { ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_compile") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
grep -v '^ *+' conftest.err >conftest.er1
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then :
ac_retval=0
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=1
fi
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
as_fn_set_status $ac_retval
} # ac_fn_c_try_compile
# ac_fn_c_try_cpp LINENO
# ----------------------
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_cpp ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
if { { ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
grep -v '^ *+' conftest.err >conftest.er1
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } > conftest.i && {
test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
test ! -s conftest.err
}; then :
ac_retval=0
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=1
fi
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
as_fn_set_status $ac_retval
} # ac_fn_c_try_cpp
# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists, giving a warning if it cannot be compiled using
# the include files in INCLUDES and setting the cache variable VAR
# accordingly.
ac_fn_c_check_header_mongrel ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
if eval \${$3+:} false; then :
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
$as_echo_n "(cached) " >&6
fi
eval ac_res=\$$3
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
else
# Is the header compilable?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
$as_echo_n "checking $2 usability... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_header_compiler=yes
else
ac_header_compiler=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
$as_echo "$ac_header_compiler" >&6; }
# Is the header present?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
$as_echo_n "checking $2 presence... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <$2>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
ac_header_preproc=yes
else
ac_header_preproc=no
fi
rm -f conftest.err conftest.i conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
$as_echo "$ac_header_preproc" >&6; }
# So? What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
yes:no: )
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
;;
no:yes:* )
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5
$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5
$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
;;
esac
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
$as_echo_n "(cached) " >&6
else
eval "$3=\$ac_header_compiler"
fi
eval ac_res=\$$3
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
fi
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_header_mongrel
# ac_fn_c_try_run LINENO
# ----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
# that executables *can* be run.
ac_fn_c_try_run ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
if { { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
{ { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; }; then :
ac_retval=0
else
$as_echo "$as_me: program exited with status $ac_status" >&5
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=$ac_status
fi
rm -rf conftest.dSYM conftest_ipa8_conftest.oo
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
as_fn_set_status $ac_retval
} # ac_fn_c_try_run
# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists and can be compiled using the include files in
# INCLUDES, setting the cache variable VAR accordingly.
ac_fn_c_check_header_compile ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
eval "$3=yes"
else
eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
eval ac_res=\$$3
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_header_compile
# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
# -------------------------------------------
# Tests whether TYPE exists after having included INCLUDES, setting cache
# variable VAR accordingly.
ac_fn_c_check_type ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
$as_echo_n "(cached) " >&6
else
eval "$3=no"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
int
main ()
{
if (sizeof ($2))
return 0;
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
int
main ()
{
if (sizeof (($2)))
return 0;
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
else
eval "$3=yes"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
eval ac_res=\$$3
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_type
# ac_fn_c_try_link LINENO
# -----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_link ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
rm -f conftest.$ac_objext conftest$ac_exeext
if { { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
grep -v '^ *+' conftest.err >conftest.er1
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
test -x conftest$ac_exeext
}; then :
ac_retval=0
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=1
fi
# Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
# created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
# interfere with the next link command; also delete a directory that is
# left behind by Apple's compiler. We do this before executing the actions.
rm -rf conftest.dSYM conftest_ipa8_conftest.oo
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
as_fn_set_status $ac_retval
} # ac_fn_c_try_link
# ac_fn_c_check_func LINENO FUNC VAR
# ----------------------------------
# Tests whether FUNC exists, setting the cache variable VAR accordingly
ac_fn_c_check_func ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Define $2 to an innocuous variant, in case declares $2.
For example, HP-UX 11i declares gettimeofday. */
#define $2 innocuous_$2
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $2 (); below.
Prefer to if __STDC__ is defined, since
exists even on freestanding compilers. */
#ifdef __STDC__
# include
#else
# include
#endif
#undef $2
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
#ifdef __cplusplus
extern "C"
#endif
char $2 ();
/* The GNU C library defines this for functions which it implements
to always fail with ENOSYS. Some functions are actually named
something starting with __ and the normal name is an alias. */
#if defined __stub_$2 || defined __stub___$2
choke me
#endif
int
main ()
{
return $2 ();
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
eval "$3=yes"
else
eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
fi
eval ac_res=\$$3
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
} # ac_fn_c_check_func
cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
It was created by rlwrap $as_me 0.42, which was
generated by GNU Autoconf 2.69. Invocation command line was
$ $0 $@
_ACEOF
exec 5>>config.log
{
cat <<_ASUNAME
## --------- ##
## Platform. ##
## --------- ##
hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
uname -m = `(uname -m) 2>/dev/null || echo unknown`
uname -r = `(uname -r) 2>/dev/null || echo unknown`
uname -s = `(uname -s) 2>/dev/null || echo unknown`
uname -v = `(uname -v) 2>/dev/null || echo unknown`
/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
/bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`
/bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`
/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`
/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
/usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown`
/bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`
/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`
/bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`
_ASUNAME
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
$as_echo "PATH: $as_dir"
done
IFS=$as_save_IFS
} >&5
cat >&5 <<_ACEOF
## ----------- ##
## Core tests. ##
## ----------- ##
_ACEOF
# Keep a trace of the command line.
# Strip out --no-create and --no-recursion so they do not pile up.
# Strip out --silent because we don't want to record it for future runs.
# Also quote any args containing shell meta-characters.
# Make two passes to allow for proper duplicate-argument suppression.
ac_configure_args=
ac_configure_args0=
ac_configure_args1=
ac_must_keep_next=false
for ac_pass in 1 2
do
for ac_arg
do
case $ac_arg in
-no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
| -silent | --silent | --silen | --sile | --sil)
continue ;;
*\'*)
ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
esac
case $ac_pass in
1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2)
as_fn_append ac_configure_args1 " '$ac_arg'"
if test $ac_must_keep_next = true; then
ac_must_keep_next=false # Got value, back to normal.
else
case $ac_arg in
*=* | --config-cache | -C | -disable-* | --disable-* \
| -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
| -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
| -with-* | --with-* | -without-* | --without-* | --x)
case "$ac_configure_args0 " in
"$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
esac
;;
-* ) ac_must_keep_next=true ;;
esac
fi
as_fn_append ac_configure_args " '$ac_arg'"
;;
esac
done
done
{ ac_configure_args0=; unset ac_configure_args0;}
{ ac_configure_args1=; unset ac_configure_args1;}
# When interrupted or exit'd, cleanup temporary files, and complete
# config.log. We remove comments because anyway the quotes in there
# would cause problems or look ugly.
# WARNING: Use '\'' to represent an apostrophe within the trap.
# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
trap 'exit_status=$?
# Save into config.log some information that might help in debugging.
{
echo
$as_echo "## ---------------- ##
## Cache variables. ##
## ---------------- ##"
echo
# The following way of writing the cache mishandles newlines in values,
(
for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
eval ac_val=\$$ac_var
case $ac_val in #(
*${as_nl}*)
case $ac_var in #(
*_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
esac
case $ac_var in #(
_ | IFS | as_nl) ;; #(
BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
*) { eval $ac_var=; unset $ac_var;} ;;
esac ;;
esac
done
(set) 2>&1 |
case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
*${as_nl}ac_space=\ *)
sed -n \
"s/'\''/'\''\\\\'\'''\''/g;
s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
;; #(
*)
sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
;;
esac |
sort
)
echo
$as_echo "## ----------------- ##
## Output variables. ##
## ----------------- ##"
echo
for ac_var in $ac_subst_vars
do
eval ac_val=\$$ac_var
case $ac_val in
*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
esac
$as_echo "$ac_var='\''$ac_val'\''"
done | sort
echo
if test -n "$ac_subst_files"; then
$as_echo "## ------------------- ##
## File substitutions. ##
## ------------------- ##"
echo
for ac_var in $ac_subst_files
do
eval ac_val=\$$ac_var
case $ac_val in
*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
esac
$as_echo "$ac_var='\''$ac_val'\''"
done | sort
echo
fi
if test -s confdefs.h; then
$as_echo "## ----------- ##
## confdefs.h. ##
## ----------- ##"
echo
cat confdefs.h
echo
fi
test "$ac_signal" != 0 &&
$as_echo "$as_me: caught signal $ac_signal"
$as_echo "$as_me: exit $exit_status"
} >&5
rm -f core *.core core.conftest.* &&
rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
exit $exit_status
' 0
for ac_signal in 1 2 13 15; do
trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
done
ac_signal=0
# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -f -r conftest* confdefs.h
$as_echo "/* confdefs.h */" > confdefs.h
# Predefined preprocessor variables.
cat >>confdefs.h <<_ACEOF
#define PACKAGE_NAME "$PACKAGE_NAME"
_ACEOF
cat >>confdefs.h <<_ACEOF
#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
_ACEOF
cat >>confdefs.h <<_ACEOF
#define PACKAGE_VERSION "$PACKAGE_VERSION"
_ACEOF
cat >>confdefs.h <<_ACEOF
#define PACKAGE_STRING "$PACKAGE_STRING"
_ACEOF
cat >>confdefs.h <<_ACEOF
#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
_ACEOF
cat >>confdefs.h <<_ACEOF
#define PACKAGE_URL "$PACKAGE_URL"
_ACEOF
# Let the site file select an alternate cache file if it wants to.
# Prefer an explicitly selected file to automatically selected ones.
ac_site_file1=NONE
ac_site_file2=NONE
if test -n "$CONFIG_SITE"; then
# We do not want a PATH search for config.site.
case $CONFIG_SITE in #((
-*) ac_site_file1=./$CONFIG_SITE;;
*/*) ac_site_file1=$CONFIG_SITE;;
*) ac_site_file1=./$CONFIG_SITE;;
esac
elif test "x$prefix" != xNONE; then
ac_site_file1=$prefix/share/config.site
ac_site_file2=$prefix/etc/config.site
else
ac_site_file1=$ac_default_prefix/share/config.site
ac_site_file2=$ac_default_prefix/etc/config.site
fi
for ac_site_file in "$ac_site_file1" "$ac_site_file2"
do
test "x$ac_site_file" = xNONE && continue
if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
$as_echo "$as_me: loading site script $ac_site_file" >&6;}
sed 's/^/| /' "$ac_site_file" >&5
. "$ac_site_file" \
|| { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "failed to load site script $ac_site_file
See \`config.log' for more details" "$LINENO" 5; }
fi
done
if test -r "$cache_file"; then
# Some versions of bash will fail to source /dev/null (special files
# actually), so we avoid doing that. DJGPP emulates it as a regular file.
if test /dev/null != "$cache_file" && test -f "$cache_file"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
$as_echo "$as_me: loading cache $cache_file" >&6;}
case $cache_file in
[\\/]* | ?:[\\/]* ) . "$cache_file";;
*) . "./$cache_file";;
esac
fi
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
$as_echo "$as_me: creating cache $cache_file" >&6;}
>$cache_file
fi
# Check that the precious variables saved in the cache have kept the same
# value.
ac_cache_corrupted=false
for ac_var in $ac_precious_vars; do
eval ac_old_set=\$ac_cv_env_${ac_var}_set
eval ac_new_set=\$ac_env_${ac_var}_set
eval ac_old_val=\$ac_cv_env_${ac_var}_value
eval ac_new_val=\$ac_env_${ac_var}_value
case $ac_old_set,$ac_new_set in
set,)
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
ac_cache_corrupted=: ;;
,set)
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
ac_cache_corrupted=: ;;
,);;
*)
if test "x$ac_old_val" != "x$ac_new_val"; then
# differences in whitespace do not lead to failure.
ac_old_val_w=`echo x $ac_old_val`
ac_new_val_w=`echo x $ac_new_val`
if test "$ac_old_val_w" != "$ac_new_val_w"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
ac_cache_corrupted=:
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
eval $ac_var=\$ac_old_val
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5
$as_echo "$as_me: former value: \`$ac_old_val'" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5
$as_echo "$as_me: current value: \`$ac_new_val'" >&2;}
fi;;
esac
# Pass precious variables to config.status.
if test "$ac_new_set" = set; then
case $ac_new_val in
*\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
*) ac_arg=$ac_var=$ac_new_val ;;
esac
case " $ac_configure_args " in
*" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.
*) as_fn_append ac_configure_args " '$ac_arg'" ;;
esac
fi
done
if $ac_cache_corrupted; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
fi
## -------------------- ##
## Main body of script. ##
## -------------------- ##
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
ac_aux_dir=
for ac_dir in tools "$srcdir"/tools; do
if test -f "$ac_dir/install-sh"; then
ac_aux_dir=$ac_dir
ac_install_sh="$ac_aux_dir/install-sh -c"
break
elif test -f "$ac_dir/install.sh"; then
ac_aux_dir=$ac_dir
ac_install_sh="$ac_aux_dir/install.sh -c"
break
elif test -f "$ac_dir/shtool"; then
ac_aux_dir=$ac_dir
ac_install_sh="$ac_aux_dir/shtool install -c"
break
fi
done
if test -z "$ac_aux_dir"; then
as_fn_error $? "cannot find install-sh, install.sh, or shtool in tools \"$srcdir\"/tools" "$LINENO" 5
fi
# These three variables are undocumented and unsupported,
# and are intended to be withdrawn in a future Autoconf release.
# They can cause serious problems if a builder's source tree is in a directory
# whose full name contains unusual characters.
ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var.
ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var.
ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var.
# Make sure we can run config.sub.
$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
$as_echo_n "checking build system type... " >&6; }
if ${ac_cv_build+:} false; then :
$as_echo_n "(cached) " >&6
else
ac_build_alias=$build_alias
test "x$ac_build_alias" = x &&
ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
test "x$ac_build_alias" = x &&
as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
$as_echo "$ac_cv_build" >&6; }
case $ac_cv_build in
*-*-*) ;;
*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
esac
build=$ac_cv_build
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_build
shift
build_cpu=$1
build_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
build_os=$*
IFS=$ac_save_IFS
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
$as_echo_n "checking host system type... " >&6; }
if ${ac_cv_host+:} false; then :
$as_echo_n "(cached) " >&6
else
if test "x$host_alias" = x; then
ac_cv_host=$ac_cv_build
else
ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
$as_echo "$ac_cv_host" >&6; }
case $ac_cv_host in
*-*-*) ;;
*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
esac
host=$ac_cv_host
ac_save_IFS=$IFS; IFS='-'
set x $ac_cv_host
shift
host_cpu=$1
host_vendor=$2
shift; shift
# Remember, the first character of IFS is used to create $*,
# except with old shells:
host_os=$*
IFS=$ac_save_IFS
case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
am__api_version='1.14'
# Find a good install program. We prefer a C program (faster),
# so one script is as good as another. But avoid the broken or
# incompatible versions:
# SysV /etc/install, /usr/sbin/install
# SunOS /usr/etc/install
# IRIX /sbin/install
# AIX /bin/install
# AmigaOS /C/install, which installs bootblocks on floppy discs
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
# OS/2's system install, which has a completely different semantic
# ./install, which can be erroneously created by make from ./install.sh.
# Reject install programs that cannot install multiple files.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
$as_echo_n "checking for a BSD-compatible install... " >&6; }
if test -z "$INSTALL"; then
if ${ac_cv_path_install+:} false; then :
$as_echo_n "(cached) " >&6
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
# Account for people who put trailing slashes in PATH elements.
case $as_dir/ in #((
./ | .// | /[cC]/* | \
/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
/usr/ucb/* ) ;;
*)
# OSF1 and SCO ODT 3.0 have their own names for install.
# Don't use installbsd from OSF since it installs stuff as root
# by default.
for ac_prog in ginstall scoinst install; do
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
if test $ac_prog = install &&
grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
# AIX install. It has an incompatible calling convention.
:
elif test $ac_prog = install &&
grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
# program-specific install script used by HP pwplus--don't use.
:
else
rm -rf conftest.one conftest.two conftest.dir
echo one > conftest.one
echo two > conftest.two
mkdir conftest.dir
if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
test -s conftest.one && test -s conftest.two &&
test -s conftest.dir/conftest.one &&
test -s conftest.dir/conftest.two
then
ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
break 3
fi
fi
fi
done
done
;;
esac
done
IFS=$as_save_IFS
rm -rf conftest.one conftest.two conftest.dir
fi
if test "${ac_cv_path_install+set}" = set; then
INSTALL=$ac_cv_path_install
else
# As a last resort, use the slow shell script. Don't cache a
# value for INSTALL within a source directory, because that will
# break other packages using the cache if that directory is
# removed, or if the value is a relative name.
INSTALL=$ac_install_sh
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
$as_echo "$INSTALL" >&6; }
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
# It thinks the first close brace ends the variable substitution.
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
$as_echo_n "checking whether build environment is sane... " >&6; }
# Reject unsafe characters in $srcdir or the absolute working directory
# name. Accept space and tab only in the latter.
am_lf='
'
case `pwd` in
*[\\\"\#\$\&\'\`$am_lf]*)
as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
esac
case $srcdir in
*[\\\"\#\$\&\'\`$am_lf\ \ ]*)
as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
esac
# Do 'set' in a subshell so we don't clobber the current shell's
# arguments. Must try -L first in case configure is actually a
# symlink; some systems play weird games with the mod time of symlinks
# (eg FreeBSD returns the mod time of the symlink's containing
# directory).
if (
am_has_slept=no
for am_try in 1 2; do
echo "timestamp, slept: $am_has_slept" > conftest.file
set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
if test "$*" = "X"; then
# -L didn't work.
set X `ls -t "$srcdir/configure" conftest.file`
fi
if test "$*" != "X $srcdir/configure conftest.file" \
&& test "$*" != "X conftest.file $srcdir/configure"; then
# If neither matched, then we have a broken ls. This can happen
# if, for instance, CONFIG_SHELL is bash and it inherits a
# broken ls alias from the environment. This has actually
# happened. Such a system could not be considered "sane".
as_fn_error $? "ls -t appears to fail. Make sure there is not a broken
alias in your environment" "$LINENO" 5
fi
if test "$2" = conftest.file || test $am_try -eq 2; then
break
fi
# Just in case.
sleep 1
am_has_slept=yes
done
test "$2" = conftest.file
)
then
# Ok.
:
else
as_fn_error $? "newly created file is older than distributed files!
Check your system clock" "$LINENO" 5
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
# If we didn't sleep, we still need to ensure time stamps of config.status and
# generated files are strictly newer.
am_sleep_pid=
if grep 'slept: no' conftest.file >/dev/null 2>&1; then
( sleep 1 ) &
am_sleep_pid=$!
fi
rm -f conftest.file
test "$program_prefix" != NONE &&
program_transform_name="s&^&$program_prefix&;$program_transform_name"
# Use a double $ so make ignores it.
test "$program_suffix" != NONE &&
program_transform_name="s&\$&$program_suffix&;$program_transform_name"
# Double any \ or $.
# By default was `s,x,x', remove it if useless.
ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
# expand $ac_aux_dir to an absolute path
am_aux_dir=`cd $ac_aux_dir && pwd`
if test x"${MISSING+set}" != xset; then
case $am_aux_dir in
*\ * | *\ *)
MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
*)
MISSING="\${SHELL} $am_aux_dir/missing" ;;
esac
fi
# Use eval to expand $SHELL
if eval "$MISSING --is-lightweight"; then
am_missing_run="$MISSING "
else
am_missing_run=
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
fi
if test x"${install_sh}" != xset; then
case $am_aux_dir in
*\ * | *\ *)
install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
*)
install_sh="\${SHELL} $am_aux_dir/install-sh"
esac
fi
# Installed binaries are usually stripped using 'strip' when the user
# run "make install-strip". However 'strip' might not be the right
# tool to use in cross-compilation environments, therefore Automake
# will honor the 'STRIP' environment variable to overrule this program.
if test "$cross_compiling" != no; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
set dummy ${ac_tool_prefix}strip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_STRIP+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$STRIP"; then
ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_STRIP="${ac_tool_prefix}strip"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
$as_echo "$STRIP" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_STRIP"; then
ac_ct_STRIP=$STRIP
# Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_STRIP"; then
ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_STRIP="strip"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
$as_echo "$ac_ct_STRIP" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
if test "x$ac_ct_STRIP" = x; then
STRIP=":"
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
STRIP=$ac_ct_STRIP
fi
else
STRIP="$ac_cv_prog_STRIP"
fi
fi
INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
if test -z "$MKDIR_P"; then
if ${ac_cv_path_mkdir+:} false; then :
$as_echo_n "(cached) " >&6
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_prog in mkdir gmkdir; do
for ac_exec_ext in '' $ac_executable_extensions; do
as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
'mkdir (GNU coreutils) '* | \
'mkdir (coreutils) '* | \
'mkdir (fileutils) '4.1*)
ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
break 3;;
esac
done
done
done
IFS=$as_save_IFS
fi
test -d ./--version && rmdir ./--version
if test "${ac_cv_path_mkdir+set}" = set; then
MKDIR_P="$ac_cv_path_mkdir -p"
else
# As a last resort, use the slow shell script. Don't cache a
# value for MKDIR_P within a source directory, because that will
# break other packages using the cache if that directory is
# removed, or if the value is a relative name.
MKDIR_P="$ac_install_sh -d"
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
$as_echo "$MKDIR_P" >&6; }
for ac_prog in gawk mawk nawk awk
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_AWK+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$AWK"; then
ac_cv_prog_AWK="$AWK" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_AWK="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
AWK=$ac_cv_prog_AWK
if test -n "$AWK"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
$as_echo "$AWK" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
test -n "$AWK" && break
done
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
set x ${MAKE-make}
ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
$as_echo_n "(cached) " >&6
else
cat >conftest.make <<\_ACEOF
SHELL = /bin/sh
all:
@echo '@@@%%%=$(MAKE)=@@@%%%'
_ACEOF
# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
case `${MAKE-make} -f conftest.make 2>/dev/null` in
*@@@%%%=?*=@@@%%%*)
eval ac_cv_prog_make_${ac_make}_set=yes;;
*)
eval ac_cv_prog_make_${ac_make}_set=no;;
esac
rm -f conftest.make
fi
if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
SET_MAKE=
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
SET_MAKE="MAKE=${MAKE-make}"
fi
rm -rf .tst 2>/dev/null
mkdir .tst 2>/dev/null
if test -d .tst; then
am__leading_dot=.
else
am__leading_dot=_
fi
rmdir .tst 2>/dev/null
# Check whether --enable-silent-rules was given.
if test "${enable_silent_rules+set}" = set; then :
enableval=$enable_silent_rules;
fi
case $enable_silent_rules in # (((
yes) AM_DEFAULT_VERBOSITY=0;;
no) AM_DEFAULT_VERBOSITY=1;;
*) AM_DEFAULT_VERBOSITY=1;;
esac
am_make=${MAKE-make}
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
if ${am_cv_make_support_nested_variables+:} false; then :
$as_echo_n "(cached) " >&6
else
if $as_echo 'TRUE=$(BAR$(V))
BAR0=false
BAR1=true
V=1
am__doit:
@$(TRUE)
.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
am_cv_make_support_nested_variables=yes
else
am_cv_make_support_nested_variables=no
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
$as_echo "$am_cv_make_support_nested_variables" >&6; }
if test $am_cv_make_support_nested_variables = yes; then
AM_V='$(V)'
AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
else
AM_V=$AM_DEFAULT_VERBOSITY
AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
fi
AM_BACKSLASH='\'
if test "`cd $srcdir && pwd`" != "`pwd`"; then
# Use -I$(srcdir) only when $(srcdir) != ., so that make's output
# is not polluted with repeated "-I."
am__isrc=' -I$(srcdir)'
# test to see if srcdir already configured
if test -f $srcdir/config.status; then
as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
fi
fi
# test whether we have cygpath
if test -z "$CYGPATH_W"; then
if (cygpath --version) >/dev/null 2>/dev/null; then
CYGPATH_W='cygpath -w'
else
CYGPATH_W=echo
fi
fi
# Define the identity of the package.
PACKAGE='rlwrap'
VERSION='0.42'
cat >>confdefs.h <<_ACEOF
#define PACKAGE "$PACKAGE"
_ACEOF
cat >>confdefs.h <<_ACEOF
#define VERSION "$VERSION"
_ACEOF
# Some tools Automake needs.
ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
# For better backward compatibility. To be removed once Automake 1.9.x
# dies out for good. For more background, see:
#
#
mkdir_p='$(MKDIR_P)'
# We need awk for the "check" target. The system "awk" is bad on
# some platforms.
# Always define AMTAR for backward compatibility. Yes, it's still used
# in the wild :-( We should find a proper way to deprecate it ...
AMTAR='$${TAR-tar}'
# We'll loop over all known methods to create a tar archive until one works.
_am_tools='gnutar pax cpio none'
am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
# POSIX will say in a future version that running "rm -f" with no argument
# is OK; and we want to be able to make that assumption in our Makefile
# recipes. So use an aggressive probe to check that the usage we want is
# actually supported "in the wild" to an acceptable degree.
# See automake bug#10828.
# To make any issue more visible, cause the running configure to be aborted
# by default if the 'rm' program in use doesn't match our expectations; the
# user can still override this though.
if rm -f && rm -fr && rm -rf; then : OK; else
cat >&2 <<'END'
Oops!
Your 'rm' program seems unable to run without file operands specified
on the command line, even when the '-f' option is present. This is contrary
to the behaviour of most rm programs out there, and not conforming with
the upcoming POSIX standard:
Please tell bug-automake@gnu.org about your system, including the value
of your $PATH and any error possibly output before this message. This
can help us improve future automake versions.
END
if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
echo 'Configuration will proceed anyway, since you have set the' >&2
echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
echo >&2
else
cat >&2 <<'END'
Aborting the configuration process, to ensure you take notice of the issue.
You can download and install GNU coreutils to get an 'rm' implementation
that behaves properly: .
If you want to complete the configuration process using your problematic
'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
to "yes", and re-run configure.
END
as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
fi
fi
ac_config_headers="$ac_config_headers config.h"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
set x ${MAKE-make}
ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
$as_echo_n "(cached) " >&6
else
cat >conftest.make <<\_ACEOF
SHELL = /bin/sh
all:
@echo '@@@%%%=$(MAKE)=@@@%%%'
_ACEOF
# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
case `${MAKE-make} -f conftest.make 2>/dev/null` in
*@@@%%%=?*=@@@%%%*)
eval ac_cv_prog_make_${ac_make}_set=yes;;
*)
eval ac_cv_prog_make_${ac_make}_set=no;;
esac
rm -f conftest.make
fi
if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
SET_MAKE=
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
SET_MAKE="MAKE=${MAKE-make}"
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
$as_echo_n "checking whether build environment is sane... " >&6; }
# Reject unsafe characters in $srcdir or the absolute working directory
# name. Accept space and tab only in the latter.
am_lf='
'
case `pwd` in
*[\\\"\#\$\&\'\`$am_lf]*)
as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
esac
case $srcdir in
*[\\\"\#\$\&\'\`$am_lf\ \ ]*)
as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
esac
# Do 'set' in a subshell so we don't clobber the current shell's
# arguments. Must try -L first in case configure is actually a
# symlink; some systems play weird games with the mod time of symlinks
# (eg FreeBSD returns the mod time of the symlink's containing
# directory).
if (
am_has_slept=no
for am_try in 1 2; do
echo "timestamp, slept: $am_has_slept" > conftest.file
set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
if test "$*" = "X"; then
# -L didn't work.
set X `ls -t "$srcdir/configure" conftest.file`
fi
if test "$*" != "X $srcdir/configure conftest.file" \
&& test "$*" != "X conftest.file $srcdir/configure"; then
# If neither matched, then we have a broken ls. This can happen
# if, for instance, CONFIG_SHELL is bash and it inherits a
# broken ls alias from the environment. This has actually
# happened. Such a system could not be considered "sane".
as_fn_error $? "ls -t appears to fail. Make sure there is not a broken
alias in your environment" "$LINENO" 5
fi
if test "$2" = conftest.file || test $am_try -eq 2; then
break
fi
# Just in case.
sleep 1
am_has_slept=yes
done
test "$2" = conftest.file
)
then
# Ok.
:
else
as_fn_error $? "newly created file is older than distributed files!
Check your system clock" "$LINENO" 5
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
# If we didn't sleep, we still need to ensure time stamps of config.status and
# generated files are strictly newer.
am_sleep_pid=
if grep 'slept: no' conftest.file >/dev/null 2>&1; then
( sleep 1 ) &
am_sleep_pid=$!
fi
rm -f conftest.file
# option parsing for optional features
opt_debug=no
opt_homegrown_redisplay=no
opt_spy_on_readline=yes
opt_proc_mountpoint=/proc
# Check whether --enable-debug was given.
if test "${enable_debug+set}" = set; then :
enableval=$enable_debug; opt_debug=$enableval
fi
# Check whether --enable-homegrown-redisplay was given.
if test "${enable_homegrown_redisplay+set}" = set; then :
enableval=$enable_homegrown_redisplay; opt_homegrown_redisplay=$enableval
fi
# Check whether --enable-spy-on-readline was given.
if test "${enable_spy_on_readline+set}" = set; then :
enableval=$enable_spy_on_readline; opt_spy_on_readline=$enableval
fi
# Check whether --enable-proc-mountpoint was given.
if test "${enable_proc_mountpoint+set}" = set; then :
enableval=$enable_proc_mountpoint; # '
opt_proc_mountpoint=$enableval
fi
if test $opt_debug = yes; then
$as_echo "#define DEBUG 1 " >>confdefs.h
test -z "$CFLAGS" || { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Because CFLAGS is set, configure will not add -g and -Wall to them - do it yourself if necessary" >&5
$as_echo "$as_me: WARNING: Because CFLAGS is set, configure will not add -g and -Wall to them - do it yourself if necessary" >&2;}
test -z "$CFLAGS" && CFLAGS="-O0 -g -Wimplicit-function-declaration -Wimplicit -pedantic -Wall"
# compile for debugging, and give plenty of warnings
fi
DEPDIR="${am__leading_dot}deps"
ac_config_commands="$ac_config_commands depfiles"
am_make=${MAKE-make}
cat > confinc << 'END'
am__doit:
@echo this is the am__doit target
.PHONY: am__doit
END
# If we don't find an include directive, just comment out the code.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
$as_echo_n "checking for style of include used by $am_make... " >&6; }
am__include="#"
am__quote=
_am_result=none
# First try GNU make style include.
echo "include confinc" > confmf
# Ignore all kinds of additional output from 'make'.
case `$am_make -s -f confmf 2> /dev/null` in #(
*the\ am__doit\ target*)
am__include=include
am__quote=
_am_result=GNU
;;
esac
# Now try BSD make style include.
if test "$am__include" = "#"; then
echo '.include "confinc"' > confmf
case `$am_make -s -f confmf 2> /dev/null` in #(
*the\ am__doit\ target*)
am__include=.include
am__quote="\""
_am_result=BSD
;;
esac
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
$as_echo "$_am_result" >&6; }
rm -f confinc confmf
# Check whether --enable-dependency-tracking was given.
if test "${enable_dependency_tracking+set}" = set; then :
enableval=$enable_dependency_tracking;
fi
if test "x$enable_dependency_tracking" != xno; then
am_depcomp="$ac_aux_dir/depcomp"
AMDEPBACKSLASH='\'
am__nodep='_no'
fi
if test "x$enable_dependency_tracking" != xno; then
AMDEP_TRUE=
AMDEP_FALSE='#'
else
AMDEP_TRUE='#'
AMDEP_FALSE=
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
set dummy ${ac_tool_prefix}gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}gcc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_CC"; then
ac_ct_CC=$CC
# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_CC"; then
ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="gcc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
if test "x$ac_ct_CC" = x; then
CC=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
CC=$ac_ct_CC
fi
else
CC="$ac_cv_prog_CC"
fi
if test -z "$CC"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
set dummy ${ac_tool_prefix}cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}cc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
fi
fi
if test -z "$CC"; then
# Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
ac_prog_rejected=no
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
ac_prog_rejected=yes
continue
fi
ac_cv_prog_CC="cc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
if test $ac_prog_rejected = yes; then
# We found a bogon in the path, so make sure we never use it.
set dummy $ac_cv_prog_CC
shift
if test $# != 0; then
# We chose a different compiler from the bogus one.
# However, it has the same basename, so the bogon will be chosen
# first if we set CC to just the basename; use the full file name.
shift
ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
fi
fi
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
fi
if test -z "$CC"; then
if test -n "$ac_tool_prefix"; then
for ac_prog in cl.exe
do
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
test -n "$CC" && break
done
fi
if test -z "$CC"; then
ac_ct_CC=$CC
for ac_prog in cl.exe
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_CC"; then
ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
test -n "$ac_ct_CC" && break
done
if test "x$ac_ct_CC" = x; then
CC=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
CC=$ac_ct_CC
fi
fi
fi
test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "no acceptable C compiler found in \$PATH
See \`config.log' for more details" "$LINENO" 5; }
# Provide some information about the compiler.
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion; do
{ { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_compiler $ac_option >&5") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
sed '10a\
... rest of stderr output deleted ...
10q' conftest.err >conftest.er1
cat conftest.er1 >&5
fi
rm -f conftest.er1 conftest.err
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
done
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
# Try to create an executable without -o first, disregard a.out.
# It will help us diagnose broken compilers, and finding out an intuition
# of exeext.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
$as_echo_n "checking whether the C compiler works... " >&6; }
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
# The possible output files:
ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
ac_rmfiles=
for ac_file in $ac_files
do
case $ac_file in
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
* ) ac_rmfiles="$ac_rmfiles $ac_file";;
esac
done
rm -f $ac_rmfiles
if { { ac_try="$ac_link_default"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link_default") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then :
# Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
# in a Makefile. We should not override ac_cv_exeext if it was cached,
# so that the user can short-circuit this test for compilers unknown to
# Autoconf.
for ac_file in $ac_files ''
do
test -f "$ac_file" || continue
case $ac_file in
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
;;
[ab].out )
# We found the default executable, but exeext='' is most
# certainly right.
break;;
*.* )
if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
then :; else
ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
fi
# We set ac_cv_exeext here because the later test for it is not
# safe: cross compilers may not add the suffix if given an `-o'
# argument, so we may need to know it at that point already.
# Even if this section looks crufty: it has the advantage of
# actually working.
break;;
* )
break;;
esac
done
test "$ac_cv_exeext" = no && ac_cv_exeext=
else
ac_file=''
fi
if test -z "$ac_file"; then :
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error 77 "C compiler cannot create executables
See \`config.log' for more details" "$LINENO" 5; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
$as_echo_n "checking for C compiler default output file name... " >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
$as_echo "$ac_file" >&6; }
ac_exeext=$ac_cv_exeext
rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
$as_echo_n "checking for suffix of executables... " >&6; }
if { { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then :
# If both `conftest.exe' and `conftest' are `present' (well, observable)
# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will
# work properly (i.e., refer to `conftest.exe'), while it won't with
# `rm'.
for ac_file in conftest.exe conftest conftest.*; do
test -f "$ac_file" || continue
case $ac_file in
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
*.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
break;;
* ) break;;
esac
done
else
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of executables: cannot compile and link
See \`config.log' for more details" "$LINENO" 5; }
fi
rm -f conftest conftest$ac_cv_exeext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
$as_echo "$ac_cv_exeext" >&6; }
rm -f conftest.$ac_ext
EXEEXT=$ac_cv_exeext
ac_exeext=$EXEEXT
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
int
main ()
{
FILE *f = fopen ("conftest.out", "w");
return ferror (f) || fclose (f) != 0;
;
return 0;
}
_ACEOF
ac_clean_files="$ac_clean_files conftest.out"
# Check that the compiler produces executables we can run. If not, either
# the compiler is broken, or we cross compile.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
$as_echo_n "checking whether we are cross compiling... " >&6; }
if test "$cross_compiling" != yes; then
{ { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
if { ac_try='./conftest$ac_cv_exeext'
{ { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; }; then
cross_compiling=no
else
if test "$cross_compiling" = maybe; then
cross_compiling=yes
else
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details" "$LINENO" 5; }
fi
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
$as_echo "$cross_compiling" >&6; }
rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
$as_echo_n "checking for suffix of object files... " >&6; }
if ${ac_cv_objext+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
rm -f conftest.o conftest.obj
if { { ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_compile") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then :
for ac_file in conftest.o conftest.obj conftest.*; do
test -f "$ac_file" || continue;
case $ac_file in
*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
*) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
break;;
esac
done
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "cannot compute suffix of object files: cannot compile
See \`config.log' for more details" "$LINENO" 5; }
fi
rm -f conftest.$ac_cv_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
$as_echo "$ac_cv_objext" >&6; }
OBJEXT=$ac_cv_objext
ac_objext=$OBJEXT
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
if ${ac_cv_c_compiler_gnu+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
#ifndef __GNUC__
choke me
#endif
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_compiler_gnu=yes
else
ac_compiler_gnu=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_c_compiler_gnu=$ac_compiler_gnu
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
$as_echo "$ac_cv_c_compiler_gnu" >&6; }
if test $ac_compiler_gnu = yes; then
GCC=yes
else
GCC=
fi
ac_test_CFLAGS=${CFLAGS+set}
ac_save_CFLAGS=$CFLAGS
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
$as_echo_n "checking whether $CC accepts -g... " >&6; }
if ${ac_cv_prog_cc_g+:} false; then :
$as_echo_n "(cached) " >&6
else
ac_save_c_werror_flag=$ac_c_werror_flag
ac_c_werror_flag=yes
ac_cv_prog_cc_g=no
CFLAGS="-g"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_prog_cc_g=yes
else
CFLAGS=""
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
else
ac_c_werror_flag=$ac_save_c_werror_flag
CFLAGS="-g"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_prog_cc_g=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_c_werror_flag=$ac_save_c_werror_flag
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
$as_echo "$ac_cv_prog_cc_g" >&6; }
if test "$ac_test_CFLAGS" = set; then
CFLAGS=$ac_save_CFLAGS
elif test $ac_cv_prog_cc_g = yes; then
if test "$GCC" = yes; then
CFLAGS="-g -O2"
else
CFLAGS="-g"
fi
else
if test "$GCC" = yes; then
CFLAGS="-O2"
else
CFLAGS=
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
if ${ac_cv_prog_cc_c89+:} false; then :
$as_echo_n "(cached) " >&6
else
ac_cv_prog_cc_c89=no
ac_save_CC=$CC
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#include
struct stat;
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
struct buf { int x; };
FILE * (*rcsopen) (struct buf *, struct stat *, int);
static char *e (p, i)
char **p;
int i;
{
return p[i];
}
static char *f (char * (*g) (char **, int), char **p, ...)
{
char *s;
va_list v;
va_start (v,p);
s = g (p, va_arg (v,int));
va_end (v);
return s;
}
/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has
function prototypes and stuff, but not '\xHH' hex character constants.
These don't provoke an error unfortunately, instead are silently treated
as 'x'. The following induces an error, until -std is added to get
proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an
array size at least. It's necessary to write '\x00'==0 to get something
that's true only with -std. */
int osf4_cc_array ['\x00' == 0 ? 1 : -1];
/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
inside strings and character constants. */
#define FOO(x) 'x'
int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
int test (int i, double x);
struct s1 {int (*f) (int a);};
struct s2 {int (*f) (double a);};
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
int argc;
char **argv;
int
main ()
{
return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];
;
return 0;
}
_ACEOF
for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
do
CC="$ac_save_CC $ac_arg"
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_prog_cc_c89=$ac_arg
fi
rm -f core conftest.err conftest.$ac_objext
test "x$ac_cv_prog_cc_c89" != "xno" && break
done
rm -f conftest.$ac_ext
CC=$ac_save_CC
fi
# AC_CACHE_VAL
case "x$ac_cv_prog_cc_c89" in
x)
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
$as_echo "none needed" >&6; } ;;
xno)
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
$as_echo "unsupported" >&6; } ;;
*)
CC="$CC $ac_cv_prog_cc_c89"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
esac
if test "x$ac_cv_prog_cc_c89" != xno; then :
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
if ${am_cv_prog_cc_c_o+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
# Make sure it works both with $CC and with simple cc.
# Following AC_PROG_CC_C_O, we do the test twice because some
# compilers refuse to overwrite an existing .o file with -o,
# though they will create one.
am_cv_prog_cc_c_o=yes
for am_i in 1 2; do
if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
ac_status=$?
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } \
&& test -f conftest2.$ac_objext; then
: OK
else
am_cv_prog_cc_c_o=no
break
fi
done
rm -f core conftest*
unset am_i
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
$as_echo "$am_cv_prog_cc_c_o" >&6; }
if test "$am_cv_prog_cc_c_o" != yes; then
# Losing compiler, so override with the script.
# FIXME: It is wrong to rewrite CC.
# But if we don't then we get into trouble of one sort or another.
# A longer-term fix would be to have automake use am__CC in this case,
# and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
CC="$am_aux_dir/compile $CC"
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
depcc="$CC" am_compiler_list=
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
$as_echo_n "checking dependency style of $depcc... " >&6; }
if ${am_cv_CC_dependencies_compiler_type+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
# We make a subdir and do the tests there. Otherwise we can end up
# making bogus files that we don't know about and never remove. For
# instance it was reported that on HP-UX the gcc test will end up
# making a dummy file named 'D' -- because '-MD' means "put the output
# in D".
rm -rf conftest.dir
mkdir conftest.dir
# Copy depcomp to subdir because otherwise we won't find it if we're
# using a relative directory.
cp "$am_depcomp" conftest.dir
cd conftest.dir
# We will build objects and dependencies in a subdirectory because
# it helps to detect inapplicable dependency modes. For instance
# both Tru64's cc and ICC support -MD to output dependencies as a
# side effect of compilation, but ICC will put the dependencies in
# the current directory while Tru64 will put them in the object
# directory.
mkdir sub
am_cv_CC_dependencies_compiler_type=none
if test "$am_compiler_list" = ""; then
am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
fi
am__universal=false
case " $depcc " in #(
*\ -arch\ *\ -arch\ *) am__universal=true ;;
esac
for depmode in $am_compiler_list; do
# Setup a source with many dependencies, because some compilers
# like to wrap large dependency lists on column 80 (with \), and
# we should not choose a depcomp mode which is confused by this.
#
# We need to recreate these files for each test, as the compiler may
# overwrite some of them when testing with obscure command lines.
# This happens at least with the AIX C compiler.
: > sub/conftest.c
for i in 1 2 3 4 5 6; do
echo '#include "conftst'$i'.h"' >> sub/conftest.c
# Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
# Solaris 10 /bin/sh.
echo '/* dummy */' > sub/conftst$i.h
done
echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
# We check with '-c' and '-o' for the sake of the "dashmstdout"
# mode. It turns out that the SunPro C++ compiler does not properly
# handle '-M -o', and we need to detect this. Also, some Intel
# versions had trouble with output in subdirs.
am__obj=sub/conftest.${OBJEXT-o}
am__minus_obj="-o $am__obj"
case $depmode in
gcc)
# This depmode causes a compiler race in universal mode.
test "$am__universal" = false || continue
;;
nosideeffect)
# After this tag, mechanisms are not by side-effect, so they'll
# only be used when explicitly requested.
if test "x$enable_dependency_tracking" = xyes; then
continue
else
break
fi
;;
msvc7 | msvc7msys | msvisualcpp | msvcmsys)
# This compiler won't grok '-c -o', but also, the minuso test has
# not run yet. These depmodes are late enough in the game, and
# so weak that their functioning should not be impacted.
am__obj=conftest.${OBJEXT-o}
am__minus_obj=
;;
none) break ;;
esac
if depmode=$depmode \
source=sub/conftest.c object=$am__obj \
depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
$SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
>/dev/null 2>conftest.err &&
grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
${MAKE-make} -s -f confmf > /dev/null 2>&1; then
# icc doesn't choke on unknown options, it will just issue warnings
# or remarks (even with -Werror). So we grep stderr for any message
# that says an option was ignored or not supported.
# When given -MP, icc 7.0 and 7.1 complain thusly:
# icc: Command line warning: ignoring option '-M'; no argument required
# The diagnosis changed in icc 8.0:
# icc: Command line remark: option '-MP' not supported
if (grep 'ignoring option' conftest.err ||
grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
am_cv_CC_dependencies_compiler_type=$depmode
break
fi
fi
done
cd ..
rm -rf conftest.dir
else
am_cv_CC_dependencies_compiler_type=none
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
if
test "x$enable_dependency_tracking" != xno \
&& test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
am__fastdepCC_TRUE=
am__fastdepCC_FALSE='#'
else
am__fastdepCC_TRUE='#'
am__fastdepCC_FALSE=
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
$as_echo_n "checking how to run the C preprocessor... " >&6; }
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
CPP=
fi
if test -z "$CPP"; then
if ${ac_cv_prog_CPP+:} false; then :
$as_echo_n "(cached) " >&6
else
# Double quotes because CPP needs to be expanded
for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
do
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
# Use a header file that comes with gcc, so configuring glibc
# with a fresh cross-compiler works.
# Prefer to if __STDC__ is defined, since
# exists even on freestanding compilers.
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp. "Syntax error" is here to catch this case.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#ifdef __STDC__
# include
#else
# include
#endif
Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
else
# Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext
# OK, works on sane cases. Now check whether nonexistent headers
# can be detected and how.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
# Broken: success on invalid input.
continue
else
# Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext
done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
break
fi
done
ac_cv_prog_CPP=$CPP
fi
CPP=$ac_cv_prog_CPP
else
ac_cv_prog_CPP=$CPP
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
$as_echo "$CPP" >&6; }
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
# Use a header file that comes with gcc, so configuring glibc
# with a fresh cross-compiler works.
# Prefer to if __STDC__ is defined, since
# exists even on freestanding compilers.
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp. "Syntax error" is here to catch this case.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#ifdef __STDC__
# include
#else
# include
#endif
Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
else
# Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext
# OK, works on sane cases. Now check whether nonexistent headers
# can be detected and how.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
# Broken: success on invalid input.
continue
else
# Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext
done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
else
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details" "$LINENO" 5; }
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
if ${ac_cv_path_GREP+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -z "$GREP"; then
ac_path_GREP_found=false
# Loop through the user's path and test for each of PROGNAME-LIST
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_prog in grep ggrep; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
as_fn_executable_p "$ac_path_GREP" || continue
# Check for GNU ac_path_GREP and select it if it is found.
# Check for GNU $ac_path_GREP
case `"$ac_path_GREP" --version 2>&1` in
*GNU*)
ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
*)
ac_count=0
$as_echo_n 0123456789 >"conftest.in"
while :
do
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
$as_echo 'GREP' >> "conftest.nl"
"$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
if test $ac_count -gt ${ac_path_GREP_max-0}; then
# Best one so far, save it but keep looking for a better one
ac_cv_path_GREP="$ac_path_GREP"
ac_path_GREP_max=$ac_count
fi
# 10*(2^10) chars as input seems more than enough
test $ac_count -gt 10 && break
done
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac
$ac_path_GREP_found && break 3
done
done
done
IFS=$as_save_IFS
if test -z "$ac_cv_path_GREP"; then
as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
fi
else
ac_cv_path_GREP=$GREP
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
$as_echo "$ac_cv_path_GREP" >&6; }
GREP="$ac_cv_path_GREP"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
$as_echo_n "checking for egrep... " >&6; }
if ${ac_cv_path_EGREP+:} false; then :
$as_echo_n "(cached) " >&6
else
if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
then ac_cv_path_EGREP="$GREP -E"
else
if test -z "$EGREP"; then
ac_path_EGREP_found=false
# Loop through the user's path and test for each of PROGNAME-LIST
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_prog in egrep; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
as_fn_executable_p "$ac_path_EGREP" || continue
# Check for GNU ac_path_EGREP and select it if it is found.
# Check for GNU $ac_path_EGREP
case `"$ac_path_EGREP" --version 2>&1` in
*GNU*)
ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
*)
ac_count=0
$as_echo_n 0123456789 >"conftest.in"
while :
do
cat "conftest.in" "conftest.in" >"conftest.tmp"
mv "conftest.tmp" "conftest.in"
cp "conftest.in" "conftest.nl"
$as_echo 'EGREP' >> "conftest.nl"
"$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
as_fn_arith $ac_count + 1 && ac_count=$as_val
if test $ac_count -gt ${ac_path_EGREP_max-0}; then
# Best one so far, save it but keep looking for a better one
ac_cv_path_EGREP="$ac_path_EGREP"
ac_path_EGREP_max=$ac_count
fi
# 10*(2^10) chars as input seems more than enough
test $ac_count -gt 10 && break
done
rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
esac
$ac_path_EGREP_found && break 3
done
done
done
IFS=$as_save_IFS
if test -z "$ac_cv_path_EGREP"; then
as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
fi
else
ac_cv_path_EGREP=$EGREP
fi
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
$as_echo "$ac_cv_path_EGREP" >&6; }
EGREP="$ac_cv_path_EGREP"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
$as_echo_n "checking for ANSI C header files... " >&6; }
if ${ac_cv_header_stdc+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#include
#include
#include
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_header_stdc=yes
else
ac_cv_header_stdc=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
if test $ac_cv_header_stdc = yes; then
# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "memchr" >/dev/null 2>&1; then :
else
ac_cv_header_stdc=no
fi
rm -f conftest*
fi
if test $ac_cv_header_stdc = yes; then
# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "free" >/dev/null 2>&1; then :
else
ac_cv_header_stdc=no
fi
rm -f conftest*
fi
if test $ac_cv_header_stdc = yes; then
# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
if test "$cross_compiling" = yes; then :
:
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#include
#if ((' ' & 0x0FF) == 0x020)
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
#else
# define ISLOWER(c) \
(('a' <= (c) && (c) <= 'i') \
|| ('j' <= (c) && (c) <= 'r') \
|| ('s' <= (c) && (c) <= 'z'))
# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
#endif
#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
int
main ()
{
int i;
for (i = 0; i < 256; i++)
if (XOR (islower (i), ISLOWER (i))
|| toupper (i) != TOUPPER (i))
return 2;
return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
else
ac_cv_header_stdc=no
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
$as_echo "$ac_cv_header_stdc" >&6; }
if test $ac_cv_header_stdc = yes; then
$as_echo "#define STDC_HEADERS 1" >>confdefs.h
fi
# On IRIX 5.3, sys/types and inttypes.h are conflicting.
for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
inttypes.h stdint.h unistd.h
do :
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
"
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
_ACEOF
fi
done
ac_fn_c_check_header_mongrel "$LINENO" "minix/config.h" "ac_cv_header_minix_config_h" "$ac_includes_default"
if test "x$ac_cv_header_minix_config_h" = xyes; then :
MINIX=yes
else
MINIX=
fi
if test "$MINIX" = yes; then
$as_echo "#define _POSIX_SOURCE 1" >>confdefs.h
$as_echo "#define _POSIX_1_SOURCE 2" >>confdefs.h
$as_echo "#define _MINIX 1" >>confdefs.h
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether it is safe to define __EXTENSIONS__" >&5
$as_echo_n "checking whether it is safe to define __EXTENSIONS__... " >&6; }
if ${ac_cv_safe_to_define___extensions__+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
# define __EXTENSIONS__ 1
$ac_includes_default
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_safe_to_define___extensions__=yes
else
ac_cv_safe_to_define___extensions__=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_safe_to_define___extensions__" >&5
$as_echo "$ac_cv_safe_to_define___extensions__" >&6; }
test $ac_cv_safe_to_define___extensions__ = yes &&
$as_echo "#define __EXTENSIONS__ 1" >>confdefs.h
$as_echo "#define _ALL_SOURCE 1" >>confdefs.h
$as_echo "#define _GNU_SOURCE 1" >>confdefs.h
$as_echo "#define _POSIX_PTHREAD_SEMANTICS 1" >>confdefs.h
$as_echo "#define _TANDEM_SOURCE 1" >>confdefs.h
test $opt_homegrown_redisplay = yes &&
$as_echo "#define HOMEGROWN_REDISPLAY 1 " >>confdefs.h
test $opt_spy_on_readline = yes &&
$as_echo "#define SPY_ON_READLINE 1 " >>confdefs.h
ac_config_files="$ac_config_files Makefile filters/Makefile doc/Makefile src/Makefile doc/rlwrap.man"
# Checks for programs.
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
set dummy ${ac_tool_prefix}gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}gcc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
fi
if test -z "$ac_cv_prog_CC"; then
ac_ct_CC=$CC
# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_CC"; then
ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="gcc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
if test "x$ac_ct_CC" = x; then
CC=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
CC=$ac_ct_CC
fi
else
CC="$ac_cv_prog_CC"
fi
if test -z "$CC"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
set dummy ${ac_tool_prefix}cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="${ac_tool_prefix}cc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
fi
fi
if test -z "$CC"; then
# Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
ac_prog_rejected=no
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
ac_prog_rejected=yes
continue
fi
ac_cv_prog_CC="cc"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
if test $ac_prog_rejected = yes; then
# We found a bogon in the path, so make sure we never use it.
set dummy $ac_cv_prog_CC
shift
if test $# != 0; then
# We chose a different compiler from the bogus one.
# However, it has the same basename, so the bogon will be chosen
# first if we set CC to just the basename; use the full file name.
shift
ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
fi
fi
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
fi
if test -z "$CC"; then
if test -n "$ac_tool_prefix"; then
for ac_prog in cl.exe
do
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
ac_cv_prog_CC="$CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
test -n "$CC" && break
done
fi
if test -z "$CC"; then
ac_ct_CC=$CC
for ac_prog in cl.exe
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_ac_ct_CC+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_CC"; then
ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_ac_ct_CC="$ac_prog"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
fi
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
test -n "$ac_ct_CC" && break
done
if test "x$ac_ct_CC" = x; then
CC=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
CC=$ac_ct_CC
fi
fi
fi
test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "no acceptable C compiler found in \$PATH
See \`config.log' for more details" "$LINENO" 5; }
# Provide some information about the compiler.
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
set X $ac_compile
ac_compiler=$2
for ac_option in --version -v -V -qversion; do
{ { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_compiler $ac_option >&5") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
sed '10a\
... rest of stderr output deleted ...
10q' conftest.err >conftest.er1
cat conftest.er1 >&5
fi
rm -f conftest.er1 conftest.err
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
done
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
if ${ac_cv_c_compiler_gnu+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
#ifndef __GNUC__
choke me
#endif
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_compiler_gnu=yes
else
ac_compiler_gnu=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_c_compiler_gnu=$ac_compiler_gnu
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
$as_echo "$ac_cv_c_compiler_gnu" >&6; }
if test $ac_compiler_gnu = yes; then
GCC=yes
else
GCC=
fi
ac_test_CFLAGS=${CFLAGS+set}
ac_save_CFLAGS=$CFLAGS
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
$as_echo_n "checking whether $CC accepts -g... " >&6; }
if ${ac_cv_prog_cc_g+:} false; then :
$as_echo_n "(cached) " >&6
else
ac_save_c_werror_flag=$ac_c_werror_flag
ac_c_werror_flag=yes
ac_cv_prog_cc_g=no
CFLAGS="-g"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_prog_cc_g=yes
else
CFLAGS=""
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
else
ac_c_werror_flag=$ac_save_c_werror_flag
CFLAGS="-g"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_prog_cc_g=yes
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_c_werror_flag=$ac_save_c_werror_flag
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
$as_echo "$ac_cv_prog_cc_g" >&6; }
if test "$ac_test_CFLAGS" = set; then
CFLAGS=$ac_save_CFLAGS
elif test $ac_cv_prog_cc_g = yes; then
if test "$GCC" = yes; then
CFLAGS="-g -O2"
else
CFLAGS="-g"
fi
else
if test "$GCC" = yes; then
CFLAGS="-O2"
else
CFLAGS=
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
if ${ac_cv_prog_cc_c89+:} false; then :
$as_echo_n "(cached) " >&6
else
ac_cv_prog_cc_c89=no
ac_save_CC=$CC
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#include
struct stat;
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
struct buf { int x; };
FILE * (*rcsopen) (struct buf *, struct stat *, int);
static char *e (p, i)
char **p;
int i;
{
return p[i];
}
static char *f (char * (*g) (char **, int), char **p, ...)
{
char *s;
va_list v;
va_start (v,p);
s = g (p, va_arg (v,int));
va_end (v);
return s;
}
/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has
function prototypes and stuff, but not '\xHH' hex character constants.
These don't provoke an error unfortunately, instead are silently treated
as 'x'. The following induces an error, until -std is added to get
proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an
array size at least. It's necessary to write '\x00'==0 to get something
that's true only with -std. */
int osf4_cc_array ['\x00' == 0 ? 1 : -1];
/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
inside strings and character constants. */
#define FOO(x) 'x'
int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
int test (int i, double x);
struct s1 {int (*f) (int a);};
struct s2 {int (*f) (double a);};
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
int argc;
char **argv;
int
main ()
{
return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];
;
return 0;
}
_ACEOF
for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
do
CC="$ac_save_CC $ac_arg"
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_prog_cc_c89=$ac_arg
fi
rm -f core conftest.err conftest.$ac_objext
test "x$ac_cv_prog_cc_c89" != "xno" && break
done
rm -f conftest.$ac_ext
CC=$ac_save_CC
fi
# AC_CACHE_VAL
case "x$ac_cv_prog_cc_c89" in
x)
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
$as_echo "none needed" >&6; } ;;
xno)
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
$as_echo "unsupported" >&6; } ;;
*)
CC="$CC $ac_cv_prog_cc_c89"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
esac
if test "x$ac_cv_prog_cc_c89" != xno; then :
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
if ${am_cv_prog_cc_c_o+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
# Make sure it works both with $CC and with simple cc.
# Following AC_PROG_CC_C_O, we do the test twice because some
# compilers refuse to overwrite an existing .o file with -o,
# though they will create one.
am_cv_prog_cc_c_o=yes
for am_i in 1 2; do
if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
ac_status=$?
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } \
&& test -f conftest2.$ac_objext; then
: OK
else
am_cv_prog_cc_c_o=no
break
fi
done
rm -f core conftest*
unset am_i
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
$as_echo "$am_cv_prog_cc_c_o" >&6; }
if test "$am_cv_prog_cc_c_o" != yes; then
# Losing compiler, so override with the script.
# FIXME: It is wrong to rewrite CC.
# But if we don't then we get into trouble of one sort or another.
# A longer-term fix would be to have automake use am__CC in this case,
# and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
CC="$am_aux_dir/compile $CC"
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
depcc="$CC" am_compiler_list=
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
$as_echo_n "checking dependency style of $depcc... " >&6; }
if ${am_cv_CC_dependencies_compiler_type+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
# We make a subdir and do the tests there. Otherwise we can end up
# making bogus files that we don't know about and never remove. For
# instance it was reported that on HP-UX the gcc test will end up
# making a dummy file named 'D' -- because '-MD' means "put the output
# in D".
rm -rf conftest.dir
mkdir conftest.dir
# Copy depcomp to subdir because otherwise we won't find it if we're
# using a relative directory.
cp "$am_depcomp" conftest.dir
cd conftest.dir
# We will build objects and dependencies in a subdirectory because
# it helps to detect inapplicable dependency modes. For instance
# both Tru64's cc and ICC support -MD to output dependencies as a
# side effect of compilation, but ICC will put the dependencies in
# the current directory while Tru64 will put them in the object
# directory.
mkdir sub
am_cv_CC_dependencies_compiler_type=none
if test "$am_compiler_list" = ""; then
am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
fi
am__universal=false
case " $depcc " in #(
*\ -arch\ *\ -arch\ *) am__universal=true ;;
esac
for depmode in $am_compiler_list; do
# Setup a source with many dependencies, because some compilers
# like to wrap large dependency lists on column 80 (with \), and
# we should not choose a depcomp mode which is confused by this.
#
# We need to recreate these files for each test, as the compiler may
# overwrite some of them when testing with obscure command lines.
# This happens at least with the AIX C compiler.
: > sub/conftest.c
for i in 1 2 3 4 5 6; do
echo '#include "conftst'$i'.h"' >> sub/conftest.c
# Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
# Solaris 10 /bin/sh.
echo '/* dummy */' > sub/conftst$i.h
done
echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
# We check with '-c' and '-o' for the sake of the "dashmstdout"
# mode. It turns out that the SunPro C++ compiler does not properly
# handle '-M -o', and we need to detect this. Also, some Intel
# versions had trouble with output in subdirs.
am__obj=sub/conftest.${OBJEXT-o}
am__minus_obj="-o $am__obj"
case $depmode in
gcc)
# This depmode causes a compiler race in universal mode.
test "$am__universal" = false || continue
;;
nosideeffect)
# After this tag, mechanisms are not by side-effect, so they'll
# only be used when explicitly requested.
if test "x$enable_dependency_tracking" = xyes; then
continue
else
break
fi
;;
msvc7 | msvc7msys | msvisualcpp | msvcmsys)
# This compiler won't grok '-c -o', but also, the minuso test has
# not run yet. These depmodes are late enough in the game, and
# so weak that their functioning should not be impacted.
am__obj=conftest.${OBJEXT-o}
am__minus_obj=
;;
none) break ;;
esac
if depmode=$depmode \
source=sub/conftest.c object=$am__obj \
depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
$SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
>/dev/null 2>conftest.err &&
grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
${MAKE-make} -s -f confmf > /dev/null 2>&1; then
# icc doesn't choke on unknown options, it will just issue warnings
# or remarks (even with -Werror). So we grep stderr for any message
# that says an option was ignored or not supported.
# When given -MP, icc 7.0 and 7.1 complain thusly:
# icc: Command line warning: ignoring option '-M'; no argument required
# The diagnosis changed in icc 8.0:
# icc: Command line remark: option '-MP' not supported
if (grep 'ignoring option' conftest.err ||
grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
am_cv_CC_dependencies_compiler_type=$depmode
break
fi
fi
done
cd ..
rm -rf conftest.dir
else
am_cv_CC_dependencies_compiler_type=none
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
if
test "x$enable_dependency_tracking" != xno \
&& test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
am__fastdepCC_TRUE=
am__fastdepCC_FALSE='#'
else
am__fastdepCC_TRUE='#'
am__fastdepCC_FALSE=
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
$as_echo_n "checking how to run the C preprocessor... " >&6; }
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
CPP=
fi
if test -z "$CPP"; then
if ${ac_cv_prog_CPP+:} false; then :
$as_echo_n "(cached) " >&6
else
# Double quotes because CPP needs to be expanded
for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
do
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
# Use a header file that comes with gcc, so configuring glibc
# with a fresh cross-compiler works.
# Prefer to if __STDC__ is defined, since
# exists even on freestanding compilers.
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp. "Syntax error" is here to catch this case.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#ifdef __STDC__
# include
#else
# include
#endif
Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
else
# Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext
# OK, works on sane cases. Now check whether nonexistent headers
# can be detected and how.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
# Broken: success on invalid input.
continue
else
# Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext
done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
break
fi
done
ac_cv_prog_CPP=$CPP
fi
CPP=$ac_cv_prog_CPP
else
ac_cv_prog_CPP=$CPP
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
$as_echo "$CPP" >&6; }
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
do
# Use a header file that comes with gcc, so configuring glibc
# with a fresh cross-compiler works.
# Prefer to if __STDC__ is defined, since
# exists even on freestanding compilers.
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp. "Syntax error" is here to catch this case.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#ifdef __STDC__
# include
#else
# include
#endif
Syntax error
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
else
# Broken: fails on valid input.
continue
fi
rm -f conftest.err conftest.i conftest.$ac_ext
# OK, works on sane cases. Now check whether nonexistent headers
# can be detected and how.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
# Broken: success on invalid input.
continue
else
# Passes both tests.
ac_preproc_ok=:
break
fi
rm -f conftest.err conftest.i conftest.$ac_ext
done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.i conftest.err conftest.$ac_ext
if $ac_preproc_ok; then :
else
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details" "$LINENO" 5; }
fi
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
# Extract the first word of "perl", so it can be a program name with args.
set dummy perl; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_path_PERL+:} false; then :
$as_echo_n "(cached) " >&6
else
case $PERL in
[\\/]* | ?:[\\/]*)
ac_cv_path_PERL="$PERL" # Let the user override the test with a path.
;;
*)
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_path_PERL="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
;;
esac
fi
PERL=$ac_cv_path_PERL
if test -n "$PERL"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $PERL" >&5
$as_echo "$PERL" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
# Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_STRIP+:} false; then :
$as_echo_n "(cached) " >&6
else
if test -n "$STRIP"; then
ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
ac_cv_prog_STRIP="strip"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
test -z "$ac_cv_prog_STRIP" && ac_cv_prog_STRIP="true"
fi
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
$as_echo "$STRIP" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
# Checks for header files.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
$as_echo_n "checking for ANSI C header files... " >&6; }
if ${ac_cv_header_stdc+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#include
#include
#include
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_header_stdc=yes
else
ac_cv_header_stdc=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
if test $ac_cv_header_stdc = yes; then
# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "memchr" >/dev/null 2>&1; then :
else
ac_cv_header_stdc=no
fi
rm -f conftest*
fi
if test $ac_cv_header_stdc = yes; then
# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "free" >/dev/null 2>&1; then :
else
ac_cv_header_stdc=no
fi
rm -f conftest*
fi
if test $ac_cv_header_stdc = yes; then
# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
if test "$cross_compiling" = yes; then :
:
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#include
#if ((' ' & 0x0FF) == 0x020)
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
#else
# define ISLOWER(c) \
(('a' <= (c) && (c) <= 'i') \
|| ('j' <= (c) && (c) <= 'r') \
|| ('s' <= (c) && (c) <= 'z'))
# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
#endif
#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
int
main ()
{
int i;
for (i = 0; i < 256; i++)
if (XOR (islower (i), ISLOWER (i))
|| toupper (i) != TOUPPER (i))
return 2;
return 0;
}
_ACEOF
if ac_fn_c_try_run "$LINENO"; then :
else
ac_cv_header_stdc=no
fi
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
$as_echo "$ac_cv_header_stdc" >&6; }
if test $ac_cv_header_stdc = yes; then
$as_echo "#define STDC_HEADERS 1" >>confdefs.h
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible" >&5
$as_echo_n "checking for sys/wait.h that is POSIX.1 compatible... " >&6; }
if ${ac_cv_header_sys_wait_h+:} false; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include
#include
#ifndef WEXITSTATUS
# define WEXITSTATUS(stat_val) ((unsigned int) (stat_val) >> 8)
#endif
#ifndef WIFEXITED
# define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
#endif
int
main ()
{
int s;
wait (&s);
s = WIFEXITED (s) ? WEXITSTATUS (s) : 1;
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_header_sys_wait_h=yes
else
ac_cv_header_sys_wait_h=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h" >&5
$as_echo "$ac_cv_header_sys_wait_h" >&6; }
if test $ac_cv_header_sys_wait_h = yes; then
$as_echo "#define HAVE_SYS_WAIT_H 1" >>confdefs.h
fi
for ac_header in errno.h fcntl.h libutil.h stdlib.h string.h sched.h sys/ioctl.h sys/wait.h sys/resource.h stddef.h
do :
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
_ACEOF
fi
done
for ac_header in termios.h unistd.h stdint.h time.h getopt.h regex.h curses.h termcap.h
do :
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
_ACEOF
fi
done
for ac_header in term.h ncurses/term.h
do :
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "#ifdef HAVE_CURSES_H
#include
#endif
"
if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
_ACEOF
fi
done
# Found this in configure.ac for 'top':
# The third argument to tputs is a putc-like function that takes an
# argument. On most systems that argument is an int, but on some (you
# know who you are, Solaris!) it is a char. Determine which:
_savedwerror_flag=$ac_c_werror_flag
ac_c_werror_flag=yes # make $CC fail after warning
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking argument type of tputs putc function" >&5
$as_echo_n "checking argument type of tputs putc function... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#ifdef HAVE_CURSES_H
# include
# ifdef HAVE_TERM_H
# include
# else
# ifdef HAVE_NCURSES_TERM_H /* cygwin? AIX? */
# include