dmbcs/i-bash
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Imported from ../bash-2.05a.tar.gz.

Browse source
This commit is contained in:
Jari Aalto 2001-11-13 17:56:06 +00:00
commit f73dda092b
303 changed files with 37069 additions and 28812 deletions
Download patch file Download diff file Expand all files Collapse all files

1
examples/complete/complete-examples
View file

@ -476,6 +476,7 @@ complete -A hostname rsh telnet rlogin ftp ping xping host traceroute nslookup
complete -A hostname rxterm rxterm3 rxvt2
complete -u su
complete -g newgrp groupdel groupmod
complete -f -X '!*.+(ps|PS)' gs gv ghostview psselect pswrap
complete -f -X '!*.+(dvi|DVI)' dvips xdvi dviselect dvitype catdvi

43
examples/complete/complete.gnu-longopt Normal file
View file

@ -0,0 +1,43 @@
#
# Originally from:
#
#Message-ID: <3B13EC65.179451AE@wanadoo.fr>
#Date: Tue, 29 May 2001 20:37:25 +0200
#From: Manu Rouat <emmanuel.rouat@wanadoo.fr>
#Subject: [bash] Universal command options completion?
#
#
#In the recent versions of bash (after 2.04) programmable
#completion is available. A useful completion function
#is , for a particular command, to enumerate all flags
#that can be used in the command. Now, most GNU unix
#commands have so-called 'long options' for example:
#
#ls --color=always --no-group --size
#
#and these are all listed when you issue a '--help' flag.
#So the idea is to use that, then parse the output of the
#'--help' and reinject this to compgen. The basis of the
#following 'universal' completion funtion was the _configure_func'
#written by Ian McDonnald (or is it Chet Ramey ?)
#A dedicated function will always be better, but this is quite
#convenient. I chose to use 'long options' because they are
#easy to parse and explicit too (it's the point I guess...)
#Lots of room for improvement !
_longopt_func ()
{
case "$2" in
-*) ;;
*) return ;;
esac
case "$1" in
\~*) eval cmd=$1 ;;
*) cmd="$1" ;;
esac
COMPREPLY=( $("$cmd" --help | sed -e '/--/!d' -e 's/.*--\([^ ]*\).*/--\1/'| \
grep ^"$2" |sort -u) )
}
complete -o default -F _longopt_func ldd wget bash id info # some examples that work

26
examples/functions/autoload
View file

@ -51,7 +51,7 @@ autoload()
# yet defined, but we don't have enough information to do that here.
#
if [ $# -eq 0 ] ; then
echo "usage: autoload function [function...]"
echo "usage: autoload function [function...]" >&2
return 1
fi
@ -60,7 +60,7 @@ autoload()
#
if [ -z "$FPATH" ] ; then
echo autoload: FPATH not set
echo autoload: FPATH not set or null >&2
return 1
fi
@ -71,17 +71,25 @@ autoload()
# The path splitting command is taken from Kernighan and Pike
#
fp=$(echo $FPATH | sed 's/^:/.:/
s/::/:.:/g
s/:$/:./
s/:/ /g')
# fp=$(echo $FPATH | sed 's/^:/.:/
# s/::/:.:/g
# s/:$/:./
# s/:/ /g')
# replaced with builtin mechanisms 2001 Oct 10
fp=${FPATH/#:/.:}
fp=${fp//::/:.:}
fp=${fp/%:/:.}
fp=${fp//:/ }
for FUNC in $args ; do
#
# We're blowing away the arguments to autoload here...
# We have to; there are no arrays.
# We have to; there are no arrays (well, there are, but
# this doesn't use them yet).
#
set $fp
set -- $fp
while [ $# -ne 0 ] ; do
if [ -f $1/$FUNC ] ; then
@ -91,7 +99,7 @@ autoload()
done
if [ $# -eq 0 ] ; then
echo "$FUNC: autoload function not found"
echo "$FUNC: autoload function not found" >&2
continue
fi

2
examples/functions/autoload.v2
View file

@ -18,7 +18,7 @@
# -p print in a format that can be reused as input
# -u unset each function and remove it from the autoload list
#
# The first cut of this was by Bill Trost, trost@reed.bitnet
# The first cut of this was by Bill Trost, trost@reed.edu
#
# Chet Ramey
# chet@ins.CWRU.Edu

109
examples/functions/coproc.bash Normal file
View file

@ -0,0 +1,109 @@
# coprocess.bash
#
# vi:set sts=2 sw=2 ai:
#
coprocess_pid=
#
# coprocess - Start, control, and end coprocesses.
#
function coprocess ()
{
while (( $# > 0 )) ; do
case "$1" in
#
# coprocess close
#
c|cl|clo|clos|close)
shift
exec 61>&- 62<&-
coprocess_pid=
if [ "$1" = "-SIGPIPE" ] ; then
# Only print message in an interactive shell
case "$-" in
*i*)
echo 'SIGPIPE' >&2
;;
esac
return 1
fi
return 0
;;
#
# coprocess open
#
o|op|ope|open)
shift
local fifo="/var/tmp/coprocess.$$.$RANDOM"
local cmd="/bin/bash"
if (( $# > 0 )) ; then
cmd="$@"
fi
mkfifo "$fifo.in" || return $?
mkfifo "$fifo.out" || {
ret=$?
rm -f "$fifo.in"
return $?
}
( "$@" <$fifo.in >$fifo.out ; rm -f "$fifo.in" "$fifo.out" ) &
coprocess_pid=$!
exec 61>$fifo.in 62<$fifo.out
return 0
;;
#
# coprocess print - write to the coprocess
#
p|pr|pri|prin|print)
shift
local old_trap=$(trap -p SIGPIPE)
trap 'coprocess close -SIGPIPE' SIGPIPE
if [ $# -eq 1 -a "$1" = "--stdin" ] ; then
cat >&61
else
echo "$@" >&61
fi
local ret=$?
eval "$old_trap"
return $ret
;;
#
# coprocess read - read from the coprocess
#
r|re|rea|read)
shift
local old_trap=$(trap -p SIGPIPE)
trap '_coprocess_close -SIGPIPE' SIGPIPE
builtin read "$@" <&62
local ret=$?
eval "$old_trap"
return $ret
;;
s|st|sta|stat|statu|status)
if [ -z "$coprocess_pid" ] ; then
echo 'no active coprocess'
return 1
else
echo " coprocess is active [$coprocess_pid]"
return 0
fi
;;
*)
coprocess print "$@"
return $?
;;
esac
shift
done
coprocess status
return $?
}

53
examples/functions/coshell.README Normal file
View file

@ -0,0 +1,53 @@
Date: Fri, 21 Sep 2001 14:50:29 -0400
From: "Jason M. Felice" <jfelice@cronosys.com>
To: bash-maintainers@gnu.org, chet@po.cwru.edu
Subject: Bash co-processes functions
Message-ID: <20010921145029.A6093@argo.eraserhead.net>
Mime-Version: 1.0
Attached to this message you will find coprocess.bash and coshell.bash.
Here's a brief synopsis of use:
coprocess open telnet localhost
while coprocess read il ; do
echo "$il"
case "$il" in
*ogin:*)
coprocess print 'user'
;;
*ord:*)
echo 'pass' |coprocess print --stdin
;;
*$ *)
coprocess print 'exit'
break
;;
esac
done
coprocess close
And here's an example of the coshell function:
coshell open ssh -l root otherbox
coshell eval hostname
coshell ls -l
if coshell test -d /tmp ; then echo 'otherbox has a /tmp!' ; fi
coshell sendfile /var/lib/upgrade.rpm /tmp/test.rpm || exit $?
coshell eval rpm -ivh /tmp/test.rpm || exit $?
coshell eval rm -f /tmp/test.rpm || exit $?
coshell close
exit 0
There are a few minor issues that I'd like to work out, but it works well
enough for me ;-) The issues are:
- Shell quoting issue with 'coshell eval' commands - need to somehow
re-quote words.
- Interactive commands hang 'coshell eval', tried redirecting in </dev/null
to executed command, but it caused strange shell exit problems.
- Some way to copy stdin from local coshell eval to remote shell. Probably
logically impossible, but would be wonderfully useful.
I'm using it for writing scripts to publish websites and other scripts to
co-located servers.

127
examples/functions/coshell.bash Normal file
View file

@ -0,0 +1,127 @@
# vi:set sts=2 sw=2 ai:
#
# coshell.bash - Control shell coprocesses (see coprocess.bash).
#
function coshell ()
{
while (( $# > 0 )) ; do
case "$1" in
#
# coshell open
#
o|op|ope|open)
shift
coprocess open "$@"
local ret=$?
# This should eat any ssh error messages or what not.
coshell eval : >/dev/null 2>&1
return $ret
;;
#
# coshell close
#
c|cl|clo|close)
shift
coprocess close "$@"
return $?
;;
#
# coshell eval
#
e|ev|eva|eval)
shift
local cookie=$RANDOM
if (( $# == 0 )) ; then
echo "coshell eval: no argumentsl" >&2
return 1
fi
if [ x$coprocess_pid = x ] ; then
echo "coshell eval: no active coshell" >&2
return 1
fi
coprocess print "$@"
coprocess print "coprocess_rc=\$?"
coprocess print "printf 'coprocess-$cookie----\n%d\n' \$coprocess_rc"
if [ x$coprocess_pid = x ] ; then
return 0
fi
local ol
while coprocess read ol ; do
case "$ol" in
*coprocess-$cookie----*)
ol="${ol%coprocess-$cookie----}"
echo -n "$ol"
break
;;
esac
echo "$ol"
done
coprocess read ol
return $ol
;;
#
# coshell sendfile
#
s|se|sen|send|sendf|sendfi|sendfil|sendfile)
shift
if (( $# != 2 )) ; then
echo "coshell sendfile: syntax is 'coshell sendfile SRC TARGET'" >&2
return 1
fi
if [ x$coprocess_pid = x ] ; then
echo "coshell sendfile: no active coshell" >&2
return 1
fi
local target=$2
if coshell test -d "$target" ; then
target="$target/${1##*/}"
fi
coprocess print "uudecode <<END_OF_FILE"
uuencode -m "$target" <$1 |coprocess print --stdin
coshell eval "END_OF_FILE"
return $?
;;
#
# coshell getfile
#
g|ge|get|getf|getfi|getfil|getfile)
shift
if (( $# != 2 )) ; then
echo "coshell getfile: syntax is 'coshell getfile SRC TARGET'" >&2
return 1
fi
if [ x$coprocess_pid = x ] ; then
echo "coshell getfile: no active coshell" >&2
return 1
fi
local target=$2
if test -d "$target" ; then
target="$target/${1##*/}"
fi
coshell eval uuencode -m "$target" "<" "$1" |uudecode
return $?
;;
*)
coshell eval "$@"
return $?
;;
esac
shift
done
coprocess status
return $?
}

10
examples/loadables/Makefile.in
View file

@ -66,9 +66,9 @@ INC = -I. -I.. -I$(topdir) -I$(topdir)/lib -I$(topdir)/builtins \
ALLPROG = print truefalse sleep pushd finfo logname basename dirname \
tty pathchk tee head mkdir rmdir sprintf printenv id whoami \
uname sync push ln unlink cut realpath
OTHERPROG = necho getconf hello cat
tty pathchk tee head mkdir rmdir printenv id whoami \
uname sync push ln unlink cut realpath getconf
OTHERPROG = necho hello cat
all: $(SHOBJ_STATUS)
@ -86,9 +86,6 @@ unsupported:
everything: supported others
sprintf: sprintf.o
$(SHOBJ_LD) $(SHOBJ_LDFLAGS) $(SHOBJ_XLDFLAGS) -o $@ sprintf.o $(SHOBJ_LIBS)
print: print.o
$(SHOBJ_LD) $(SHOBJ_LDFLAGS) $(SHOBJ_XLDFLAGS) -o $@ print.o $(SHOBJ_LIBS)
@ -207,7 +204,6 @@ pathchk.o: pathchk.c
tee.o: tee.c
head.o: head.c
rmdir.o: rmdir.c
sprintf.o: sprintf.c
necho.o: necho.c
getconf.o: getconf.c
hello.o: hello.c

1
examples/loadables/finfo.c
View file

@ -348,6 +348,7 @@ int flags;
}
#ifndef NOBUILTIN
int
finfo_builtin(list)
WORD_LIST *list;
{

714
examples/loadables/getconf.c
View file

@ -40,6 +40,14 @@
* Chet Ramey <chet@po.cwru.edu>
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#include <stdio.h>
#include <limits.h>
#include <locale.h>
@ -52,6 +60,12 @@
#include "common.h"
#include "bashgetopt.h"
#include "getconf.h"
#ifndef errno
extern int errno;
#endif
struct conf_variable
{
const char *name;
@ -59,9 +73,16 @@ struct conf_variable
long value;
};
/* Some systems do not define these; use POSIX.2 minimum recommended values. */
#ifndef _POSIX2_COLL_WEIGHTS_MAX
# define _POSIX2_COLL_WEIGHTS_MAX 2
#ifndef HAVE_CONFSTR
static size_t confstr __P((int, char *, size_t));
#endif
#ifndef HAVE_SYSCONF
static long sysconf __P((int));
#endif
#ifndef HAVE_PATHCONF
static long pathconf __P((const char *, int));
#endif
static const struct conf_variable conf_table[] =
@ -84,25 +105,90 @@ static const struct conf_variable conf_table[] =
{ "LFS64_LINTFLAGS", CONFSTR, _CS_LFS64_LINTFLAGS },
#endif
/* Single UNIX Specification version 2 Configurable Variable Values */
/* Single UNIX Specification version 2 Configurable Variable Values. The
SYSCONF variables say whether or not the appropriate CONFSTR variables
are available. */
#if defined (_SC_XBS5_ILP32_OFF32)
{ "XBS5_ILP32_OFF32", SYSCONF, _SC_XBS5_ILP32_OFF32 },
{ "_XBS5_ILP32_OFF32", SYSCONF, _SC_XBS5_ILP32_OFF32 },
#endif
#if defined (_CS_XBS5_ILP32_OFF32_CFLAGS)
{ "XBS5_ILP32_OFF32_CFLAGS", CONFSTR, _CS_XBS5_ILP32_OFF32_CFLAGS },
{ "XBS5_ILP32_OFF32_LDFLAGS", CONFSTR, _CS_XBS5_ILP32_OFF32_LDFLAGS },
{ "XBS5_ILP32_OFF32_LIBS", CONFSTR, _CS_XBS5_ILP32_OFF32_LIBS },
{ "XBS5_ILP32_OFF32_LINTFLAGS", CONFSTR, _CS_XBS5_ILP32_OFF32_LINTFLAGS },
#endif
#if defined (_SC_XBS5_ILP32_OFFBIG)
{ "XBS5_ILP32_OFFBIG", SYSCONF, _SC_XBS5_ILP32_OFFBIG },
{ "_XBS5_ILP32_OFFBIG", SYSCONF, _SC_XBS5_ILP32_OFFBIG },
#endif
#if defined (_CS_XBS5_ILP32_OFFBIG_CFLAGS)
{ "XBS5_ILP32_OFFBIG_CFLAGS", CONFSTR, _CS_XBS5_ILP32_OFFBIG_CFLAGS },
{ "XBS5_ILP32_OFFBIG_LDFLAGS", CONFSTR, _CS_XBS5_ILP32_OFFBIG_LDFLAGS },
{ "XBS5_ILP32_OFFBIG_LIBS", CONFSTR, _CS_XBS5_ILP32_OFFBIG_LIBS },
{ "XBS5_ILP32_OFFBIG_LINTFLAGS", CONFSTR, _CS_XBS5_ILP32_OFFBIG_LINTFLAGS },
#endif
#if defined (_SC_XBS5_LP64_OFF64)
{ "XBS5_LP64_OFF64", SYSCONF, _SC_XBS5_LP64_OFF64 },
{ "_XBS5_LP64_OFF64", SYSCONF, _SC_XBS5_LP64_OFF64 },
#endif
#if defined (_CS_XBS5_LP64_OFF64_CFLAGS)
{ "XBS5_LP64_OFF64_CFLAGS", CONFSTR, _CS_XBS5_LP64_OFF64_CFLAGS },
{ "XBS5_LP64_OFF64_LDFLAGS", CONFSTR, _CS_XBS5_LP64_OFF64_LDFLAGS },
{ "XBS5_LP64_OFF64_LIBS", CONFSTR, _CS_XBS5_LP64_OFF64_LIBS },
{ "XBS5_LP64_OFF64_LINTFLAGS", CONFSTR, _CS_XBS5_LP64_OFF64_LINTFLAGS },
#endif
#if defined (_SC_XBS5_LPBIG_OFFBIG)
{ "XBS5_LPBIG_OFFBIG", SYSCONF, _SC_XBS5_LPBIG_OFFBIG },
{ "_XBS5_LPBIG_OFFBIG", SYSCONF, _SC_XBS5_LPBIG_OFFBIG },
#endif
#if defined (_CS_XBS5_LPBIG_OFFBIG_CFLAGS)
{ "XBS5_LPBIG_OFFBIG_CFLAGS", CONFSTR, _CS_XBS5_LPBIG_OFFBIG_CFLAGS },
{ "XBS5_LPBIG_OFFBIG_LDFLAGS", CONFSTR, _CS_XBS5_LPBIG_OFFBIG_LDFLAGS },
{ "XBS5_LPBIG_OFFBIG_LIBS", CONFSTR, _CS_XBS5_LPBIG_OFFBIG_LIBS },
{ "XBS5_LPBIG_OFFBIG_LINTFLAGS", CONFSTR, _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS },
#endif /* _CS_XBS5_ILP32_OFF32_CFLAGS */
#endif
/* Single UNIX Specification version 3 (POSIX.1-200x) Configurable Variable
Values. The SYSCONF variables say whether or not the appropriate CONFSTR
variables are available. */
#if defined (_SC_POSIX_V6_ILP32_OFF32)
{ "_POSIX_V6_ILP32_OFF32", SYSCONF, _SC_POSIX_V6_ILP32_OFF32 },
#endif
#if defined (_CS_POSIX_V6_ILP32_OFF32_CFLAGS)
{ "POSIX_V6_ILP32_OFF32_CFLAGS", CONFSTR, _CS_POSIX_V6_ILP32_OFF32_CFLAGS },
{ "POSIX_V6_ILP32_OFF32_LDFLAGS", CONFSTR, _CS_POSIX_V6_ILP32_OFF32_LDFLAGS },
{ "POSIX_V6_ILP32_OFF32_LIBS", CONFSTR, _CS_POSIX_V6_ILP32_OFF32_LIBS },
{ "POSIX_V6_ILP32_OFF32_LINTFLAGS", CONFSTR, _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS },
#endif
#if defined (_SC_POSIX_V6_ILP32_OFFBIG)
{ "_POSIX_V6_ILP32_OFFBIG", SYSCONF, _SC_POSIX_V6_ILP32_OFFBIG },
#endif
#if defined (_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS)
{ "POSIX_V6_ILP32_OFFBIG_CFLAGS", CONFSTR, _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS },
{ "POSIX_V6_ILP32_OFFBIG_LDFLAGS", CONFSTR, _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS },
{ "POSIX_V6_ILP32_OFFBIG_LIBS", CONFSTR, _CS_POSIX_V6_ILP32_OFFBIG_LIBS },
{ "POSIX_V6_ILP32_OFFBIG_LINTFLAGS", CONFSTR, _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS },
#endif
#if defined (_SC_POSIX_V6_LP64_OFF64)
{ "_POSIX_V6_LP64_OFF64", SYSCONF, _SC_POSIX_V6_LP64_OFF64 },
#endif
#if defined (_CS_POSIX_V6_LP64_OFF64_CFLAGS)
{ "POSIX_V6_LP64_OFF64_CFLAGS", CONFSTR, _CS_POSIX_V6_LP64_OFF64_CFLAGS },
{ "POSIX_V6_LP64_OFF64_LDFLAGS", CONFSTR, _CS_POSIX_V6_LP64_OFF64_LDFLAGS },
{ "POSIX_V6_LP64_OFF64_LIBS", CONFSTR, _CS_POSIX_V6_LP64_OFF64_LIBS },
{ "POSIX_V6_LP64_OFF64_LINTFLAGS", CONFSTR, _CS_POSIX_V6_LP64_OFF64_LINTFLAGS },
#endif
#if defined (_SC_POSIX_V6_LPBIG_OFFBIG)
{ "_POSIX_V6_LPBIG_OFFBIG", SYSCONF, _SC_POSIX_V6_LPBIG_OFFBIG },
#endif
#if defined (_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS)
{ "POSIX_V6_LPBIG_OFFBIG_CFLAGS", CONFSTR, _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS },
{ "POSIX_V6_LPBIG_OFFBIG_LDFLAGS", CONFSTR, _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS },
{ "POSIX_V6_LPBIG_OFFBIG_LIBS", CONFSTR, _CS_POSIX_V6_LPBIG_OFFBIG_LIBS },
{ "POSIX_V6_LPBIG_OFFBIG_LINTFLAGS", CONFSTR, _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS },
#endif
/* POSIX.2 Utility Limit Minimum Values */
#ifdef _POSIX2_BC_BASE_MAX
@ -157,99 +243,274 @@ static const struct conf_variable conf_table[] =
#endif
/* POSIX.1 Minimum Values */
#ifdef _POSIX_ARG_MAX
{ "_POSIX_ARG_MAX", CONSTANT, _POSIX_ARG_MAX },
#else
{ "_POSIX_ARG_MAX", G_UNDEF, -1 },
#endif
#ifdef _POSIX_CHILD_MAX
{ "_POSIX_CHILD_MAX", CONSTANT, _POSIX_CHILD_MAX },
#else
{ "_POSIX_CHILD_MAX", G_UNDEF, -1 },
#endif
#ifdef _POSIX_LINK_MAX
{ "_POSIX_LINK_MAX", CONSTANT, _POSIX_LINK_MAX },
#else
{ "_POSIX_LINK_MAX", G_UNDEF, -1 },
#endif
#ifdef _POSIX_MAX_CANON
{ "_POSIX_MAX_CANON", CONSTANT, _POSIX_MAX_CANON },
#else
{ "_POSIX_MAX_CANON", G_UNDEF, -1 },
#endif
#ifdef _POSIX_MAX_INPUT
{ "_POSIX_MAX_INPUT", CONSTANT, _POSIX_MAX_INPUT },
#else
{ "_POSIX_MAX_INPUT", G_UNDEF, -1 },
#endif
#ifdef _POSIX_NAME_MAX
{ "_POSIX_NAME_MAX", CONSTANT, _POSIX_NAME_MAX },
#else
{ "_POSIX_NAME_MAX", G_UNDEF, -1 },
#endif
#ifdef _POSIX_NGROUPS_MAX
{ "_POSIX_NGROUPS_MAX", CONSTANT, _POSIX_NGROUPS_MAX },
#else
{ "_POSIX_NGROUPS_MAX", G_UNDEF, -1 },
#endif
#ifdef _POSIX_OPEN_MAX
{ "_POSIX_OPEN_MAX", CONSTANT, _POSIX_OPEN_MAX },
{ "_POSIX_PATH_MAX", CONSTANT, _POSIX_PIPE_BUF },
#else
{ "_POSIX_OPEN_MAX", G_UNDEF, -1 },
#endif
#ifdef _POSIX_PATH_MAX
{ "_POSIX_PATH_MAX", CONSTANT, _POSIX_PATH_MAX },
#else
{ "_POSIX_PATH_MAX", G_UNDEF, -1 },
#endif
#ifdef _POSIX_PIPE_BUF
{ "_POSIX_PIPE_BUF", CONSTANT, _POSIX_PIPE_BUF },
#else
{ "_POSIX_PIPE_BUF", G_UNDEF, -1 },
#endif
#ifdef _POSIX_SSIZE_MAX
{ "_POSIX_SSIZE_MAX", CONSTANT, _POSIX_SSIZE_MAX },
#else
{ "_POSIX_SSIZE_MAX", G_UNDEF, -1 },
#endif
#ifdef _POSIX_STREAM_MAX
{ "_POSIX_STREAM_MAX", CONSTANT, _POSIX_STREAM_MAX },
#else
{ "_POSIX_STREAM_MAX", G_UNDEF, -1 },
#endif
#ifdef _POSIX_TZNAME_MAX
{ "_POSIX_TZNAME_MAX", CONSTANT, _POSIX_TZNAME_MAX },
#else
{ "_POSIX_TZNAME_MAX", G_UNDEF, -1 },
#endif
/* POSIX.2 Symbolic Utility Limits */
/* POSIX.2/XPG 4.2 (and later) Symbolic Utility Limits */
#ifdef _SC_BC_BASE_MAX
{ "BC_BASE_MAX", SYSCONF, _SC_BC_BASE_MAX },
#endif
#ifdef _SC_BC_DIM_MAX
{ "BC_DIM_MAX", SYSCONF, _SC_BC_DIM_MAX },
#endif
#ifdef _SC_BC_SCALE_MAX
{ "BC_SCALE_MAX", SYSCONF, _SC_BC_SCALE_MAX },
#endif
#ifdef _SC_BC_STRING_MAX
{ "BC_STRING_MAX", SYSCONF, _SC_BC_STRING_MAX },
#endif
#ifdef CHARCLASS_NAME_MAX
{ "CHARCLASS_NAME_MAX", CONSTANT, CHARCLASS_NAME_MAX },
#endif
#ifdef _SC_COLL_WEIGHTS_MAX
{ "COLL_WEIGHTS_MAX", SYSCONF, _SC_COLL_WEIGHTS_MAX },
#endif
#ifdef _SC_EXPR_NEST_MAX
{ "EXPR_NEST_MAX", SYSCONF, _SC_EXPR_NEST_MAX },
#endif
#ifdef _SC_LINE_MAX
{ "LINE_MAX", SYSCONF, _SC_LINE_MAX },
#endif
# ifdef NL_ARGMAX
{ "NL_ARGMAX", CONSTANT, NL_ARGMAX },
#endif
#ifdef NL_LANGMAX
{ "NL_LANGMAX", CONSTANT, NL_LANGMAX },
#endif
#ifdef NL_MSGMAX
{ "NL_MSGMAX", CONSTANT, NL_MSGMAX },
#endif
#ifdef NL_NMAX
{ "NL_NMAX", CONSTANT, NL_NMAX },
#endif
#ifdef NL_SETMAX
{ "NL_SETMAX", CONSTANT, NL_SETMAX },
#endif
#ifdef NL_TEXTMAX
{ "NL_TEXTMAX", CONSTANT, NL_TEXTMAX },
#endif
#ifdef _SC_RE_DUP_MAX
{ "RE_DUP_MAX", SYSCONF, _SC_RE_DUP_MAX },
#endif
/* POSIX.2 Optional Facility Configuration Values */
#ifdef _SC_2_C_BIND
{ "POSIX2_C_BIND", SYSCONF, _SC_2_C_BIND },
{ "_POSIX2_C_BIND", SYSCONF, _SC_2_C_BIND },
#else
{ "POSIX2_C_BIND", G_UNDEF, -1 },
{ "_POSIX2_C_BIND", G_UNDEF, -1 },
#endif
#ifdef _SC_2_C_DEV
{ "POSIX2_C_DEV", SYSCONF, _SC_2_C_DEV },
{ "_POSIX2_C_DEV", SYSCONF, _SC_2_C_DEV },
#else
{ "POSIX2_C_DEV", G_UNDEF, -1 },
{ "_POSIX2_C_DEV", G_UNDEF, -1 },
#endif
#if defined (_SC_2_C_VERSION)
{ "POSIX2_C_VERSION", SYSCONF, _SC_2_C_VERSION },
{ "_POSIX2_C_VERSION", SYSCONF, _SC_2_C_VERSION },
#else
{ "POSIX2_C_VERSION", G_UNDEF, -1 },
{ "_POSIX2_C_VERSION", G_UNDEF, -1 },
#endif
#if defined (_SC_2_CHAR_TERM)
{ "POSIX2_CHAR_TERM", SYSCONF, _SC_2_CHAR_TERM },
{ "_POSIX2_CHAR_TERM", SYSCONF, _SC_2_CHAR_TERM },
#else
{ "POSIX2_CHAR_TERM", G_UNDEF, -1 },
{ "_POSIX2_CHAR_TERM", G_UNDEF, -1 },
#endif
#ifdef _SC_2_FORT_DEV
{ "POSIX2_FORT_DEV", SYSCONF, _SC_2_FORT_DEV },
{ "_POSIX2_FORT_DEV", SYSCONF, _SC_2_FORT_DEV },
#else
{ "POSIX2_FORT_DEV", G_UNDEF, -1 },
{ "_POSIX2_FORT_DEV", G_UNDEF, -1 },
#endif
#ifdef _SC_2_FORT_RUN
{ "POSIX2_FORT_RUN", SYSCONF, _SC_2_FORT_RUN },
{ "_POSIX2_FORT_RUN", SYSCONF, _SC_2_FORT_RUN },
#else
{ "POSIX2_FORT_RUN", G_UNDEF, -1 },
{ "_POSIX2_FORT_RUN", G_UNDEF, -1 },
#endif
#ifdef _SC_2_LOCALEDEF
{ "POSIX2_LOCALEDEF", SYSCONF, _SC_2_LOCALEDEF },
{ "_POSIX2_LOCALEDEF", SYSCONF, _SC_2_LOCALEDEF },
#else
{ "POSIX2_LOCALEDEF", G_UNDEF, -1 },
{ "_POSIX2_LOCALEDEF", G_UNDEF, -1 },
#endif
#ifdef _SC_2_SW_DEV
{ "POSIX2_SW_DEV", SYSCONF, _SC_2_SW_DEV },
{ "_POSIX2_SW_DEV", SYSCONF, _SC_2_SW_DEV },
#else
{ "POSIX2_SW_DEV", G_UNDEF, -1 },
{ "_POSIX2_SW_DEV", G_UNDEF, -1 },
#endif
#if defined (_SC2_UPE)
{ "POSIX2_UPE", SYSCONF, _SC_2_UPE },
{ "_POSIX2_UPE", SYSCONF, _SC_2_UPE },
#else
{ "POSIX2_UPE", G_UNDEF, -1 },
{ "_POSIX2_UPE", G_UNDEF, -1 },
#endif
#if !defined (_POSIX2_VERSION) && defined (_SC_2_VERSION)
{ "POSIX2_VERSION" SYSCONF, _SC_2_VERSION },
{ "_POSIX2_VERSION", SYSCONF, _SC_2_VERSION },
#else
{ "_POSIX2_VERSION", G_UNDEF, -1 },
#endif
#if defined (_SC_REGEX_VERSION)
{ "REGEX_VERSION", SYSCONF, _SC_REGEX_VERSION },
#else
{ "REGEX_VERSION", G_UNDEF, -1 },
#endif
#if defined (_SC_2_PBS)
{ "_POSIX2_PBS", SYSCONF, _SC_2_PBS },
{ "_POSIX2_PBS_ACCOUNTING", SYSCONF, _SC_2_PBS_ACCOUNTING },
{ "_POSIX2_PBS_LOCATE", SYSCONF, _SC_2_PBS_LOCATE },
{ "_POSIX2_PBS_MESSAGE", SYSCONF, _SC_2_PBS_MESSAGE },
{ "_POSIX2_PBS_TRACK", SYSCONF, _SC_2_PBS_TRACK },
#endif
/* POSIX.1 Configurable System Variables */
#ifdef _SC_ARG_MAX
{ "ARG_MAX", SYSCONF, _SC_ARG_MAX },
#endif
#ifdef _SC_CHILD_MAX
{ "CHILD_MAX", SYSCONF, _SC_CHILD_MAX },
#endif
#ifdef _SC_CLK_TCK
{ "CLK_TCK", SYSCONF, _SC_CLK_TCK },
#endif
#ifdef _SC_DELAYTIMER_MAX
{ "DELAYTIMER_MAX", SYSCONF, _SC_DELAYTIMER_MAX },
#endif
#ifdef _SC_NGROUPS_MAX
{ "NGROUPS_MAX", SYSCONF, _SC_NGROUPS_MAX },
#endif
#ifdef NZERO
{ "NZERO", CONSTANT, NZERO },
#endif
#ifdef _SC_OPEN_MAX
{ "OPEN_MAX", SYSCONF, _SC_OPEN_MAX },
#endif
#ifdef PASS_MAX
{ "PASS_MAX", CONSTANT, PASS_MAX },
#endif
#ifdef _SC_STREAM_MAX
{ "STREAM_MAX", SYSCONF, _SC_STREAM_MAX },
#endif
#ifdef TMP_MAX
{ "TMP_MAX", CONSTANT, TMP_MAX },
#endif
#ifdef _SC_TZNAME_MAX
{ "TZNAME_MAX", SYSCONF, _SC_TZNAME_MAX },
{ "_POSIX_JOB_CONTROL", SYSCONF, _SC_JOB_CONTROL },
{ "_POSIX_SAVED_IDS", SYSCONF, _SC_SAVED_IDS },
{ "_POSIX_VERSION", SYSCONF, _SC_VERSION },
#endif
/* POSIX.1 Optional Facility Configuration Values */
#if defined (_SC_ADVISORY_INFO)
{ "_POSIX_ADVISORY_INFO", SYSCONF, _SC_ADVISORY_INFO },
#endif
#if defined (_SC_ASYNCHRONOUS_IO)
{ "_POSIX_ASYNCHRONOUS_IO", SYSCONF, _SC_ASYNCHRONOUS_IO },
#endif
#if defined (_SC_BARRIERS)
{ "_POSIX_BARRIERS", SYSCONF, _SC_BARRIERS },
#endif
#if defined (_SC_BASE)
{ "_POSIX_BASE", SYSCONF, _SC_BASE },
#endif
#if defined (_SC_C_LANG_SUPPORT)
{ "_POSIX_C_LANG_SUPPORT", SYSCONF, _SC_C_LANG_SUPPORT },
#endif
#if defined (_SC_C_LANG_SUPPORT_R)
{ "_POSIX_C_LANG_SUPPORT_R", SYSCONF, _SC_C_LANG_SUPPORT_R },
#endif
#if defined (_SC_CLOCK_SELECTION)
{ "_POSIX_CLOCK_SELECTION", SYSCONF, _SC_CLOCK_SELECTION },
#endif
#if defined (_SC_CPUTIME)
{ "_POSIX_CPUTIME", SYSCONF, _SC_CPUTIME },
#endif
#if defined (_SC_DEVICE_IO)
{ "_POSIX_DEVICE_IO", SYSCONF, _SC_DEVICE_IO },
#endif
#if defined (_SC_DEVICE_SPECIFIC)
{ "_POSIX_DEVICE_SPECIFIC", SYSCONF, _SC_DEVICE_SPECIFIC },
#endif
#if defined (_SC_DEVICE_SPECIFIC_R)
{ "_POSIX_DEVICE_SPECIFIC_R", SYSCONF, _SC_DEVICE_SPECIFIC_R },
#endif
#if defined (_SC_FD_MGMT)
{ "_POSIX_FD_MGMT", SYSCONF, _SC_FD_MGMT },
#endif
#if defined (_SC_FIFO)
{ "_POSIX_FIFO", SYSCONF, _SC_FIFO },
#endif
#if defined (_SC_FILE_ATTRIBUTES)
{ "_POSIX_FILE_ATTRIBUTES", SYSCONF, _SC_FILE_ATTRIBUTES },
#endif
#if defined (_SC_FILE_LOCKING)
{ "_POSIX_FILE_LOCKING", SYSCONF, _SC_FILE_LOCKING },
#endif
#if defined (_SC_FILE_SYSTEM)
{ "_POSIX_FILE_SYSTEM", SYSCONF, _SC_FILE_SYSTEM },
#endif
#if defined (_SC_FSYNC)
{ "_POSIX_FSYNC", SYSCONF, _SC_FSYNC },
#endif
#if defined (_SC_JOB_CONTROL)
{ "_POSIX_JOB_CONTROL", SYSCONF, _SC_JOB_CONTROL },
#endif
#if defined (_SC_MAPPED_FILES)
{ "_POSIX_MAPPED_FILES", SYSCONF, _SC_MAPPED_FILES },
#endif
@ -265,38 +526,75 @@ static const struct conf_variable conf_table[] =
#if defined (_SC_MESSAGE_PASSING)
{ "_POSIX_MESSAGE_PASSING", SYSCONF, _SC_MESSAGE_PASSING },
#endif
#if defined (_SC_MONOTONIC_CLOCK)
{ "_POSIX_MONOTONIC_CLOCK", SYSCONF, _SC_MONOTONIC_CLOCK },
#endif
#if defined (_SC_MULTI_PROCESS)
{ "_POSIX_MULTI_PROCESS", SYSCONF, _SC_MULTI_PROCESS },
#endif
#if defined (_SC_NETWORKING)
{ "_POSIX_NETWORKING", SYSCONF, _SC_NETWORKING },
#endif
#if defined (_SC_PIPE)
{ "_POSIX_PIPE", SYSCONF, _SC_PIPE },
#endif
#if defined (SC_PRIORITIZED_IO)
{ "_POSIX_PRIORITIZED_IO", SYSCONF, _SC_PRIORITIZED_IO },
#endif
#if defined (_SC_PRIORITY_SCHEDULING)
{ "_POSIX_PRIORITY_SCHEDULING", SYSCONF, _SC_PRIORITY_SCHEDULING },
#endif
#if defined (_SC_READER_WRITER_LOCKS)
{ "_POSIX_READER_WRITER_LOCKS", SYSCONF, _SC_READER_WRITER_LOCKS },
#endif
#if defined (_SC_REALTIME_SIGNALS)
{ "_POSIX_REALTIME_SIGNALS", SYSCONF, _SC_REALTIME_SIGNALS },
#endif
#if defined (_SC_REGEXP)
{ "_POSIX_REGEXP", SYSCONF, _SC_REGEXP },
#endif
#if defined (_SC_SAVED_IDS)
{ "_POSIX_SAVED_IDS", SYSCONF, _SC_SAVED_IDS },
#endif
#if defined (_SC_SEMAPHORES)
{ "_POSIX_SEMAPHORES", SYSCONF, _SC_SEMAPHORES },
#endif
#if defined (_SC_SHARED_MEMORY_OBJECTS)
{ "_POSIX_SHARED_MEMORY_OBJECTS", SYSCONF, _SC_SHARED_MEMORY_OBJECTS },
#endif
{ "_POSIX_SHELL", CONSTANT, 1 },
#if defined (_SC_SIGNALS)
{ "_POSIX_SIGNALS", SYSCONF, _SC_SIGNALS },
#endif
#if defined (_SC_SINGLE_PROCESS)
{ "_POSIX_SINGLE_PROCESS", SYSCONF, _SC_SINGLE_PROCESS },
#endif
#if defined (_SC_SPAWN)
{ "_POSIX_SPAWN", SYSCONF, _SC_SPAWN },
#endif
#if defined (_SC_SPIN_LOCKS)
{ "_POSIX_SPIN_LOCKS", SYSCONF, _SC_SPIN_LOCKS },
#endif
#if defined (_SC_SPORADIC_SERVER)
{ "_POSIX_SPORADIC_SERVER", SYSCONF, _SC_SPORADIC_SERVER },
#endif
#if defined (_SC_SYNCHRONIZED_IO)
{ "_POSIX_SYNCHRONIZED_IO", SYSCONF, _SC_SYNCHRONIZED_IO },
#endif
#if defined (_SC_TIMERS)
{ "_POSIX_TIMERS", SYSCONF, _SC_TIMERS },
#if defined (_SC_SYSTEM_DATABASE)
{ "_POSIX_SYSTEM_DATABASE", SYSCONF, _SC_SYSTEM_DATABASE },
#endif
#if defined (_SC_THREADS)
{ "_POSIX_THREADS", SYSCONF, _SC_THREADS },
#if defined (_SC_SYSTEM_DATABASE_R)
{ "_POSIX_SYSTEM_DATABASE_R", SYSCONF, _SC_SYSTEM_DATABASE_R },
#endif
#if defined (_SC_THREADS)
#if defined (_SC_THREAD_ATTR_STACKADDR)
{ "_POSIX_THREAD_ATTR_STACKADDR", SYSCONF, _SC_THREAD_ATTR_STACKADDR },
#endif
#if defined (_SC_THREAD_ATTR_STACKSIZE)
{ "_POSIX_THREAD_ATTR_STACKSIZE", SYSCONF, _SC_THREAD_ATTR_STACKSIZE },
#endif
#if defined (_SC_THREAD_PRIORITY_SCHEDULING)
{ "_POSIX_THREAD_PRIORITY_SCHEDULING", SYSCONF, _SC_THREAD_PRIORITY_SCHEDULING },
#if defined (_SC_THREAD_CPUTIME)
{ "_POSIX_THREAD_CPUTIME", SYSCONF, _SC_THREAD_CPUTIME },
#endif
#if defined (_SC_THREAD_PRIO_INHERIT)
{ "_POSIX_THREAD_PRIO_INHERIT", SYSCONF, _SC_THREAD_PRIO_INHERIT },
@ -304,26 +602,86 @@ static const struct conf_variable conf_table[] =
#if defined (_SC_THREAD_PRIO_PROTECT)
{ "_POSIX_THREAD_PRIO_PROTECT", SYSCONF, _SC_THREAD_PRIO_PROTECT },
#endif
#if defined (_SC_THREAD_PRIORITY_SCHEDULING)
{ "_POSIX_THREAD_PRIORITY_SCHEDULING", SYSCONF, _SC_THREAD_PRIORITY_SCHEDULING },
#endif
#if defined (_SC_THREAD_PROCESS_SHARED)
{ "_POSIX_THREAD_PROCESS_SHARED", SYSCONF, _SC_THREAD_PROCESS_SHARED },
#endif
#if defined (_SC_THREAD_SAFE_FUNCTIONS)
{ "_POSIX_THREAD_SAFE_FUNCTIONS", SYSCONF, _SC_THREAD_SAFE_FUNCTIONS },
#endif
#if defined (_SC_THREAD_SPORADIC_SERVER)
{ "_POSIX_THREAD_SPORADIC_SERVER", SYSCONF, _SC_THREAD_SPORADIC_SERVER },
#endif
#if defined (_SC_THREADS)
{ "_POSIX_THREADS", SYSCONF, _SC_THREADS },
#endif
#if defined (_SC_TIMEOUTS)
{ "_POSIX_TIMEOUTS", SYSCONF, _SC_TIMEOUTS },
#endif
#if defined (_SC_TIMERS)
{ "_POSIX_TIMERS", SYSCONF, _SC_TIMERS },
#endif
#if defined (_SC_TRACE)
{ "_POSIX_TRACE", SYSCONF, _SC_TRACE },
#endif
#if defined (_SC_TRACE)
{ "_POSIX_TRACE_EVENT_FILTER",SYSCONF, _SC_TRACE_EVENT_FILTER },
#endif
#if defined (_SC_TRACE)
{ "_POSIX_TRACE_INHERIT", SYSCONF, _SC_TRACE_INHERIT },
#endif
#if defined (_SC_TRACE)
{ "_POSIX_TRACE_LOG", SYSCONF, _SC_TRACE_LOG },
#endif
#if defined (_SC_TYPED_MEMORY_OBJECTS)
{ "_POSIX_TYPED_MEMORY_OBJECTS", SYSCONF, _SC_TYPED_MEMORY_OBJECTS },
#endif
#if defined (_SC_VERSION)
{ "_POSIX_VERSION", SYSCONF, _SC_VERSION },
#endif
/* XPG 4.2 Configurable System Variables. */
#if defined (_SC_ATEXIT_MAX)
{ "ATEXIT_MAX", SYSCONF, _SC_ATEXIT_MAX },
#endif
#if defined (_SC_GETGR_R_SIZE_MAX)
{ "GETGR_R_SIZE_MAX", SYSCONF, _SC_GETGR_R_SIZE_MAX },
#endif
#if defined (_SC_GETPW_R_SIZE_MAX)
{ "GETPW_R_SIZE_MAX", SYSCONF, _SC_GETPW_R_SIZE_MAX },
#endif
#if defined (_SC_HOST_NAME_MAX)
{ "HOST_NAME_MAX", SYSCONF, _SC_HOST_NAME_MAX },
#endif
#if defined (_SC_IOV_MAX)
{ "IOV_MAX", SYSCONF, _SC_IOV_MAX },
#endif
#if defined (_SC_LOGIN_NAME_MAX)
{ "LOGIN_NAME_MAX", SYSCONF, _SC_LOGIN_NAME_MAX },
#endif
#if defined (_SC_LOGNAME_MAX)
{ "LOGNAME_MAX", SYSCONF, _SC_LOGNAME_MAX },
#endif
#if defined (_SC_PAGESIZE)
{ "PAGESIZE", SYSCONF, _SC_PAGESIZE },
#endif
#if defined (_SC_PAGE_SIZE)
{ "PAGE_SIZE", SYSCONF, _SC_PAGE_SIZE },
#endif
#if defined (_SC_SYMLOOP_MAX)
{ "SYMLOOP_MAX", SYSCONF, _SC_SYMLOOP_MAX },
#endif
#if defined (_SC_TTY_NAME_MAX)
{ "TTY_NAME_MAX", SYSCONF, _SC_TTY_NAME_MAX },
#endif
#if defined (_SC_USER_GROUPS)
{ "_POSIX_USER_GROUPS", SYSCONF, _SC_USER_GROUPS },
#endif
#if defined (_SC_USER_GROUPS_R)
{ "_POSIX_USER_GROUPS_R", SYSCONF, _SC_USER_GROUPS_R },
#endif
#if defined (_SC_AIO_LISTIO_MAX)
{ "AIO_LISTIO_MAX", SYSCONF, _SC_AIO_LISTIO_MAX },
@ -337,12 +695,6 @@ static const struct conf_variable conf_table[] =
#if defined (_SC_DELAYTIMER_MAX)
{ "DELAYTIMER_MAX", SYSCONF, _SC_DELAYTIMER_MAX },
#endif
#if defined (_SC_GETGR_R_SIZE_MAX)
{ "GETGR_R_SIZE_MAX", SYSCONF, _SC_GETGR_R_SIZE_MAX },
#endif
#if defined (_SC_GETPW_R_SIZE_MAX)
{ "GETPW_R_SIZE_MAX", SYSCONF, _SC_GETPW_R_SIZE_MAX },
#endif
#if defined (_SC_MQ_OPEN_MAX)
{ "MQ_OPEN_MAX", SYSCONF, _SC_MQ_OPEN_MAX },
#endif
@ -365,16 +717,6 @@ static const struct conf_variable conf_table[] =
{ "TIMER_MAX", SYSCONF, _SC_TIMER_MAX },
#endif
#if defined (_SC_LOGIN_NAME_MAX)
{ "LOGIN_NAME_MAX", SYSCONF, _SC_LOGIN_NAME_MAX },
#endif
#if defined (_SC_LOGNAME_MAX)
{ "LOGNAME_MAX", SYSCONF, _SC_LOGNAME_MAX },
#endif
#if defined (_SC_TTY_NAME_MAX)
{ "TTY_NAME_MAX", SYSCONF, _SC_TTY_NAME_MAX },
#endif
#if defined (_SC_THREAD_DESTRUCTOR_ITERATIONS)
{ "PTHREAD_DESTRUCTOR_ITERATIONS", SYSCONF, _SC_THREAD_DESTRUCTOR_ITERATIONS },
#endif
@ -388,43 +730,78 @@ static const struct conf_variable conf_table[] =
{ "PTHREAD_THREADS_MAX", SYSCONF, _SC_THREAD_THREADS_MAX },
#endif
/* XPG 4.2 Optional Facility Configuration Values */
#if defined (_SC_XOPEN_UNIX)
{ "_XOPEN_UNIX", SYSCONF, _SC_XOPEN_UNIX },
/* XPG 4.2 (and later) Optional Facility Configuration Values */
#if defined (_SC_XOPEN_CRYPT)
{ "_XOPEN_CRYPT", SYSCONF, _SC_XOPEN_CRYPT },
{ "_XOPEN_ENH_I18N", SYSCONF, _SC_XOPEN_ENH_I18N },
{ "_XOPEN_SHM", SYSCONF, _SC_XOPEN_SHM },
{ "_XOPEN_VERSION", SYSCONF, _SC_XOPEN_VERSION },
# if defined (_SC_XOPEN_XCU_VERSION)
{ "_XOPEN_XCU_VERSION", SYSCONF, _SC_XOPEN_XCU_VERSION },
# endif
#endif
#if defined (_SC_XOPEN_REALTIME)
{ "_XOPEN_REALTIME", SYSCONF, _SC_XOPEN_REALTIME },
{ "_XOPEN_REALTIME_THREADS", SYSCONF, _SC_XOPEN_REALTIME_THREADS },
#if defined (_SC_XOPEN_ENH_I18N)
{ "_XOPEN_ENH_I18N", SYSCONF, _SC_XOPEN_ENH_I18N },
#endif
#if defined (_SC_XOPEN_LEGACY)
{ "_XOPEN_LEGACY", SYSCONF, _SC_XOPEN_LEGACY },
#endif /* _SC_XOPEN_LEGACY */
/* Single UNIX Specification version 2 Optional Facility Configuration Values */
#if defined (_SC_XBS5_ILP32_OFF32)
{ "_XBS5_ILP32_OFF32", SYSCONF, _SC_XBS5_ILP32_OFF32 },
{ "_XBS5_ILP32_OFFBIG", SYSCONF, _SC_XBS5_ILP32_OFFBIG },
{ "_XBS5_LP64_OFF64", SYSCONF, _SC_XBS5_LP64_OFF64 },
{ "_XBS5_LPBIG_OFFBIG", SYSCONF, _SC_XBS5_LPBIG_OFFBIG },
#endif /* _SC_XBS5_ILP32_OFF32 */
#if defined (_SC_XOPEN_REALTIME)
{ "_XOPEN_REALTIME", SYSCONF, _SC_XOPEN_REALTIME },
#endif
#if defined (_SC_XOPEN_REALTIME_THREADS)
{ "_XOPEN_REALTIME_THREADS", SYSCONF, _SC_XOPEN_REALTIME_THREADS },
#endif
#if defined (_SC_XOPEN_SHM)
{ "_XOPEN_SHM", SYSCONF, _SC_XOPEN_SHM },
#endif
#if defined (_SC_XOPEN_UNIX)
{ "_XOPEN_UNIX", SYSCONF, _SC_XOPEN_UNIX },
#endif
#if defined (_SC_XOPEN_VERSION)
{ "_XOPEN_VERSION", SYSCONF, _SC_XOPEN_VERSION },
#endif
#if defined (_SC_XOPEN_XCU_VERSION)
{ "_XOPEN_XCU_VERSION", SYSCONF, _SC_XOPEN_XCU_VERSION },
#endif
#if defined (_SC_XOPEN_XPG2)
{ "_XOPEN_XPG2", SYSCONF, _SC_XOPEN_XPG2 },
#endif
#if defined (_SC_XOPEN_XPG3)
{ "_XOPEN_XPG3", SYSCONF, _SC_XOPEN_XPG3 },
#endif
#if defined (_SC_XOPEN_XPG4)
{ "_XOPEN_XPG4", SYSCONF, _SC_XOPEN_XPG4 },
#endif
#if defined (_SC_XOPEN_XPG5)
{ "_XOPEN_XPG5", SYSCONF, _SC_XOPEN_XPG5 },
#endif
/* POSIX.1 Configurable Pathname Values */
#ifdef _PC_LINK_MAX
{ "LINK_MAX", PATHCONF, _PC_LINK_MAX },
#endif
#ifdef _PC_MAX_CANON
{ "MAX_CANON", PATHCONF, _PC_MAX_CANON },
#endif
#ifdef _PC_MAX_INPUT
{ "MAX_INPUT", PATHCONF, _PC_MAX_INPUT },
#endif
#ifdef _PC_NAMW_MAX
{ "NAME_MAX", PATHCONF, _PC_NAME_MAX },
#endif
#ifdef _PC_PATH_MAX
{ "PATH_MAX", PATHCONF, _PC_PATH_MAX },
#endif
#ifdef _PC_PIPE_BUF
{ "PIPE_BUF", PATHCONF, _PC_PIPE_BUF },
#endif
#ifdef _PC_SYMLINK_MAX
{ "SYMLINK_MAX", PATHCONF, _PC_SYMLINK_MAX },
#endif
#ifdef _PC_CHOWN_RESTRICTED
{ "_POSIX_CHOWN_RESTRICTED", PATHCONF, _PC_CHOWN_RESTRICTED },
#endif
#ifdef _PC_NO_TRUNC
{ "_POSIX_NO_TRUNC", PATHCONF, _PC_NO_TRUNC },
#endif
#ifdef _PC_VDISABLE
{ "_POSIX_VDISABLE", PATHCONF, _PC_VDISABLE },
#endif
/* XPG 4.2 Configurable Pathname Values */
#if defined (_PC_FILESIZEBITS)
@ -440,6 +817,40 @@ static const struct conf_variable conf_table[] =
{ "_POSIX_SYNC_IO", PATHCONF, _PC_SYNC_IO },
#endif
/* POSIX.1-200x configurable pathname values */
#if defined (_PC_ALLOC_SIZE_MIN)
{ "POSIX_ALLOC_SIZE_MIN", PATHCONF, _PC_ALLOC_SIZE_MIN },
{ "POSIX_REC_INCR_XFER_SIZE", PATHCONF, _PC_REC_INCR_XFER_SIZE },
{ "POSIX_REC_MAX_XFER_SIZE", PATHCONF, _PC_REC_MAX_XFER_SIZE },
{ "POSIX_REC_MIN_XFER_SIZE", PATHCONF, _PC_REC_MIN_XFER_SIZE },
{ "POSIX_REC_XFER_ALIGN", PATHCONF, _PC_REC_XFER_ALIGN },
#endif
/* ANSI/ISO C, POSIX.1-200x, XPG 4.2 (and later) C language type limits. */
{ "CHAR_BIT", CONSTANT, CHAR_BIT },
{ "CHAR_MAX", CONSTANT, CHAR_MAX },
{ "CHAR_MIN", CONSTANT, CHAR_MIN },
{ "INT_BIT", CONSTANT, INT_BIT },
{ "INT_MAX", CONSTANT, INT_MAX },
{ "INT_MIN", CONSTANT, INT_MIN },
{ "LONG_BIT", CONSTANT, LONG_BIT },
{ "LONG_MAX", CONSTANT, LONG_MAX },
{ "LONG_MIN", CONSTANT, LONG_MIN },
#ifdef MB_LEN_MAX
{ "MB_LEN_MAX", CONSTANT, MB_LEN_MAX },
#endif
{ "SCHAR_MAX", CONSTANT, SCHAR_MAX },
{ "SCHAR_MIN", CONSTANT, SCHAR_MIN },
{ "SHRT_MAX", CONSTANT, SHRT_MAX },
{ "SHRT_MIN", CONSTANT, SHRT_MIN },
{ "SIZE_MAX", CONSTANT, SIZE_MAX },
{ "SSIZE_MAX", CONSTANT, SSIZE_MAX },
{ "UCHAR_MAX", CONSTANT, UCHAR_MAX },
{ "UINT_MAX", CONSTANT, UINT_MAX },
{ "ULONG_MAX", CONSTANT, ULONG_MAX },
{ "USHRT_MAX", CONSTANT, USHRT_MAX },
{ "WORD_BIT", CONSTANT, WORD_BIT },
{ NULL }
};
@ -463,7 +874,7 @@ getconf_builtin (list)
aflag = 0;
reset_internal_getopt();
while ((opt = internal_getopt (list, "ah")) != -1) {
while ((opt = internal_getopt (list, "ahv:")) != -1) {
switch (opt) {
case 'a':
aflag = 1;
@ -471,6 +882,8 @@ getconf_builtin (list)
case 'h':
getconf_help();
return(EXECUTION_SUCCESS);
case 'v':
break; /* ignored */
default:
builtin_usage();
return(EX_USAGE);
@ -520,7 +933,23 @@ int all;
break;
case CONSTANT:
printf("%ld\n", cp->value);
switch (cp->value) {
case UCHAR_MAX:
case USHRT_MAX:
case UINT_MAX:
#if (ULONG_MAX != UINT_MAX)
case ULONG_MAX:
#endif
#if (SIZE_MAX != UINT_MAX) && (SIZE_MAX != ULONG_MAX)
case SIZE_MAX:
#endif
printf("%lu\n", cp->value);
break;
default:
printf("%ld\n", cp->value);
break;
}
break;
case CONFSTR:
@ -578,8 +1007,7 @@ int all;
break;
}
return ((ferror(stdout) || cp->type == G_UNDEF) ? EXECUTION_FAILURE
: EXECUTION_SUCCESS);
return (ferror(stdout) ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
}
static int
@ -591,7 +1019,7 @@ getconf_all()
ret = EXECUTION_SUCCESS;
for (cp = conf_table; cp->name != NULL; cp++) {
printf("%-35s", cp->name);
if (getconf_print(cp, ".", 1) == EXECUTION_FAILURE)
if (getconf_print(cp, "/", 1) == EXECUTION_FAILURE)
ret = EXECUTION_FAILURE;
}
return ret;
@ -643,6 +1071,136 @@ struct builtin getconf_struct = {
getconf_builtin,
BUILTIN_ENABLED,
getconf_doc,
"getconf -a or getconf -h or getconf sysvar or getconf pathvar pathname",
"getconf -[ah] or getconf [-v spec] sysvar or getconf [-v spec] pathvar pathname",
0
};
#ifndef HAVE_CONFSTR
static size_t
confstr (name, buf, len)
int name;
char *buf;
size_t len;
{
switch (name)
{
case _CS_PATH:
if (len > 0 && buf)
{
strncpy (buf, STANDARD_UTILS_PATH, len - 1);
buf[len - 1] = '\0';
}
return (sizeof (STANDARD_UTILS_PATH) + 1);
default:
errno = EINVAL;
return 0;
}
}
#endif
#ifndef HAVE_SYSCONF
extern long get_clk_tck __P((void));
static long
sysconf (name)
int name;
{
# if defined (_POSIX_VERSION)
switch (name)
{
case _SC_ARG_MAX:
return _POSIX_ARG_MAX;
case _SC_CHILD_MAX:
return _POSIX_CHILD_MAX;
case _SC_CLK_TCK:
return get_clk_tck();
case _SC_NGROUPS_MAX:
return _POSIX_NGROUPS_MAX;
case _SC_OPEN_MAX:
return _POSIX_OPEN_MAX;
case _SC_JOB_CONTROL:
return _POSIX_JOB_CONTROL;
case _SC_SAVED_IDS:
return _POSIX_SAVED_IDS;
case _SC_VERSION:
return _POSIX_VERSION;
case _SC_BC_BASE_MAX:
return _POSIX2_BC_BASE_MAX;
case _SC_BC_DIM_MAX:
return _POSIX2_BC_DIM_MAX;
case _SC_BC_SCALE_MAX:
return _POSIX2_BC_SCALE_MAX;
case _SC_BC_STRING_MAX:
return _POSIX2_BC_STRING_MAX;
case _SC_COLL_WEIGHTS_MAX:
return -1;
case _SC_EXPR_NEST_MAX:
return _POSIX2_EXPR_NEST_MAX;
case _SC_LINE_MAX:
return _POSIX2_LINE_MAX;
case _SC_RE_DUP_MAX:
return _POSIX2_RE_DUP_MAX;
case _SC_STREAM_MAX:
return _POSIX_STREAM_MAX;
case _SC_TZNAME_MAX:
return _POSIX_TZNAME_MAX;
default:
errno = EINVAL;
return -1;
}
#else
errno = EINVAL;
return -1;
#endif
}
#endif
#ifndef HAVE_PATHCONF
static long
pathconf (path, name)
const char *path;
int name;
{
#if defined (_POSIX_VERSION)
switch (name)
{
case _PC_LINK_MAX:
return _POSIX_LINK_MAX;
case _PC_MAX_CANON:
return _POSIX_MAX_CANON;
case _PC_MAX_INPUT:
return _POSIX_MAX_INPUT;
case _PC_NAME_MAX:
return _POSIX_NAME_MAX;
case _PC_PATH_MAX:
return _POSIX_PATH_MAX;
case _PC_PIPE_BUF:
return _POSIX_PIPE_BUF;
case _PC_CHOWN_RESTRICTED:
#ifdef _POSIX_CHOWN_RESTRICTED
return _POSIX_CHOWN_RESTRICTED;
#else
return -1;
#endif
case _PC_NO_TRUNC:
#ifdef _POSIX_NO_TRUNC
return _POSIX_NO_TRUNC;
#else
return -1;
#endif
case _PC_VDISABLE:
#ifdef _POSIX_VDISABLE
return _POSIX_VDISABLE;
#else
return -1;
#endif
default:
errno = EINVAL;
return -1;
}
#else
errno = EINVAL;
return -1;
#endif
}
#endif

214
examples/loadables/getconf.h Normal file
View file

@ -0,0 +1,214 @@
/* getconf.h -- replacement definitions for ones the system doesn't provide. */
#ifndef _GETCONF_H
#define _GETCONF_H
/* Some systems do not define these; use POSIX.2 minimum recommended values. */
#ifndef _POSIX2_COLL_WEIGHTS_MAX
# define _POSIX2_COLL_WEIGHTS_MAX 2
#endif
/* If we're on a posix system, but the system doesn't define the necessary
constants, use posix.1 minimum values. */
#if defined (_POSIX_VERSION)
#ifndef _POSIX_ARG_MAX
# define _POSIX_ARG_MAX 4096
#endif
#ifndef _POSIX_CHILD_MAX
# define _POSIX_CHILD_MAX 6
#endif
#ifndef _POSIX_LINK_MAX
# define _POSIX_LINK_MAX 8
#endif
#ifndef _POSIX_MAX_CANON
# define _POSIX_MAX_CANON 255
#endif
#ifndef _POSIX_MAX_INPUT
# define _POSIX_MAX_INPUT 255
#endif
#ifndef _POSIX_NAME_MAX
# define _POSIX_NAME_MAX 14
#endif
#ifndef _POSIX_NGROUPS_MAX
# define _POSIX_NGROUPS_MAX 0
#endif
#ifndef _POSIX_OPEN_MAX
# define _POSIX_OPEN_MAX 16
#endif
#ifndef _POSIX_PATH_MAX
# define _POSIX_PATH_MAX 255
#endif
#ifndef _POSIX_PIPE_BUF
# define _POSIX_PIPE_BUF 512
#endif
#ifndef _POSIX_SSIZE_MAX
# define _POSIX_SSIZE_MAX 32767
#endif
#ifndef _POSIX_STREAM_MAX
# define _POSIX_STREAM_MAX 8
#endif
#ifndef _POSIX_TZNAME_MAX
# define _POSIX_TZNAME_MAX 3
#endif
#ifndef _POSIX2_BC_BASE_MAX
# define _POSIX2_BC_BASE_MAX 99
#endif
#ifndef _POSIX2_BC_DIM_MAX
# define _POSIX2_BC_DIM_MAX 2048
#endif
#ifndef _POSIX2_BC_SCALE_MAX
# define _POSIX2_BC_SCALE_MAX 99
#endif
#ifndef _POSIX2_BC_STRING_MAX
# define _POSIX2_BC_STRING_MAX 1000
#endif
#ifndef _POSIX2_EQUIV_CLASS_MAX
# define _POSIX2_EQUIV_CLASS_MAX 2
#endif
#ifndef _POSIX2_EXPR_NEST_MAX
# define _POSIX2_EXPR_NEST_MAX 32
#endif
#ifndef _POSIX2_LINE_MAX
# define _POSIX2_LINE_MAX 2048
#endif
#ifndef _POSIX2_RE_DUP_MAX
# define _POSIX2_RE_DUP_MAX 255
#endif
/* configurable system variables */
#if !defined (HAVE_SYSCONF)
#ifndef _SC_ARG_MAX
# define _SC_ARG_MAX 1
# define _SC_CHILD_MAX 2
# define _SC_CLK_TCK 3
# define _SC_NGROUPS_MAX 4
# define _SC_OPEN_MAX 5
# define _SC_JOB_CONTROL 6
# define _SC_SAVED_IDS 7
# define _SC_VERSION 8
# define _SC_BC_BASE_MAX 9
# define _SC_BC_DIM_MAX 10
# define _SC_BC_SCALE_MAX 11
# define _SC_BC_STRING_MAX 12
# define _SC_COLL_WEIGHTS_MAX 13
# define _SC_EXPR_NEST_MAX 14
# define _SC_LINE_MAX 15
# define _SC_RE_DUP_MAX 16
#if 0
# define _SC_2_VERSION 17
# define _SC_2_C_BIND 18
# define _SC_2_C_DEV 19
# define _SC_2_CHAR_TERM 20
# define _SC_2_FORT_DEV 21
# define _SC_2_FORT_RUN 22
# define _SC_2_LOCALEDEF 23
# define _SC_2_SW_DEV 24
# define _SC_2_UPE 25
#endif /* 0 */
# define _SC_STREAM_MAX 26
# define _SC_TZNAME_MAX 27
#endif /* !_SC_ARG_MAX */
#endif /* !HAVE_SYSCONF */
/* configurable pathname variables */
#if !defined (HAVE_PATHCONF)
#ifndef _PC_LINK_MAX
#define _PC_LINK_MAX 1
#define _PC_MAX_CANON 2
#define _PC_MAX_INPUT 3
#define _PC_NAME_MAX 4
#define _PC_PATH_MAX 5
#define _PC_PIPE_BUF 6
#define _PC_CHOWN_RESTRICTED 7
#define _PC_NO_TRUNC 8
#define _PC_VDISABLE 9
#endif /* !_PC_LINK_MAX */
#endif /* !HAVE_PATHCONF */
#endif /* _POSIX_VERSION */
#ifndef _CS_PATH
# define _CS_PATH 1
#endif
/* ANSI/ISO C, POSIX.1-200x, XPG 4.2 (and later) C language type limits.
Defined only if the system include files don't. Assume a 32-bit
environment with signed 8-bit characters. */
#ifndef CHAR_BIT
# define CHAR_BIT 8
#endif
#ifndef CHAR_MAX
# define CHAR_MAX 127
#endif
#ifndef CHAR_MIN
# define CHAR_MIN -128
#endif
#ifndef INT_BIT
# define INT_BIT (sizeof (int) * CHAR_BIT)
#endif
#ifndef INT_MAX
# define INT_MAX 2147483647
#endif
#ifndef INT_MIN
# define INT_MIN (-2147483647-1)
#endif
#ifndef LONG_BIT
# define LONG_BIT (sizeof (long int) * CHAR_BIT)
#endif
#ifndef LONG_MAX
# define LONG_MAX 2147483647L
#endif
#ifndef LONG_MIN
# define LONG_MIN (-2147483647L-1L)
#endif
#ifndef SCHAR_MAX
# define SCHAR_MAX CHAR_MAX
#endif
#ifndef SCHAR_MIN
# define SCHAR_MIN CHAR_MIN
#endif
#ifndef SHRT_MAX
# define SHRT_MAX 32767
#endif
#ifndef SHRT_MIN
# define SHRT_MIN (-32768)
#endif
#ifndef UCHAR_MAX
# define UCHAR_MAX 255
#endif
#ifndef UINT_MAX
# define UINT_MAX 4294967295U
#endif
#ifndef ULONG_MAX
# define ULONG_MAX 4294967295UL
#endif
#ifndef USHRT_MAX
# define UCHAR_MAX 65535
#endif
/* assume size_t is `unsigned int'; ssize_t is `int' */
#ifndef SIZE_MAX
# define SIZE_MAX UINT_MAX
#endif
#ifndef SSIZE_MAX
# define SSIZE_MAX INT_MAX
#endif
#ifndef WORD_BIT
# define WORD_BIT (sizeof (int) * CHAR_BIT)
#endif
#endif /* _GETCONF_H */

4
examples/loadables/head.c
View file

@ -16,7 +16,7 @@
#include <stdio.h>
#include <errno.h>
#include <ctype.h>
#include "chartypes.h"
#include "builtins.h"
#include "shell.h"
@ -37,7 +37,7 @@ munge_list (list)
for (l = list; l; l = l->next)
{
arg = l->word->word;
if (arg[0] != '-' || arg[1] == '-' || (isdigit(arg[1]) == 0))
if (arg[0] != '-' || arg[1] == '-' || (DIGIT(arg[1]) == 0))
return;
/* We have -[0-9]* */
wd = make_bare_word (arg+1);

1
examples/loadables/hello.c
View file

@ -31,6 +31,7 @@
A builtin command returns EXECUTION_SUCCESS for success and
EXECUTION_FAILURE to indicate failure. */
int
hello_builtin (list)
WORD_LIST *list;
{

4
examples/loadables/ln.c
View file

@ -23,10 +23,12 @@
extern int errno;
#endif
typedef int unix_link_syscall_t __P((const char *, const char *));
#define LN_SYMLINK 0x01
#define LN_UNLINK 0x02
static Function *linkfn;
static unix_link_syscall_t *linkfn;
static int dolink ();
ln_builtin (list)

7
examples/loadables/sleep.c
View file

@ -23,6 +23,7 @@
#endif
#include <stdio.h>
#include "chartypes.h"
#include "shell.h"
#include "builtins.h"
@ -78,7 +79,7 @@ long *sp, *usp;
for (p = s; p && *p; p++) {
if (*p == DECIMAL) /* decimal point */
break;
if (isdigit(*p) == 0)
if (DIGIT(*p) == 0)
RETURN(0);
sec = (sec * 10) + (*p - '0');
}
@ -91,7 +92,7 @@ long *sp, *usp;
/* Look for up to six digits past a decimal point. */
for (n = 0; n < 6 && p[n]; n++) {
if (isdigit(p[n]) == 0)
if (DIGIT(p[n]) == 0)
RETURN(0);
usec = (usec * 10) + (p[n] - '0');
}
@ -99,7 +100,7 @@ long *sp, *usp;
/* Now convert to millionths */
usec *= multiplier[n];
if (n == 6 && p[6] && isdigit(p[6]) && p[6] >= '5')
if (n == 6 && p[6] >= '5' && p[6] <= '9')
usec++; /* round up 1 */
RETURN(1);

514
examples/loadables/sprintf.c
View file

@ -1,514 +0,0 @@
/*
* Copyright (c) 1989, 1993
* The Regents of the University of California. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#if !defined(BUILTIN) && !defined(SHELL)
#ifndef lint
static char copyright[] =
"@(#) Copyright (c) 1989, 1993\n\
The Regents of the University of California. All rights reserved.\n";
#endif /* not lint */
#endif
#ifndef lint
static char sccsid[] = "@(#)printf.c 8.1 (Berkeley) 7/20/93";
#endif /* not lint */
#include <sys/types.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include "bashansi.h"
#include "shell.h"
#include "builtins.h"
#include "stdc.h"
#if !defined (errno)
extern int errno;
#endif
static char sbuf[1024];
static int sblen;
/* Gee, I wish sprintf could be reliably counted upon to return the
number of characters written :-( */
#define PF(f, func) \
do { \
if (fieldwidth) \
if (precision) \
sprintf(sbuf, f, fieldwidth, precision, func); \
else \
sprintf(sbuf, f, fieldwidth, func); \
else if (precision) \
sprintf(sbuf, f, precision, func); \
else \
sprintf(sbuf, f, func); \
spaddstr (sbuf, strlen (sbuf)); \
} while (0)
static int asciicode __P((void));
static void escape __P((char *));
static int getchr __P((void));
static double getdouble __P((void));
static int getint __P((int *));
static int getlong __P((long *));
static char *getstr __P((void));
static char *mklong __P((char *, int));
static void usage __P((void));
static char **gargv;
static char *outstr;
static int outsize;
static int outind;
int sprintf_builtin ();
static int sprintf_main ();
static void spaddstr ();
extern char *this_command_name;
extern char *single_quote ();
extern char **make_builtin_argv ();
static char *sprintf_doc[] = {
"sprintf formats and outputs its arguments, after the second, under control",
"of the format and assigns the result to the variable named by its first",
"argument. The format is a character string which contains three types",
"of objects: plain characters, which are simply copied to the output string,",
"character escape sequences which are converted and copied to the output",
"string, and format specifications, each of which causes printing of the",
"next successive argument. In addition to the standard sprintf(3) formats,",
"%b means to expand escapes in the corresponding argument, and %q means",
"to quote the argument in a way that can be reused as shell input. Each",
"one of the format specifications must not expand to more than 1024",
"characters, though there is no limit on the total size of the output",
"string.",
(char *)NULL
};
struct builtin sprintf_struct = {
"sprintf",
sprintf_builtin,
BUILTIN_ENABLED,
sprintf_doc,
"sprintf var format [arguments]",
(char *)0
};
int
sprintf_builtin (list)
WORD_LIST *list;
{
int c, r;
char **v, *varname;
WORD_LIST *l;
SHELL_VAR *var;
if (list == 0)
{
builtin_usage ();
return (EXECUTION_FAILURE);
}
varname = list->word->word;
list = list->next;
if (legal_identifier (varname) == 0)
{
builtin_error ("%s: not a legal variable name", varname);
return (EXECUTION_FAILURE);
}
outind = 0;
if (outstr == 0)
outstr = xmalloc (outsize = 64);
outstr[0] = '\0';
v = make_builtin_argv (list, &c);
r = sprintf_main (c, v);
free (v);
var = bind_variable (varname, outstr);
if (readonly_p (var))
{
builtin_error ("%s: readonly variable", varname);
return (EXECUTION_FAILURE);
}
return r;
}
static void
spaddstr(str, len)
char *str;
int len;
{
RESIZE_MALLOCED_BUFFER (outstr, outind, len, outsize, 64);
strcpy (outstr + outind, str);
outind += len;
}
static int
sprintf_main(argc, argv)
int argc;
char *argv[];
{
extern int optind;
static char *skip1, *skip2;
int ch, end, fieldwidth, precision;
char convch, nextch, *format, *fmt, *start;
while ((ch = getopt(argc, argv, "")) != EOF)
switch (ch) {
case '?':
default:
usage();
return (1);
}
argc -= optind;
argv += optind;
if (argc < 1) {
usage();
return (1);
}
/*
* Basic algorithm is to scan the format string for conversion
* specifications -- once one is found, find out if the field
* width or precision is a '*'; if it is, gather up value. Note,
* format strings are reused as necessary to use up the provided
* arguments, arguments of zero/null string are provided to use
* up the format string.
*/
skip1 = "#-+ 0";
skip2 = "*0123456789";
escape(fmt = format = *argv); /* backslash interpretation */
gargv = ++argv;
for (;;) {
end = 0;
/* find next format specification */
next: for (start = fmt;; ++fmt) {
if (!*fmt) {
/* avoid infinite loop */
if (end == 1) {
warnx("missing format character",
NULL, NULL);
return (1);
}
end = 1;
if (fmt > start)
(void)printf("%s", start);
if (!*gargv)
return (0);
fmt = format;
goto next;
}
/* %% prints a % */
if (*fmt == '%') {
if (*++fmt != '%')
break;
*fmt++ = '\0';
(void)printf("%s", start);
goto next;
}
}
/* skip to field width */
for (; strchr(skip1, *fmt); ++fmt);
if (*fmt == '*') {
if (getint(&fieldwidth))
return (1);
} else
fieldwidth = 0;
/* skip to possible '.', get following precision */
for (; strchr(skip2, *fmt); ++fmt);
if (*fmt == '.')
++fmt;
if (*fmt == '*') {
if (getint(&precision))
return (1);
} else
precision = 0;
/* skip to conversion char */
for (; strchr(skip2, *fmt); ++fmt);
if (!*fmt) {
warnx("missing format character", NULL, NULL);
return (1);
}
convch = *fmt;
nextch = *++fmt;
*fmt = '\0';
switch(convch) {
case 'c': {
char p;
p = getchr();
PF(start, p);
break;
}
case 's': {
char *p;
p = getstr();
PF(start, p);
break;
}
case 'b': { /* expand escapes in argument */
char *p;
p = getstr();
escape(p);
PF("%s", p);
break;
}
case 'q': { /* print with shell single quoting */
char *p, *p2;
p = getstr();
p2 = single_quote(p);
PF("%s", p2);
free(p2);
break;
}
case 'd': case 'i': case 'o': case 'u': case 'x': case 'X': {
long p;
char *f;
if ((f = mklong(start, convch)) == NULL)
return (1);
if (getlong(&p))
return (1);
PF(f, p);
break;
}
case 'e': case 'E': case 'f': case 'g': case 'G': {
double p;
p = getdouble();
PF(start, p);
break;
}
default:
warnx("illegal format character", NULL, NULL);
return (1);
}
*fmt = nextch;
}
/* NOTREACHED */
}
static char *
mklong(str, ch)
char *str;
int ch;
{
static char copy[64];
int len;
len = strlen(str) + 2;
memmove(copy, str, len - 3);
copy[len - 3] = 'l';
copy[len - 2] = ch;
copy[len - 1] = '\0';
return (copy);
}
static void
escape(fmt)
register char *fmt;
{
register char *store;
register int value, c;
for (store = fmt; c = *fmt; ++fmt, ++store) {
if (c != '\\') {
*store = c;
continue;
}
switch (*++fmt) {
case '\0': /* EOS, user error */
*store = '\\';
*++store = '\0';
return;
case '\\': /* backslash */
case '\'': /* single quote */
*store = *fmt;
break;
case 'a': /* bell/alert */
*store = '\7';
break;
case 'b': /* backspace */
*store = '\b';
break;
case 'c':
return;
case 'e':
case 'E':
*store = '\033';
break;
case 'f': /* form-feed */
*store = '\f';
break;
case 'n': /* newline */
*store = '\n';
break;
case 'r': /* carriage-return */
*store = '\r';
break;
case 't': /* horizontal tab */
*store = '\t';
break;
case 'v': /* vertical tab */
*store = '\13';
break;
/* octal constant */
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
for (c = 3, value = 0;
c-- && *fmt >= '0' && *fmt <= '7'; ++fmt) {
value <<= 3;
value += *fmt - '0';
}
--fmt;
*store = value;
break;
default:
*store = *fmt;
break;
}
}
*store = '\0';
}
static int
getchr()
{
if (!*gargv)
return ('\0');
return ((int)**gargv++);
}
static char *
getstr()
{
if (!*gargv)
return ("");
return (*gargv++);
}
static char *Number = "+-.0123456789";
static int
getint(ip)
int *ip;
{
long val;
if (getlong(&val))
return (1);
if (val > INT_MAX) {
warnx("%s: %s", *gargv, strerror(ERANGE));
return (1);
}
*ip = val;
return (0);
}
static int
getlong(lp)
long *lp;
{
long val;
char *ep;
if (!*gargv) {
*lp = 0;
return (0);
}
if (strchr(Number, **gargv)) {
errno = 0;
val = strtol(*gargv, &ep, 0);
if (*ep != '\0') {
warnx("%s: illegal number", *gargv, NULL);
return (1);
}
if (errno == ERANGE)
if (val == LONG_MAX) {
warnx("%s: %s", *gargv, strerror(ERANGE));
return (1);
}
if (val == LONG_MIN) {
warnx("%s: %s", *gargv, strerror(ERANGE));
return (1);
}
*lp = val;
++gargv;
return (0);
}
*lp = (long)asciicode();
return (0);
}
static double
getdouble()
{
if (!*gargv)
return ((double)0);
if (strchr(Number, **gargv))
return (atof(*gargv++));
return ((double)asciicode());
}
static int
asciicode()
{
register int ch;
ch = **gargv;
if (ch == '\'' || ch == '"')
ch = (*gargv)[1];
++gargv;
return (ch);
}
static void
usage()
{
(void)fprintf(stderr, "usage: printf format [arg ...]\n");
}