-Fri Feb 21 00:22:28 1997 Miles Bader <miles@gnu.ai.mit.edu>
+1997-02-24 23:05 Wolfram Gloger <wmglo@dent.med.uni-muenchen.de>
+
+ * malloc/malloc.c (malloc_get_state): New function.
+ Saves global malloc state to an opaque data structure which
+ is dynamically allocated in the heap.
+ * malloc/malloc.c (malloc_set_state): New function.
+ Restore previously obtained state.
+ * malloc/malloc.h: Add declaration of malloc_get_state()
+ and malloc_set_state().
+
+1997-02-24 23:27 Ulrich Drepper <drepper@cygnus.com>
+
+ * sysdeps/libm-ieee754/s_cbrtl.c: Shift B1_EXP value to right
+ position.
+
+1997-02-24 17:38 Ulrich Drepper <drepper@cygnus.com>
+
+ * misc/error.c: Make error and error_at_line weak aliases of
+ __error and __error_at_line respectively.
+ Suggested by David Mosberger-Tang <davidm@AZStarNet.COM>.
+
+ * sysdeps/unix/sysv/linux/i386/socket.S: Update copyright.
+
+1997-02-22 11:30 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
+
+ * elf/ldd.bash.in: Run the program directly, not as argument
+ to the dynamic linker, if it contains an interpreter segment.
+ * elf/ldd.sh.in: Likewise.
+
+ * elf/rtld.c (dl_main): In verify mode check whether the dynamic
+ object contains an interpreter segment and exit with 2 if not.
+
+1997-02-23 01:23 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
+
+ * Makefile (distribute): Remove nsswitch.h, netgroup.h, mcheck.h
+ and xlocale.h. Make-dist adds them automagically.
+
+1997-02-22 12:25 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
+
+ * locale/C-time.c (_nl_C_LC_TIME): Add missing entry for
+ time-era-num-entries.
+
+1997-02-06 13:49 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
+
+ * rellns-sh: No need to check for existance of first parameter.
+
+1997-02-24 15:20 Jonathan T. Agnew <jtagnew@amherst.edu>
+
+ * glibcbug.in: Don't mention destination on MAIL_AGENT command line
+ to avoid duplicate mail.
+
+1997-02-24 03:51 Ulrich Drepper <drepper@cygnus.com>
+
+ * Makefile (distribute): Add isomac.c.
+ (tests): Run isomac test.
+
+ * features.h (__USE_ISOC9X): New macro.
+
+ * catgets/catgets.c: Don't use global variable `optind'. Instead
+ use result computed by argp_parse.
+ * db/makedb: Likewise.
+ * locale/programs/locale.c: Likewise.
+ * locale/programs/localedef.c: Likewise.
+
+ * libio/stdio.h: Rewrite. Make it more readable and add comments.
+
+ * libio/clearerr.c: Remove clearerr_locked alias.
+ * libio/feof.c: Remove feof_locked alias.
+ * libio/ferror.c: Remove feof_locked alias.
+ * libio/fileno.c: Remove fileno_locked alias.
+ * libio/fputc.c: Remove fputc_locked alias.
+ * libio/getc.c: Remove getc_locked alias.
+ * libio/getchar.c: Remove getchar_locked alias.
+ * libio/iofflush.c: Remove fflush_locked alias.
+ * libio/putc.c: Remove putc_locked alias.
+ * libio/putc.c: Remove putchar_locked alias.
+
+ * stdio-common/printf_fp.c: When number is inifinity print INF
+ or inf depending on case of specifier. Same for NaN where NAN
+ or nan is printed. Specified in ISO C 9X.
+
+ * misc/sys/cdefs.h (__restrict): Define to empty string for now.
+ * stdio/stdio.h: Add __restrict to prototypes where necessary.
+ * libio/stdio.h: Likewise.
+ * stdlib/stdlib.h: Likewise.
+ * string/string.h: Likewise.
+ * time/time.h: Likewise.
+ * wcsmbs/wchar.h: Likewise.
+
+ * stdlib/strtod.c: Change to recognize INF, INFINITY, NAN, and
+ NAN(...).
+
+ * sysdeps/ieee754/huge_val.h: Define HUGE_VALF and HUGE_VALL instead
+ of HUGE_VALf and HUGE_VALL.
+ * stdlib/strtof.c (FLOAT_HUGE_VAL): Use standard name HUGE_VALF
+ instead of HUGE_VALf.
+ * wcsmbs/wcstof.c: Likewise.
+ * stdlib/strtold.c (FLOAT_HUGE_VAL): Use standard name HUGE_VALL
+ instead of HUGE_VALl.
+ * wcsmbs/wcstold.c: Likewise.
+
+ * sysdeps/posix/gai_strerror.c: Use size_t for counter variable to
+ avoid warning.
+
+ * wcsmbs/Makefile (routines): Add wcscasecmp and wcsncase.
+ * wcsmbs/wchar.h: Add prototypes for wcscasecmp and wcsncase.
+ * wcsmbs/wcscasecmp.c: New file.
+ * wcsmbs/wcsncase.c: New file.
+
+ * stdlib/strtol.c: Define wide character quad word functions as
+ wcstoll and wcstoull and normal versions as strtoll and strtoull.
+ * wcsmbs/wchar.h: Add prototypes for wcstoll and wcstoull.
+ * wcsmbs/wcstoq: Renamed to wcstoll.c.
+ * wcsmbs/wcstouq: Renamed to wcstoull.c.
+ * wcsmbs/wcstoll.c: Renamed from wcstoq.c. Make wcstoq a weak
+ alias of wcstoll.
+ * wcsmbs/wcstoull.c: Renamed from wcstouq.c. Make wcstouq a weak
+ alias of wcstoull.
+ * wcsmbs/Makefile (routines): Replace wcstoq and wcstouq by
+ wcstoll and wcstoull respectively.
+ * stdlib/strtoq.c: Rename to strtoll.c.
+ * stdlib/strtouq.c: Rename to strtoull.c.
+ * stdlib/strtoll.c: Renamed from strtoq.c. Make strtoq a weak
+ alias of strtoll.
+ * stdlib/strtoll.c: Renamed from strtouq.c. Make strtouq a weak
+ alias of strtoull.
+ * stdlib/Makefile (routines): Replace strtoq and strtouq by
+ strtoll and strtoull respectively.
+ * stdio-common/vfscanf.c: Don't use __strtoq_internal and
+ __strtouq_internal but instead __strtoll_internal and
+ __strtoull_internal respectively.
+ * stdlib/stdlib.h (strtoq): Use __internal_strtoll in inline version.
+ (strtouq): Similar with __internal_strtoull.
+ * wcsmbs/wchar.h (wcstoq): Use __internal_wcstoll in inline version.
+ (wcstouq): Similar with __internal_wcstoull.
+
+1997-02-23 04:38 Ulrich Drepper <drepper@cygnus.com>
+
+ * stdlib/strtol.c (STRTOL): It is not illegal to parse a minus
+ sign in the strtouXX functions. The results gets simply negated.
+ * stdio-common/tstscanf.c: Add testcase for above case.
+ * stdlib/tst-strtol.c: Correct tests.
+
+ * manual/stdio-fp.c: New file. Generate output for example program
+ in stdio.texi.
+
+ * stdio-common/Makefile (routines): Add printf_fphex.
+ * stdio-common/vfprintf.c: Add handling of %a and %A specifier.
+ * stdio-common/printf_fphex.c: New file. Implement %a and %A
+ specifier.
+
+1997-02-22 03:01 Ulrich Drepper <drepper@cygnus.com>
+
+ * sysdeps/unix/sysv/linux/timebits.h (CLK_TCK): Don't defined if
+ __STRICT_ANSI__.
+
+ * math/math.h: Prevent definition of struct exception when using
+ C++.
+
+1997-02-22 01:45 Ulrich Drepper <drepper@cygnus.com>
+
+ * sysdeps/unix/syscalls.list: Dup takes only one argument.
+ Reported by Greg McGary.
+
+1997-02-21 00:22 Miles Bader <miles@gnu.ai.mit.edu>
* sysdeps/mach/hurd/readlink.c (__readlink): Use io_read rather
than file_get_translator.
* sysdeps/mach/hurd/defs.c, sysdeps/stub/defs.c, sysdeps/posix/defs.c
(_cleanup): Use __fcloseall instead of fclose with a NULL stream.
-Thu Feb 20 01:28:39 1997 Miles Bader <miles@gnu.ai.mit.edu>
+1997-02-20 01:28 Miles Bader <miles@gnu.ai.mit.edu>
* hurd/fchroot.c (fchroot): Reparent DIR to make it a real root.
* sysdeps/mach/hurd/chroot.c (chroot): Likewise.
-Wed Feb 19 13:56:04 1997 Miles Bader <miles@gnu.ai.mit.edu>
+1997-02-19 13:56 Miles Bader <miles@gnu.ai.mit.edu>
* sysdeps/mach/hurd/accept.c (accept): Don't segv if ADDR_LEN == 0
but ADDR also == 0.
now instead of a weak extern, as some old programs expect it to be
defined by ld.so.
-Tue Feb 18 15:39:08 1997 Miles Bader <miles@gnu.ai.mit.edu>
+1997-02-18 15:39 Miles Bader <miles@gnu.ai.mit.edu>
* hurd/hurdfault.c (_hurdsig_fault_preempter): New weak alias.
* malloc/thread-m.h (mutex_trylock): Invert sense of return value.
-Mon Feb 17 10:58:14 1997 Miles Bader <miles@gnu.ai.mit.edu>
+1997-02-17 10:58 Miles Bader <miles@gnu.ai.mit.edu>
* malloc/thread-m.h (mutex_trylock): Define to be __mutex_trylock,
not __mutex_try_lock.
* hurd/hurdinit.c (__libc_argv): Remove extern.
(__libc_argc): New variable.
-Sat Feb 15 10:23:32 1997 Miles Bader <miles@gnu.ai.mit.edu>
+1997-02-15 10:23 Miles Bader <miles@gnu.ai.mit.edu>
* hurd/hurd/threadvar.h (enum __hurd_threadvar_index): Add
_HURD_THREADVAR_MALLOC.
* malloc/thread-m.h
[_LIBC && !PTHREAD_MUTEX_INITIALIZER && MUTEX_INITIALIZER]
- (__x_mutex_lock, __x_mutex_unlock): Functions removed.
- (mutex_lock, mutex_unlock): Defined in terms of __mutex_*.
- (tsd_key_create, tsd_setspecific, tsd_setspecific): Change to
- hurd-specific definitions, using __hurd_threadvar_location.
+ (mutex_lock, mutex_unlock, mutex_trylock): Defined in terms of
+ __mutex_*.
+ (mutex_t): Type removed & replaced by new macro.
+ (tsd_key_t): Typedef to int instead of pthread_key_t.
+ (tsd_key_create, tsd_setspecific, tsd_getspecific): New macros.
+ (__pthread_initialize): New macro, work around assumption of pthreads.
(tsd_keys_alloced): New static variable.
<hurd/threadvar.h>: New include.
-
+
* hurd/report-wait.c (_hurd_itimer_thread): Make a weak extern.
(_S_msg_report_wait): Check to see if _hurd_itimer_thread is
defined before using it.
- * sysdeps/mach/hurd/i386/init-first.c (__libc_argv, __libc_argc):
+ * sysdeps/mach/hurd/i386/init-first.c (__libc_argv, __libc_argc):
Make extern.
* hurd/hurdinit.c (__libc_argv): Make extern.
(__hurd_threadvar_max, __hurd_threadvar_stack_offset,
__hurd_threadvar_stack_mask): Variables removed.
* sysdeps/mach/hurd/dl-sysdep.c (__hurd_sigthread_stack_base,
- __hurd_sigthread_stack_end, __hurd_sigthread_stack_variables,
- __hurd_threadvar_max, __hurd_threadvar_stack_offset,
- __hurd_threadvar_stack_mask): Variables removed.
+ __hurd_sigthread_stack_end, __hurd_sigthread_stack_variables,
+ __hurd_threadvar_max, __hurd_threadvar_stack_offset,
+ __hurd_threadvar_stack_mask): Variables removed.
-Fri Feb 14 14:07:19 1997 Miles Bader <miles@gnu.ai.mit.edu>
+1997-02-14 14:07 Miles Bader <miles@gnu.ai.mit.edu>
- * hurd/hurd.h (_hurd_pids_changed_stamp, _hurd_pids_changed_sync):
+ * hurd/hurd.h (_hurd_pids_changed_stamp, _hurd_pids_changed_sync):
Declare extern.
* malloc/thread-m.h
* locale/weight.h (collate_rules): It's an u_int32_t array.
(get_weight): Compute initial SLOT value correctly.
+1997-02-24 17:06 Geoffrey Keating <geoffk@discus.anu.edu.au>
+
+ * sysdeps/unix/sysv/linux/accept.S (NARGS): Describe number of
+ arguments taken, for sysdeps/unix/sysv/linux/powerpc/socket.S.
+ * sysdeps/unix/sysv/linux/bind.S: Likewise.
+ * sysdeps/unix/sysv/linux/connect.S: Likewise.
+ * sysdeps/unix/sysv/linux/getpeername.S: Likewise.
+ * sysdeps/unix/sysv/linux/getsockname.S: Likewise.
+ * sysdeps/unix/sysv/linux/getsockopt.S: Likewise.
+ * sysdeps/unix/sysv/linux/listen.S: Likewise.
+ * sysdeps/unix/sysv/linux/recv.S: Likewise.
+ * sysdeps/unix/sysv/linux/recvfrom.S: Likewise.
+ * sysdeps/unix/sysv/linux/recvmsg.S: Likewise.
+ * sysdeps/unix/sysv/linux/send.S: Likewise.
+ * sysdeps/unix/sysv/linux/sendmsg.S: Likewise.
+ * sysdeps/unix/sysv/linux/sendto.S: Likewise.
+ * sysdeps/unix/sysv/linux/setsockopt.S: Likewise.
+ * sysdeps/unix/sysv/linux/shutdown.S: Likewise.
+ * sysdeps/unix/sysv/linux/socketpair.S: Likewise.
+
1997-02-22 00:17 Ulrich Drepper <drepper@cygnus.com>
* catgets/gencat.c: Change to use argp.
trying to resolv name as numeric IPv6 address.
* nss/digits_dots.c: Likewise.
-Sat Feb 15 04:51:08 1997 Ulrich Drepper <drepper@cygnus.com>
+1997-02-15 04:51 Ulrich Drepper <drepper@cygnus.com>
* locale/setlocale.c (setlocale): Don't try to be clever about
unused locales. When the existence of the locale files isn't
$(addprefix +nodist+,$(generated))
\f
+# Run a test on the header files we use.
+tests: $(objpfx)isomac
+ $(objpfx)isomac $(CC) '$(+sysdep-includes)' >$(common-objpfx)isomac.out
+
+$(objpfx)isomac: isomac.c
+ $(native-compile)
+\f
# Make the distribution tarfile.
distribute := README INSTALL FAQ NOTES NEWS PROJECTS \
COPYING.LIB COPYING ChangeLog ChangeLog.[0-9] \
Makefile Makeconfig Makerules Rules Make-dist MakeTAGS \
- extra-lib.mk o-iterator.mk \
+ extra-lib.mk o-iterator.mk isomac.c \
ansidecl.h mkinstalldirs move-if-change install-sh \
configure configure.in aclocal.m4 config.sub config.guess\
config.h.in config.make.in config-name.in Makefile.in \
autolock.sh rellns-sh munch-tmpl.c munch.awk interp.c \
sysdep.h set-hooks.h libc-symbols.h version.h shlib-versions \
- rpm/Makefile rpm/template rpm/rpmrc nsswitch.h netgroup.h \
- mcheck.h glibcbug.in xlocale.h
+ rpm/Makefile rpm/template rpm/rpmrc glibcbug.in
distribute := $(strip $(distribute))
generated := $(generated) stubs.h version-info.h
main (int argc, char *argv[])
{
struct catalog *result;
+ int remaining;
/* Set program name for messages. */
error_print_progname = error_print;
result = NULL;
/* Parse and process arguments. */
- argp_parse (&argp, argc, argv, 0, 0, NULL);
+ argp_parse (&argp, argc, argv, 0, &remaining, NULL);
/* Determine output file. */
if (output_name == NULL)
- output_name = optind < argc ? argv[optind++] : "-";
+ output_name = remaining < argc ? argv[remaining++] : "-";
/* Process all input files. */
setlocale (LC_CTYPE, "C");
- if (optind < argc)
+ if (remaining < argc)
do
- result = read_input_file (result, argv[optind]);
- while (++optind < argc);
+ result = read_input_file (result, argv[remaining]);
+ while (++remaining < argc);
else
result = read_input_file (NULL, "-");
FILE *input_file;
DB *db_file;
int status;
+ int remaining;
/* Set locale via LC_ALL. */
setlocale (LC_ALL, "");
input_name = NULL;
/* Parse and process arguments. */
- argp_parse (&argp, argc, argv, 0, 0, NULL);
+ argp_parse (&argp, argc, argv, 0, &remaining, NULL);
/* Determine file names. */
if (do_undo || output_name != NULL)
{
- if (optind + 1 != argc)
+ if (remaining + 1 != argc)
{
wrong_arguments:
error (0, 0, gettext ("wrong number of arguments"));
argp_help (&argp, stdout, ARGP_HELP_SEE,
program_invocation_short_name);
}
- input_name = argv[optind];
+ input_name = argv[remaining];
}
else
{
- if (optind + 2 != argc)
+ if (remaining + 2 != argc)
goto wrong_arguments;
- input_name = argv[optind++];
- output_name = argv[optind];
+ input_name = argv[remaining++];
+ output_name = argv[remaining];
}
/* Special handling if we are asked to print the database. */
esac
done
+add_env="LD_TRACE_LOADED_OBJECTS=1 LD_WARN=$warn LD_BIND_NOW=$bind_now"
case $# in
0)
echo >&2 $"ldd: missing file arguments"
elif test -r "$file"; then
test -x "$file" ||
echo $"ldd: warning: you do not have execution permission for" "\`$file'"
- if ${RTLD} --verify "$file"; then
- LD_TRACE_LOADED_OBJECTS=1 LD_WARN=$warn LD_BIND_NOW=$bind_now \
- exec ${RTLD} ${RELOCS} "$file" || exit 1
- else
- echo $" not a dynamic executable"
- exit 1
- fi
+ ${RTLD} --verify "$file"
+ case $? in
+ 0)
+ eval $add_env exec '"$file"' || exit 1
+ ;;
+ 1)
+ echo $" not a dynamic executable"
+ exit 1
+ ;;
+ 2)
+ eval $add_env exec \${RTLD} '"$file"' || exit 1
+ ;;
+ *)
+ echo $"ldd: ${RTLD} exited with unknown exit code ($?)" >&2
+ exit 1
+ ;;
+ esac
else
echo $"ldd: error: you do not have read permission for" "\`$file'"
exit 1
fi
exit ;;
*)
- set -e # Bail out immediately if ${RTLD} loses on any argument.
result=0
for file; do
echo "${file}:"
elif test -r "$file"; then
test -x "$file" || echo $"\
ldd: warning: you do not have execution permission for" "\`$file'"
- if ${RTLD} --verify "$file"; then
- LD_TRACE_LOADED_OBJECTS=1 LD_WARN=$warn LD_BIND_NOW=$bind_now \
- ${RTLD} ${RELOCS} "$file" || result=1
- else
+ ${RTLD} --verify "$file"
+ case $? in
+ 0)
+ eval $add_env '"$file"' || result=1
+ ;;
+ 1)
echo $" not a dynamic executable"
result=1
- fi
+ ;;
+ 2)
+ eval $add_env ${RTLD} '"$file"' || result=1
+ ;;
+ *)
+ echo $"ldd: ${RTLD} exited with unknown exit code ($?)" >&2
+ exit 1
+ ;;
+ esac
else
echo $"ldd: error: you do not have read permission for" "\`$file'"
result=1
esac
done
+add_env="LD_TRACE_LOADED_OBJECTS=1 LD_WARN=$warn LD_BIND_NOW=$bind_now"
case $# in
0)
echo >&2 "\
if test -r "$file"; then
test -x "$file" ||
echo "ldd: warning: you do not have execution permission for \`$file'"
- if ${RTLD} --verify "$file"; then
- LD_TRACE_LOADED_OBJECTS=1 LD_WARN=$warn LD_BIND_NOW=$bind_now \
- exec ${RTLD} "$file" || exit 1
- else
+ ${RTLD} --verify "$file"
+ case $? in
+ 0)
+ eval $add_env exec '"$file"' || exit 1
+ ;;
+ 1)
echo ' not a dynamic executable'
exit 1
- fi
+ ;;
+ 2)
+ eval $add_env exec \${RTLD} '"$file"' || exit 1
+ ;;
+ *)
+ echo "ldd: ${RTLD} exited with unknown exit code ($?)" >&2
+ exit 1
+ ;;
+ esac
else
echo "ldd: error: you do not have read permission for \`$file'"
exit 1
if test -r "$file"; then
test -x "$file" || echo "\
ldd: warning: you do not have execution permission for \`$file'"
- if ${RTLD} --verify "$file"; then
- LD_TRACE_LOADED_OBJECTS=1 LD_WARN=$warn LD_BIND_NOW=$bind_now \
- ${RTLD} "$file" || result=1
- else
+ ${RTLD} --verify "$file"
+ case $? in
+ 0)
+ eval $add_env '"$file"' || result=1
+ ;;
+ 1)
echo ' not a dynamic executable'
result=1
- fi
+ ;;
+ 2)
+ eval $add_env ${RTLD} '"$file"' || result=1
+ ;;
+ *)
+ echo "ldd: ${RTLD} exited with unknown exit code ($?)" >&2
+ exit 1
+ ;;
+ esac
else
echo "ldd: error: you do not have read permission for \`$file'"
result=1
const char *preloadlist;
size_t file_size;
char *file;
+ int has_interp = 0;
mode = getenv ("LD_TRACE_LOADED_OBJECTS") != NULL ? trace : normal;
_dl_rtld_libname.name = (const char *) l->l_addr + ph->p_vaddr;
_dl_rtld_libname.next = NULL;
_dl_rtld_map.l_libname = &_dl_rtld_libname;
+ has_interp = 1;
break;
}
if (! _dl_rtld_map.l_libname && _dl_rtld_map.l_name)
if (mode == verify)
/* We were called just to verify that this is a dynamic executable
using us as the program interpreter. */
- _exit (l->l_ld == NULL ? EXIT_FAILURE : EXIT_SUCCESS);
+ _exit (l->l_ld == NULL ? 1 : has_interp ? 0 : 2);
/* Extract the contents of the dynamic section for easy access. */
elf_get_dynamic_info (l->l_ld, l->l_info);
to specify the desired environment:
__STRICT_ANSI__ ISO Standard C.
+ _ISOC9X_SOURCE Extensions to ISO C 89 from ISO C 9x.
_POSIX_SOURCE IEEE Std 1003.1.
_POSIX_C_SOURCE If ==1, like _POSIX_SOURCE; if >=2 add IEEE Std 1003.2;
if >=199309L, add IEEE Std 1003.1b-1993
These are defined by this file and are used by the
header files to decide what to declare or define:
+ __USE_ISOC9X Define ISO C 9X things.
__USE_POSIX Define IEEE Std 1003.1 things.
__USE_POSIX2 Define IEEE Std 1003.2 things.
__USE_POSIX199309 Define IEEE Std 1003.1b things.
/* Undefine everything, so we get a clean slate. */
+#undef __USE_ISOC9X
#undef __USE_POSIX
#undef __USE_POSIX2
#undef __USE_POSIX199309
/* If _GNU_SOURCE was defined by the user, turn on all the other features. */
#ifdef _GNU_SOURCE
+#undef _ISOC9X_SOURCE
+#define _ISOC9X_SOURCE 1
#undef _POSIX_SOURCE
#define _POSIX_SOURCE 1
#undef _POSIX_C_SOURCE
/* If nothing (other than _GNU_SOURCE) is defined,
define _BSD_SOURCE and _SVID_SOURCE. */
-#if (!defined __STRICT_ANSI__ && !defined _POSIX_SOURCE && \
- !defined _POSIX_C_SOURCE && !defined _XOPEN_SOURCE && \
- !defined _XOPEN_SOURCE_EXTENDED && !defined _BSD_SOURCE && \
- !defined _SVID_SOURCE)
+#if (!defined __STRICT_ANSI__ && !defined _ISOC9X_SOURCE && \
+ !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE && \
+ !defined _XOPEN_SOURCE && !defined _XOPEN_SOURCE_EXTENDED && \
+ !defined _BSD_SOURCE && !defined _SVID_SOURCE)
#define _BSD_SOURCE 1
#define _SVID_SOURCE 1
#endif
+/* This is to enable the ISO C 9x extension. It will go away as soon
+ as this standard is officially released. */
+#ifdef _ISOC9X_SOURCE
+#define __USE_ISOC9X 1
+#endif
+
/* If none of the ANSI/POSIX macros are defined, use POSIX.1 and POSIX.2
(and IEEE Std 1003.1b-1993 unless _XOPEN_SOURCE is defined). */
#if (!defined __STRICT_ANSI__ && !defined _POSIX_SOURCE && \
/^>Fix:/,/^>[A-Za-z-]*:/s;$FIX_C;;
" $TEMP > $TEMP.x
-if $MAIL_AGENT $BUGGLIBC < $TEMP.x; then
+if $MAIL_AGENT < $TEMP.x; then
echo "$COMMAND: problem report sent"
xs=0; exit
else
--- /dev/null
+/* Check system header files for ISO 9899:1990 (ISO C) compliance.
+ Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Jens Schweikhardt <schweikh@noc.dfn.de>, 1996.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License
+ as published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+
+ The GNU C Library 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 Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If
+ not, write to the Free Software Foundation, Inc., 59 Temple Place -
+ Suite 330, Boston, MA 02111-1307, USA. */
+
+/* This is a simple minded program that tries to find illegal macro
+ definitions in system header files. Illegal macro definitions are
+ those not from the implementation namespace (i.e. not starting with
+ an underscore) or not matching any identifier mandated by The
+ Standard. Some common macro names are considered okay, e.g. all those
+ beginning with E (which may be defined in <errno.h>) or ending in
+ _MAX. See the arrays prefix[] and suffix[] below for details.
+
+ In a compliant implementation no other macros can be defined, because
+ you could write strictly conforming programs that may fail to compile
+ due to syntax errors: suppose <stdio.h> defines PIPE_BUF, then the
+ conforming
+
+ #include <assert.h>
+ #include <stdio.h> <- or where the bogus macro is defined
+ #include <string.h>
+ #define STR(x) #x
+ #define XSTR(x) STR(x)
+ int main (void)
+ {
+ int PIPE_BUF = 0;
+ assert (strcmp ("PIPE_BUF", XSTR (PIPE_BUF)) == 0);
+ return 0;
+ }
+
+ is expected to compile and meet the assertion. If it does not, your
+ compiler compiles some other language than Standard C.
+
+ REQUIREMENTS:
+ This program calls gcc to get the list of defined macros. If you
+ don't have gcc you're probably out of luck unless your compiler or
+ preprocessor has something similar to gcc's -dM option. Tune
+ PRINT_MACROS in this case. This program assumes headers are found
+ under /usr/include and that there is a writable /tmp directory.
+ Tune SYSTEM_INCLUDE and TMPFILE if your system differs.
+ #define BROKEN_SYSTEM if system(NULL) bombs -- one more violation
+ of ISO C, by the way.
+
+ OUTPUT:
+ Each header file name is printed, followed by illegal macro names
+ and their definition. For the above example, you would see
+ ...
+ /usr/include/stdio.h
+ #define PIPE_BUF 5120
+ ...
+ If your implementation does not yet incorporate Amendment 1 you
+ will see messages about iso646.h, wctype.h and wchar.h not being
+ found. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define TMPFILE "/tmp/macros"
+#define HEADER_MAX 256
+
+/* ISO C header names including Amendment 1 (without ".h" suffix). */
+static char *header[] =
+{
+ "assert", "ctype", "errno", "float", "iso646", "limits", "locale",
+ "math", "setjmp", "signal", "stdarg", "stddef", "stdio", "stdlib",
+ "string", "time", "wchar", "wctype"
+};
+
+/* Macros with these prefixes are considered okay. */
+static char *prefix[] =
+{
+ "_", "E", "is", "str", "mem", "SIG", "FLT_", "DBL_", "LDBL_",
+ "LC_", "wmem", "wcs"
+};
+
+/* Macros with these suffixes are considered okay. Will not work for
+ parametrized macros with arguments. */
+static char *suffix[] =
+{
+ "_MAX", "_MIN"
+};
+
+/* These macros are considered okay. In fact, these are just more prefixes. */
+static char *macros[] =
+{
+ "BUFSIZ", "CHAR_BIT", "CHAR_MAX", "CHAR_MIN", "CLOCKS_PER_SEC",
+ "DBL_DIG", "DBL_EPSILON", "DBL_MANT_DIG", "DBL_MAX",
+ "DBL_MAX_10_EXP", "DBL_MAX_EXP", "DBL_MIN", "DBL_MIN_10_EXP",
+ "DBL_MIN_EXP", "EDOM", "EILSEQ", "EOF", "ERANGE", "EXIT_FAILURE",
+ "EXIT_SUCCESS", "FILENAME_MAX", "FLT_DIG", "FLT_EPSILON",
+ "FLT_MANT_DIG", "FLT_MAX", "FLT_MAX_10_EXP", "FLT_MAX_EXP",
+ "FLT_MIN", "FLT_MIN_10_EXP", "FLT_MIN_EXP", "FLT_RADIX",
+ "FLT_ROUNDS", "FOPEN_MAX", "HUGE_VAL", "INT_MAX", "INT_MIN",
+ "LC_ALL", "LC_COLLATE", "LC_CTYPE", "LC_MONETARY", "LC_NUMERIC",
+ "LC_TIME", "LDBL_DIG", "LDBL_EPSILON", "LDBL_MANT_DIG", "LDBL_MAX",
+ "LDBL_MAX_10_EXP", "LDBL_MAX_EXP", "LDBL_MIN", "LDBL_MIN_10_EXP",
+ "LDBL_MIN_EXP", "LONG_MAX", "LONG_MIN", "L_tmpnam", "MB_CUR_MAX",
+ "MB_LEN_MAX", "NDEBUG", "NULL", "RAND_MAX", "SCHAR_MAX",
+ "SCHAR_MIN", "SEEK_CUR", "SEEK_END", "SEEK_SET", "SHRT_MAX",
+ "SHRT_MIN", "SIGABRT", "SIGFPE", "SIGILL", "SIGINT", "SIGSEGV",
+ "SIGTERM", "SIG_DFL", "SIG_ERR", "SIG_IGN", "TMP_MAX", "UCHAR_MAX",
+ "UINT_MAX", "ULONG_MAX", "USHRT_MAX", "WCHAR_MAX", "WCHAR_MIN",
+ "WEOF", "_IOFBF", "_IOLBF", "_IONBF", "abort", "abs", "acos",
+ "acosf", "acosl", "and", "and_eq", "asctime", "asin", "asinf",
+ "asinl", "assert", "atan", "atan2", "atan2f", "atan2l", "atanf",
+ "atanl", "atexit", "atof", "atoi", "atol", "bitand", "bitor",
+ "bsearch", "btowc", "calloc", "ceil", "ceilf", "ceill", "clearerr",
+ "clock", "clock_t", "compl", "cos", "cosf", "cosh", "coshf",
+ "coshl", "cosl", "ctime", "difftime", "div", "div_t", "errno",
+ "exit", "exp", "expf", "expl", "fabs", "fabsf", "fabsl", "fclose",
+ "feof", "ferror", "fflush", "fgetc", "fgetpos", "fgets", "fgetwc",
+ "fgetws", "floor", "floorf", "floorl", "fmod", "fmodf", "fmodl",
+ "fopen", "fprintf", "fputc", "fputs", "fputwc", "fputws", "fread",
+ "free", "freopen", "frexp", "frexpf", "frexpl", "fscanf", "fseek",
+ "fsetpos", "ftell", "fwide", "fwprintf", "fwrite", "fwscanf",
+ "getc", "getchar", "getenv", "gets", "getwc", "getwchar", "gmtime",
+ "isalnum", "isalpha", "iscntrl", "isdigit", "isgraph", "islower",
+ "isprint", "ispunct", "isspace", "isupper", "iswalnum", "iswalpha",
+ "iswcntrl", "iswctype", "iswdigit", "iswgraph", "iswlower",
+ "iswprint", "iswpunct", "iswspace", "iswupper", "iswxdigit",
+ "isxdigit", "labs", "ldexp", "ldexpf", "ldexpl", "ldiv", "ldiv_t",
+ "localeconv", "localtime", "log", "log10", "log10f", "log10l",
+ "logf", "logl", "longjmp", "malloc", "mblen", "mbrlen", "mbrtowc",
+ "mbsinit", "mbsrtowcs", "mbstate_t", "mbstowcs", "mbtowc", "memchr",
+ "memcmp", "memcpy", "memmove", "memset", "mktime", "modf", "modff",
+ "modfl", "not", "not_eq", "offsetof", "or", "or_eq", "perror",
+ "pow", "powf", "powl", "printf", "ptrdiff_t", "putc", "putchar",
+ "puts", "putwc", "putwchar", "qsort", "raise", "rand", "realloc",
+ "remove", "rename", "rewind", "scanf", "setbuf", "setjmp",
+ "setlocale", "setvbuf", "sig_atomic_t", "signal", "sin", "sinf",
+ "sinh", "sinhf", "sinhl", "sinl", "size_t", "sprintf", "sqrt",
+ "sqrtf", "sqrtl", "srand", "sscanf", "stderr", "stdin", "stdout",
+ "strcat", "strchr", "strcmp", "strcoll", "strcpy", "strcspn",
+ "strerror", "strftime", "strlen", "strncat", "strncmp", "strncpy",
+ "strpbrk", "strrchr", "strspn", "strstr", "strtod", "strtok",
+ "strtol", "strtoul", "strxfrm", "swprintf", "swscanf", "system",
+ "tan", "tanf", "tanh", "tanhf", "tanhl", "tanl", "time", "time_t",
+ "tmpfile", "tmpnam", "tolower", "toupper", "towctrans", "towlower",
+ "towupper", "ungetc", "ungetwc", "va_arg", "va_end", "va_start",
+ "vfprintf", "vfwprintf", "vprintf", "vsprintf", "vswprintf",
+ "vwprintf", "wchar_t", "wcrtomb", "wcscat", "wcschr", "wcscmp",
+ "wcscoll", "wcscpy", "wcscspn", "wcsftime", "wcslen", "wcsncat",
+ "wcsncmp", "wcsncpy", "wcspbrk", "wcsrchr", "wcsrtombs", "wcsspn",
+ "wcsstr", "wcstod", "wcstok", "wcstol", "wcstombs", "wcstoul",
+ "wcsxfrm", "wctob", "wctomb", "wctrans", "wctrans_t", "wctype",
+ "wctype_t", "wint_t", "wmemchr", "wmemcmp", "wmemcpy", "wmemmove",
+ "wmemset", "wprintf", "wscanf", "xor", "xor_eq"
+};
+
+#define NUMBER_OF_HEADERS (sizeof header / sizeof *header)
+#define NUMBER_OF_PREFIXES (sizeof prefix / sizeof *prefix)
+#define NUMBER_OF_SUFFIXES (sizeof suffix / sizeof *suffix)
+#define NUMBER_OF_MACROS (sizeof macros / sizeof *macros)
+
+/* The compiler we use (given on the command line). */
+char *CC;
+/* The -I parameters for CC to find all headers. */
+char *INC;
+
+static int check_header (const char *);
+
+int
+main (int argc, char *argv[])
+{
+ int h;
+ int result = 0;
+
+ CC = argc > 1 ? argv[1] : "gcc";
+ INC = argc > 2 ? argv[2] : "";
+
+ if (system (NULL) == 0)
+ {
+ puts ("Sorry, no command processor.");
+ return EXIT_FAILURE;
+ }
+
+ for (h = 0; h < NUMBER_OF_HEADERS; ++h)
+ {
+ char file_name[HEADER_MAX];
+ sprintf (file_name, "%s.h", header[h]);
+ result |= check_header (file_name);
+ }
+
+
+#if 0
+ /* The test suite should return errors but for now this is not
+ practical. Give a warning and ask the user to correct the bugs. */
+ return result;
+#else
+ if (result)
+ fputs ("\
+##########################################################################\n\
+# The test suite found some problems with your system (see the generated #\n\
+# isomac.out file). These are all violations of the ISO C rules and #\n\
+# should be corrected. If the problem is in the libc, report it using #\n\
+# the glibcbug script to <bugs@gnu.ai.mit.edu>. If it is a problem with #\n\
+# your compiler, contact the compiler manufacturer. #\n\
+##########################################################################\n",
+ stderr);
+
+ return 0;
+#endif
+}
+
+static int
+check_header (const char *file_name)
+{
+ char line[BUFSIZ], *command;
+ FILE *input;
+ int result = 0;
+ static const char fmt[] = "\
+echo \"#include <%s>\" |\
+%s -E -dM -ansi -pedantic %s -D_LIBC -I. -I `%s --print-prog-name=include` -\
+> %s";
+
+ command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
+ + strlen (INC) + strlen (TMPFILE));
+
+ if (command == NULL)
+ {
+ puts ("No more memory.");
+ exit (1);
+ }
+
+ puts (file_name);
+ sprintf (command, fmt, file_name, CC, INC, CC, TMPFILE);
+
+ if (system (command))
+ {
+ puts ("system() returned nonzero");
+ result = 1;
+ }
+ free (command);
+ input = fopen (TMPFILE, "r");
+
+ if (input == NULL)
+ {
+ printf ("Could not read %s: ", TMPFILE);
+ perror (NULL);
+ return 1;
+ }
+
+ while (fgets (line, sizeof line, input) != NULL)
+ {
+ int i, okay = 0;
+ size_t endmac;
+ if (strlen (line) < 9 || line[7] != ' ')
+ { /* "#define A" */
+ printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
+ line);
+ result = 1;
+ continue;
+ }
+ for (i = 0; i < NUMBER_OF_PREFIXES; ++i)
+ {
+ if (!strncmp (line+8, prefix[i], strlen (prefix[i]))) {
+ ++okay;
+ break;
+ }
+ }
+ if (okay)
+ continue;
+ for (i = 0; i < NUMBER_OF_MACROS; ++i)
+ {
+ if (!strncmp (line+8, macros[i], strlen (macros[i])))
+ {
+ ++okay;
+ break;
+ }
+ }
+ if (okay)
+ continue;
+ /* Find next char after the macro identifier; this can be either
+ a space or an open parenthesis. */
+ endmac = strcspn (line + 8, " (");
+ if (line[8+endmac] == '\0')
+ {
+ printf ("malformed input, expected '#define MACRO VALUE'\n"
+ "got '%s'\n", line);
+ result = 1;
+ continue;
+ }
+ for (i = 0; i < NUMBER_OF_SUFFIXES; ++i)
+ {
+ size_t len = strlen (suffix[i]);
+ if (!strncmp (line + 8 + endmac - len, suffix[i], len))
+ {
+ ++okay;
+ break;
+ }
+ }
+ if (!okay)
+ {
+ fputs (line, stdout);
+ result = 2;
+ }
+ }
+ fclose (input);
+ remove (TMPFILE);
+
+ return result;
+}
+
+/* EOF */
-/* Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+/* Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
_IO_clearerr (fp);
_IO_funlockfile (fp);
}
-
-#ifdef _IO_MTSAFE_IO
-weak_alias (clearerr, clearerr_locked)
-#endif
return result;
}
weak_alias (_IO_feof, feof)
-
-#ifdef _IO_MTSAFE_IO
-/* The feof implementation for libio does not require locking because
- it only accesses once a single variable and this is already atomic
- (at least at thread level). */
-
-weak_alias (_IO_feof, feof_locked)
-#endif
return result;
}
weak_alias (_IO_ferror, ferror)
-
-#ifdef _IO_MTSAFE_IO
-
-weak_alias (ferror, ferror_locked)
-#endif
(at least at thread level). */
weak_alias (fileno, fileno_unlocked)
-weak_alias (fileno, fileno_locked)
#endif
_IO_cleanup_region_end (1);
return result;
}
-
-weak_alias (fputc, fputc_locked)
}
#undef getc
weak_alias (_IO_getc, getc)
-
-#ifdef _IO_MTSAFE_IO
-# undef getc_locked
-
-weak_alias (getc, getc_locked)
-#endif
_IO_cleanup_region_end (1);
return result;
}
-
-#ifdef _IO_MTSAFE_IO
-# undef getchar_locked
-
-weak_alias (getchar, getchar_locked)
-#endif
}
weak_alias (_IO_fflush, fflush)
-
-#ifdef _IO_MTSAFE_IO
-weak_alias (_IO_fflush, fflush_locked)
-#endif
-/* Copyright (C) 1991, 1995, 1996 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
+/* Copyright (C) 1991, 1995, 1996, 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
-The GNU C Library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public License as
-published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version.
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
-The GNU C Library 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
-Library General Public License for more details.
+ The GNU C Library 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
+ Library General Public License for more details.
-You should have received a copy of the GNU Library General Public
-License along with the GNU C Library; see the file COPYING.LIB. If
-not, write to the Free Software Foundation, Inc., 675 Mass Ave,
-Cambridge, MA 02139, USA. */
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
#include "libioP.h"
#include "stdio.h"
}
#undef putc
weak_alias (_IO_putc, putc)
-
-#ifdef _IO_MTSAFE_IO
-# undef putc_locked
-
-weak_alias (putc, putc_locked)
-#endif
-/* Copyright (C) 1991, 1995, 1996 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
+/* Copyright (C) 1991, 1995, 1996, 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
-The GNU C Library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public License as
-published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version.
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
-The GNU C Library 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
-Library General Public License for more details.
+ The GNU C Library 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
+ Library General Public License for more details.
-You should have received a copy of the GNU Library General Public
-License along with the GNU C Library; see the file COPYING.LIB. If
-not, write to the Free Software Foundation, Inc., 675 Mass Ave,
-Cambridge, MA 02139, USA. */
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
#include "libioP.h"
#include "stdio.h"
__libc_cleanup_region_end (1);
return result;
}
-
-#ifdef _IO_MTSAFE_IO
-# undef putchar_locked
-
-weak_alias (putchar, putchar_locked)
-#endif
-/* This is part of the iostream/stdio library, providing -*- C -*- I/O.
- Define ANSI C stdio on top of C++ iostreams.
+/* Define ISO C stdio on top of C++ iostreams.
Copyright (C) 1991, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public
-License as published by the Free Software Foundation; either
-version 2 of the License, or (at your option) any later version.
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+ The GNU C Library 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
+ Library General Public License for more details.
-This library 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
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with this library; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-*/
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
/*
* ISO C Standard: 4.9 INPUT/OUTPUT <stdio.h>
*/
#ifndef _STDIO_H
-#define _STDIO_H
+
+#if !defined __need_FILE
+#define _STDIO_H 1
+#include <features.h>
+
+__BEGIN_DECLS
+
+#define __need_size_t
+#define __need_NULL
+#include <stddef.h>
+
+#include <gnu/types.h>
+#endif /* Don't need FILE. */
+#undef __need_FILE
+
+
+#ifndef __FILE_defined
+
+/* The opaque type of streams. */
+typedef struct _IO_FILE FILE;
+
+#define __FILE_defined 1
+#endif /* FILE not defined. */
+
+
+#ifdef _STDIO_H
#define _STDIO_USES_IOSTREAM
#include <libio.h>
-#ifndef NULL
-#ifdef __cplusplus
-#define NULL 0
-#else
-#define NULL (void*)0
-#endif
-#endif
+/* The type of the second argument to `fgetpos' and `fsetpos'. */
+typedef _G_fpos_t fpos_t;
-#ifndef EOF
-#define EOF (-1)
-#endif
+
+/* Generate a unique file name (and possibly open it with mode "w+b"). */
+extern char *__stdio_gen_tempname __P ((char *__buf, size_t __bufsize,
+ __const char *__dir,
+ __const char *__pfx,
+ int __dir_search,
+ size_t *__lenptr,
+ FILE **__streamptr));
+
+
+/* Print out MESSAGE on the error output and abort. */
+extern void __libc_fatal __P ((__const char *__message))
+ __attribute__ ((__noreturn__));
+
+
+/* The possibilities for the third argument to `setvbuf'. */
+#define _IOFBF 0 /* Fully buffered. */
+#define _IOLBF 1 /* Line buffered. */
+#define _IONBF 2 /* No buffering. */
+
+
+/* Default buffer size. */
#ifndef BUFSIZ
#define BUFSIZ _IO_BUFSIZ
#endif
-#define _IOFBF 0 /* Fully buffered. */
-#define _IOLBF 1 /* Line buffered. */
-#define _IONBF 2 /* No buffering. */
-
-#define SEEK_SET 0
-#define SEEK_CUR 1
-#define SEEK_END 2
-
- /* define size_t. Crud in case <sys/types.h> has defined it. */
-#if !defined(_SIZE_T) && !defined(_T_SIZE_) && !defined(_T_SIZE)
-#if !defined(__SIZE_T) && !defined(_SIZE_T_) && !defined(___int_size_t_h)
-#if !defined(_GCC_SIZE_T) && !defined(_SIZET_)
-#define _SIZE_T
-#define _T_SIZE_
-#define _T_SIZE
-#define __SIZE_T
-#define _SIZE_T_
-#define ___int_size_t_h
-#define _GCC_SIZE_T
-#define _SIZET_
-typedef _IO_size_t size_t;
-#endif
-#endif
+
+/* End of file character.
+ Some things throughout the library rely on this being -1. */
+#ifndef EOF
+#define EOF (-1)
#endif
-typedef struct _IO_FILE FILE;
-typedef _IO_fpos_t fpos_t;
-#include <stdio_lim.h>
+/* The possibilities for the third argument to `fseek'.
+ These values should not be changed. */
+#define SEEK_SET 0 /* Seek from beginning of file. */
+#define SEEK_CUR 1 /* Seek from current position. */
+#define SEEK_END 2 /* Seek from end of file. */
+
#ifdef __USE_SVID
/* Default path prefix for `tempnam' and `tmpnam'. */
#define P_tmpdir "/tmp"
#endif
-/* For use by debuggers. These are linked in if printf or fprintf are used. */
-extern FILE *stdin, *stdout, *stderr; /* TODO */
+/* Get the values:
+ L_tmpnam How long an array of chars must be to be passed to `tmpnam'.
+ TMP_MAX The minimum number of unique filenames generated by tmpnam
+ (and tempnam when it uses tmpnam's name space),
+ or tempnam (the two are separate).
+ L_ctermid How long an array to pass to `ctermid'.
+ L_cuserid How long an array to pass to `cuserid'.
+ FOPEN_MAX Minimum number of files that can be open at once.
+ FILENAME_MAX Maximum length of a filename. */
+#include <stdio_lim.h>
+
+
+/* Standard streams. */
+extern FILE *stdin, *stdout, *stderr;
+/* Refer to the real names by default. */
#define stdin _IO_stdin
#define stdout _IO_stdout
#define stderr _IO_stderr
-#ifdef __cplusplus
-extern "C" {
-#endif
-#ifndef __P
-#if defined(__STDC__) || defined(__cplusplus) || defined(c_plusplus)
-#define __P(args) args
-#else
-#define __P(args) ()
-#endif
-#endif /*!__P*/
-
-extern void clearerr __P ((FILE*));
-extern int fclose __P ((FILE*));
-extern int feof __P ((FILE*));
-extern int ferror __P ((FILE*));
-extern int fflush __P ((FILE*));
-extern int fgetc __P ((FILE *));
-extern int fgetpos __P ((FILE* fp, fpos_t *pos));
-extern char* fgets __P ((char*, int, FILE*));
-extern FILE* fopen __P ((__const char*, __const char*));
-extern FILE* fopencookie __P ((void *cookie, __const char *mode,
- _IO_cookie_io_functions_t io_functions));
-extern int fprintf __P ((FILE*, __const char* format, ...));
-extern int fputc __P ((int, FILE*));
-extern int fputs __P ((__const char *str, FILE *fp));
-extern size_t fread __P ((void*, size_t, size_t, FILE*));
-extern FILE* freopen __P ((__const char*, __const char*, FILE*));
-extern int fscanf __P ((FILE *fp, __const char* format, ...));
-extern int fseek __P ((FILE* fp, long int offset, int whence));
-extern int fsetpos __P ((FILE* fp, __const fpos_t *pos));
-extern long int ftell __P ((FILE* fp));
-extern size_t fwrite __P ((__const void*, size_t, size_t, FILE*));
-extern int getc __P ((FILE *));
-extern int getchar __P ((void));
-extern char* gets __P ((char*));
-extern void perror __P ((__const char *));
-extern int printf __P ((__const char* format, ...));
-extern int putc __P ((int, FILE *));
-extern int putchar __P ((int));
-extern int puts __P ((__const char *str));
-extern int remove __P ((__const char*));
-extern int rename __P ((__const char* _old, __const char* _new));
-extern void rewind __P ((FILE*));
-extern int scanf __P ((__const char* format, ...));
-extern void setbuf __P ((FILE*, char*));
-extern void setlinebuf __P ((FILE*));
-extern void setbuffer __P ((FILE*, char*, int));
-extern int setvbuf __P ((FILE*, char*, int mode, size_t size));
-extern int sprintf __P ((char*, __const char* format, ...));
-extern int sscanf __P ((__const char* string, __const char* format, ...));
-extern FILE* tmpfile __P ((void));
-extern char* tmpnam __P ((char*));
-#ifdef __USE_MISC
-extern char* tmpnam_r __P ((char*));
+/* Remove file FILENAME. */
+extern int remove __P ((__const char *__filename));
+/* Rename file OLD to NEW. */
+extern int rename __P ((__const char *__old, __const char *__new));
+
+
+/* Create a temporary file and open it read/write. */
+extern FILE *tmpfile __P ((void));
+/* Generate a temporary filename. */
+extern char *tmpnam __P ((char *__s));
+
+#ifdef __USE_MISC
+/* This is the reentrant variant of `tmpnam'. The only difference is
+ that it does not allow S to be NULL. */
+extern char *tmpnam_r __P ((char *__s));
#endif
-#if defined(__USE_SVID) || defined(__USE_XOPEN)
+
+
+#if defined __USE_SVID || defined __USE_XOPEN
+/* Generate a unique temporary filename using up to five characters of PFX
+ if it is not NULL. The directory to put this file in is searched for
+ as follows: First the environment variable "TMPDIR" is checked.
+ If it contains the name of a writable directory, that directory is used.
+ If not and if DIR is not NULL, that value is checked. If that fails,
+ P_tmpdir is tried and finally "/tmp". The storage for the filename
+ is allocated by `malloc'. */
extern char *tempnam __P ((__const char *__dir, __const char *__pfx));
#endif
-extern char *__stdio_gen_tempname __P ((char *__buf, size_t bufsize,
- __const char *dir, __const char *pfx,
- int dir_search, size_t *lenptr,
- FILE **streamptr));
-extern int ungetc __P ((int c, FILE* fp));
-extern int vfprintf __P ((FILE *fp, char __const *fmt0, _G_va_list));
-extern int vprintf __P ((char __const *fmt, _G_va_list));
-extern int vsprintf __P ((char* string, __const char* format, _G_va_list));
-extern void __libc_fatal __P ((__const char *__message))
- __attribute__ ((__noreturn__));
-#ifndef __STRICT_ANSI__
-extern int dprintf __P ((int, __const char *, ...));
-extern int vdprintf __P ((int, __const char *, _G_va_list));
-extern int vfscanf __P ((FILE*, __const char *, _G_va_list));
-extern int __vfscanf __P ((FILE*, __const char *, _G_va_list));
-extern int vscanf __P ((__const char *, _G_va_list));
-extern int vsscanf __P ((__const char *, __const char *, _G_va_list));
-extern int __vsscanf __P ((__const char *, __const char *, _G_va_list));
+
+/* Close STREAM. */
+extern int fclose __P ((FILE *__stream));
+/* Flush STREAM, or all streams if STREAM is NULL. */
+extern int fflush __P ((FILE *__stream));
+
+#ifdef __USE_MISC
+/* Faster versions when locking is not required. */
+extern int fclose_unlocked __P ((FILE *__stream));
+extern int fflush_unlocked __P ((FILE *__stream));
#endif
#ifdef __USE_GNU
+/* Close all streams. */
extern int __fcloseall __P ((void));
extern int fcloseall __P ((void));
-
-struct obstack;
-extern int obstack_vprintf __P ((struct obstack *__obstack,
- __const char *__fmt, _G_va_list));
-extern int obstack_printf __P ((struct obstack *__obstack, __const char *__fmt,
- ...));
#endif
-#if !defined(__STRICT_ANSI__) || defined(_POSIX_SOURCE)
-extern FILE *fdopen __P ((int, __const char *));
-extern int fileno __P ((FILE*));
-extern FILE* popen __P ((__const char*, __const char*));
-extern int pclose __P ((FILE*));
-
-#define L_ctermid 9
-#define L_cuserid 9
-/* Return the name of the controlling terminal. */
-extern char *ctermid __P ((char *__buf));
+/* Open a file and create a new stream for it. */
+extern FILE *fopen __P ((__const char *__filename, __const char *__modes));
+/* Open a file, replacing an existing stream with it. */
+extern FILE *freopen __P ((__const char *__restrict __filename,
+ __const char *__restrict __modes,
+ FILE *__restrict __stream));
-/* Get character login name of the user. */
-extern char *cuserid __P ((char * __buf));
+#ifdef __USE_POSIX
+/* Create a new stream that refers to an existing system file descriptor. */
+extern FILE *fdopen __P ((int __fd, __const char *__modes));
#endif
-#ifdef __USE_GNU
-extern _IO_ssize_t getdelim __P ((char **, size_t *, int, FILE*));
-extern _IO_ssize_t getline __P ((char **, size_t *, FILE *));
-extern _IO_ssize_t __getline __P ((char **, size_t *, FILE *));
-
-extern int snprintf __P ((char *, size_t, __const char *, ...));
-extern int __snprintf __P ((char *, size_t, __const char *, ...));
-extern int vsnprintf __P ((char *, size_t, __const char *, _G_va_list));
-extern int __vsnprintf __P ((char *, size_t, __const char *, _G_va_list));
-
-extern int asprintf __P ((char **, const char *, ...));
-extern int vasprintf __P ((char **, const char *, _G_va_list));
+#ifdef __USE_GNU
+/* Create a new stream that refers to the given magic cookie,
+ and uses the given functions for input and output. */
+extern FILE *fopencookie __P ((void *__magic_cookie, __const char *__modes,
+ _IO_cookie_io_functions_t __io_funcs));
/* Open a stream that writes into a malloc'd buffer that is expanded as
necessary. *BUFLOC and *SIZELOC are updated with the buffer's location
extern FILE *open_memstream __P ((char **__bufloc, size_t *__sizeloc));
#endif
-extern int __underflow __P ((struct _IO_FILE*));
-extern int __overflow __P ((struct _IO_FILE*, int));
-#ifdef __USE_BSD
-extern int sys_nerr;
-extern const char *const sys_errlist[];
-#endif
-#ifdef __USE_GNU
-extern int _sys_nerr;
-extern const char *const _sys_errlist[];
+/* If BUF is NULL, make STREAM unbuffered.
+ Else make it use buffer BUF, of size BUFSIZ. */
+extern void setbuf __P ((FILE *__restrict __stream, char *__restrict __buf));
+/* Make STREAM use buffering mode MODE.
+ If BUF is not NULL, use N bytes of it for buffering;
+ else allocate an internal buffer N bytes long. */
+extern int setvbuf __P ((FILE *__restrict __stream, char *__restrict __buf,
+ int __modes, size_t __n));
+
+#ifdef __USE_BSD
+/* If BUF is NULL, make STREAM unbuffered.
+ Else make it use SIZE bytes of BUF for buffering. */
+extern void setbuffer __P ((FILE *__stream, char *__buf, size_t __size));
+
+/* Make STREAM line-buffered. */
+extern void setlinebuf __P ((FILE *__stream));
#endif
-/* Handle locking of streams. */
-#ifdef __USE_MISC
-extern void clearerr_locked __P ((FILE *));
-extern void clearerr_unlocked __P ((FILE *));
-extern int feof_locked __P ((FILE *));
-extern int feof_unlocked __P ((FILE *));
-extern int ferror_locked __P ((FILE*));
-extern int ferror_unlocked __P ((FILE*));
-extern int fileno_locked __P ((FILE *));
-extern int fileno_unlocked __P ((FILE *));
-extern int fclose_unlocked __P ((FILE *));
-extern int fflush_locked __P ((FILE *));
-extern int fflush_unlocked __P ((FILE *));
-extern size_t fread_unlocked __P ((void *, size_t, size_t, FILE *));
-extern size_t fwrite_unlocked __P ((const void *, size_t, size_t, FILE *));
-
-extern int fputc_locked __P ((int, FILE*));
-extern int fputc_unlocked __P ((int, FILE*));
-extern int getc_locked __P ((FILE *));
-extern int getchar_locked __P ((void));
-extern int putc_locked __P ((int, FILE *));
-extern int putchar_locked __P ((int));
-
-# ifndef _LIBC
-# define getc_locked(fp) _IO_getc (fp)
-# define getchar_locked() _IO_getc (stdin)
-# define putchar_locked(c) _IO_putc (c, stdout)
-# endif
+
+/* Write formatted output to STREAM. */
+extern int fprintf __P ((FILE *__restrict __stream,
+ __const char *__restrict __format, ...));
+/* Write formatted output to stdout. */
+extern int printf __P ((__const char *__restrict __format, ...));
+/* Write formatted output to S. */
+extern int sprintf __P ((char *__restrict __s,
+ __const char *__restrict __format, ...));
+
+/* Write formatted output to S from argument list ARG. */
+extern int vfprintf __P ((FILE *__restrict __s,
+ __const char *__restrict __format,
+ _G_va_list __arg));
+/* Write formatted output to stdout from argument list ARG. */
+extern int vprintf __P ((__const char *__restrict __format,
+ _G_va_list __arg));
+/* Write formatted output to S from argument list ARG. */
+extern int vsprintf __P ((char *__restrict __s,
+ __const char *__restrict __format,
+ _G_va_list __arg));
+
+#ifdef __OPTIMIZE__
+extern __inline int
+vprintf (const char *__restrict __fmt, _G_va_list __arg)
+{
+ return vfprintf (stdout, __fmt, __arg);
+}
+#endif /* Optimizing. */
+
+#ifdef __USE_GNU
+/* Maximum chars of output to write in MAXLEN. */
+extern int __snprintf __P ((char *__s, size_t __maxlen,
+ __const char *__format, ...));
+extern int snprintf __P ((char *__s, size_t __maxlen,
+ __const char *__format, ...));
+
+extern int __vsnprintf __P ((char *__s, size_t __maxlen,
+ __const char *__format, _G_va_list __arg));
+extern int vsnprintf __P ((char *__s, size_t __maxlen,
+ __const char *__format, _G_va_list __arg));
+
+/* Write formatted output to a string dynamically allocated with `malloc'.
+ Store the address of the string in *PTR. */
+extern int vasprintf __P ((char **__ptr, __const char *__f,
+ _G_va_list __arg));
+extern int asprintf __P ((char **__ptr, __const char *__fmt, ...));
+
+/* Write formatted output to a file descriptor. */
+extern int vdprintf __P ((int __fd, __const char *__fmt, _G_va_list __arg));
+extern int dprintf __P ((int __fd, __const char *__fmt, ...));
#endif
+
+/* Read formatted input from STREAM. */
+extern int fscanf __P ((FILE *__restrict __stream,
+ __const char *__restrict __format, ...));
+/* Read formatted input from stdin. */
+extern int scanf __P ((__const char *__restrict __format, ...));
+/* Read formatted input from S. */
+extern int sscanf __P ((__const char *__restrict __s,
+ __const char *__restrict __format, ...));
+
+#ifdef __USE_GNU
+/* Read formatted input from S into argument list ARG. */
+extern int __vfscanf __P ((FILE *__s, __const char *__format,
+ _G_va_list __arg));
+extern int vfscanf __P ((FILE *__s, __const char *__format,
+ _G_va_list __arg));
+
+/* Read formatted input from stdin into argument list ARG. */
+extern int __vscanf __P ((__const char *__format, _G_va_list __arg));
+extern int vscanf __P ((__const char *__format, _G_va_list __arg));
+
+/* Read formatted input from S into argument list ARG. */
+extern int __vsscanf __P ((__const char *__s, __const char *__format,
+ _G_va_list __arg));
+extern int vsscanf __P ((__const char *__s, __const char *__format,
+ _G_va_list __arg));
+
+
+#ifdef __OPTIMIZE__
+extern __inline int
+vfscanf (FILE *__s, const char *__fmt, _G_va_list __arg)
+{
+ return __vfscanf (__s, __fmt, __arg);
+}
+extern __inline int
+vscanf (const char *__fmt, _G_va_list __arg)
+{
+ return __vfscanf (stdin, __fmt, __arg);
+}
+extern __inline int
+vsscanf (const char *__s, const char *__fmt, _G_va_list __arg)
+{
+ return __vsscanf (__s, __fmt, __arg);
+}
+#endif /* Optimizing. */
+#endif /* Use GNU. */
+
+
+/* Read a character from STREAM. */
+extern int fgetc __P ((FILE *__stream));
+extern int getc __P ((FILE *__stream));
+
+/* Read a character from stdin. */
+extern int getchar __P ((void));
+
+/* The C standard explicitly says this is a macro, so we always do the
+ optimization for it. */
+#define getc(_fp) _IO_getc (_fp)
+
+#ifdef __OPTIMIZE__
+extern __inline int
+getchar (void)
+{
+ return _IO_getc (stdin);
+}
+#endif /* Optimizing. */
+
#if defined __USE_POSIX || defined __USE_MISC
/* These are defined in POSIX.1:1996. */
-extern void flockfile __P ((FILE *));
-extern void funlockfile __P ((FILE *));
-extern int ftrylockfile __P ((FILE *));
-
-extern int getc_unlocked __P ((FILE *));
+extern int getc_unlocked __P ((FILE *__stream));
extern int getchar_unlocked __P ((void));
-extern int putc_unlocked __P ((int, FILE *));
-extern int putchar_unlocked __P ((int));
-
-# ifndef _LIBC
-# define getc_unlocked(fp) _IO_getc_unlocked (fp)
-# define getchar_unlocked() _IO_getc_unlocked (stdin)
-# define putc_unlocked(c, fp) _IO_putc_unlocked ((c), (fp))
-# define putchar_unlocked(c) _IO_putc_unlocked ((c), stdout)
-# endif
-#endif /* POSIX || misc */
-#define getc(_fp) _IO_getc (_fp)
+#ifdef __OPTIMIZE__
+extern __inline int
+getc_unlocked (FILE *__fp)
+{
+ return _IO_getc_unlocked (__fp);
+}
+
+extern __inline int
+getchar_unlocked (void)
+{
+ return _IO_getc_unlocked (stdin);
+}
+#endif /* Optimizing. */
+#endif /* Use POSIX or MISC. */
+
+
+/* Write a character to STREAM. */
+extern int fputc __P ((int __c, FILE *__stream));
+extern int putc __P ((int __c, FILE *__stream));
+
+/* Write a character to stdout. */
+extern int putchar __P ((int __c));
+
+/* The C standard explicitly says this can be a macro,
+ so we always do the optimization for it. */
#define putc(_ch, _fp) _IO_putc (_ch, _fp)
-#define putchar(_ch) _IO_putc (_ch, stdout)
-#define getchar() _IO_getc (stdin)
+#ifdef __OPTIMIZE__
+extern __inline int
+putchar (int __c)
+{
+ return _IO_putc (__c, stdout);
+}
+#endif
-#ifdef __cplusplus
+#ifdef __USE_MISC
+/* Faster version when locking is not necessary. */
+extern int fputc_unlocked __P ((int __c, FILE *__stream));
+
+#ifdef __OPTIMIZE__
+extern __inline int
+fputc_unlocked (int __c, FILE *__stream)
+{
+ return _IO_putc_unlocked (__c, __stream);
}
+#endif /* Optimizing. */
+#endif /* Use MISC. */
+
+#if defined __USE_POSIX || defined __USE_MISC
+/* These are defined in POSIX.1:1996. */
+extern int putc_unlocked __P ((int __c, FILE *__stream));
+extern int putchar_unlocked __P ((int __c));
+
+#ifdef __OPTIMIZE__
+extern __inline int
+putc_unlocked (int __c, FILE *__stream)
+{
+ return _IO_putc_unlocked (__c, __stream);
+}
+
+extern __inline int
+putchar_unlocked (int __c)
+{
+ return _IO_putc_unlocked (__c, stdout);
+}
+#endif /* Optimizing. */
+#endif /* Use POSIX or MISc. */
+
+
+#if defined __USE_SVID || defined __USE_MISC
+/* Get a word (int) from STREAM. */
+extern int getw __P ((FILE *__stream));
+
+/* Write a word (int) to STREAM. */
+extern int putw __P ((int __w, FILE *__stream));
#endif
+/* Get a newline-terminated string of finite length from STREAM. */
+extern char *fgets __P ((char *__restrict __s, int __n,
+ FILE *__restrict __stream));
+
+/* Get a newline-terminated string from stdin, removing the newline.
+ DO NOT USE THIS FUNCTION!! There is no limit on how much it will read. */
+extern char *gets __P ((char *__s));
+
+
+#ifdef __USE_GNU
+/* Read up to (and including) a DELIMITER from STREAM into *LINEPTR
+ (and null-terminate it). *LINEPTR is a pointer returned from malloc (or
+ NULL), pointing to *N characters of space. It is realloc'd as
+ necessary. Returns the number of characters read (not including the
+ null terminator), or -1 on error or EOF. */
+_IO_ssize_t __getdelim __P ((char **__lineptr, size_t *__n,
+ int __delimiter, FILE *__stream));
+_IO_ssize_t getdelim __P ((char **__lineptr, size_t *__n,
+ int __delimiter, FILE *__stream));
+
+/* Like `getdelim', but reads up to a newline. */
+_IO_ssize_t __getline __P ((char **__lineptr, size_t *__n, FILE *__stream));
+_IO_ssize_t getline __P ((char **__lineptr, size_t *__n, FILE *__stream));
+
+#ifdef __OPTIMIZE__
+extern __inline _IO_ssize_t
+getline (char **__lineptr, size_t *__n, FILE *__stream)
+{
+ return __getdelim (__lineptr, __n, '\n', __stream);
+}
+#endif /* Optimizing. */
+#endif
+
+
+/* Write a string to STREAM. */
+extern int fputs __P ((__const char *__restrict __s,
+ FILE *__restrict __stream));
+/* Write a string, followed by a newline, to stdout. */
+extern int puts __P ((__const char *__s));
+
+
+/* Push a character back onto the input buffer of STREAM. */
+extern int ungetc __P ((int __c, FILE *__stream));
+
+
+/* Read chunks of generic data from STREAM. */
+extern size_t fread __P ((void *__restrict __ptr, size_t __size,
+ size_t __n, FILE *__restrict __stream));
+/* Write chunks of generic data to STREAM. */
+extern size_t fwrite __P ((__const void *__restrict __ptr, size_t __size,
+ size_t __n, FILE *__restrict __s));
+
+#ifdef __USE_MISC
+/* Faster versions when locking is not necessary. */
+extern size_t fread_unlocked __P ((void *__restrict __ptr, size_t __size,
+ size_t __n, FILE *__restrict __stream));
+extern size_t fwrite_unlocked __P ((__const void *__restrict __ptr,
+ size_t __size, size_t __n,
+ FILE *__restrict __stream));
+#endif
+
+
+/* Seek to a certain position on STREAM. */
+extern int fseek __P ((FILE *__stream, long int __off, int __whence));
+/* Return the current position of STREAM. */
+extern long int ftell __P ((FILE *__stream));
+/* Rewind to the beginning of STREAM. */
+extern void rewind __P ((FILE *__stream));
+
+/* Get STREAM's position. */
+extern int fgetpos __P ((FILE *__restrict __stream,
+ fpos_t *__restrict __pos));
+/* Set STREAM's position. */
+extern int fsetpos __P ((FILE *__stream, __const fpos_t *__pos));
+
+
+/* Clear the error and EOF indicators for STREAM. */
+extern void clearerr __P ((FILE *__stream));
+/* Return the EOF indicator for STREAM. */
+extern int feof __P ((FILE *__stream));
+/* Return the error indicator for STREAM. */
+extern int ferror __P ((FILE *__stream));
+
+#ifdef __USE_MISC
+/* Faster versions when locking is not required. */
+extern void clearerr_unlocked __P ((FILE *__stream));
+extern int feof_unlocked __P ((FILE *__stream));
+extern int ferror_unlocked __P ((FILE *__stream));
+
+#ifdef __OPTIMIZE__
+extern __inline int
+feof_unlocked (FILE *__stream)
+{
+ return _IO_feof_unlocked (__stream);
+}
+
+extern __inline int
+ferror_unlocked (FILE *__stream)
+{
+ return _IO_ferror_unlocked (__stream);
+}
+#endif /* Optimizing. */
+#endif
+
+
+/* Print a message describing the meaning of the value of errno. */
+extern void perror __P ((__const char *__s));
+
+/* These variables normally should not be used directly. The `strftime'
+ function provides all the needed functionality. */
+#ifdef __USE_BSD
+extern int sys_nerr;
+extern __const char *__const sys_errlist[];
+#endif
+#ifdef __USE_GNU
+extern int _sys_nerr;
+extern __const char *__const _sys_errlist[];
+#endif
+
+
+#ifdef __USE_POSIX
+/* Return the system file descriptor for STREAM. */
+extern int fileno __P ((FILE *__stream));
+#endif /* Use POSIX. */
+
+#ifdef __USE_MISC
+/* Faster version when locking is not required. */
+extern int fileno_unlocked __P ((FILE *__stream));
+#endif
+
+
+#if (defined __USE_POSIX2 || defined __USE_SVID || defined __USE_BSD || \
+ defined __USE_MISC)
+/* Create a new stream connected to a pipe running the given command. */
+extern FILE *popen __P ((__const char *__command, __const char *__modes));
+
+/* Close a stream opened by popen and return the status of its child. */
+extern int pclose __P ((FILE *__stream));
+#endif
+
+
+#ifdef __USE_POSIX
+/* Return the name of the controlling terminal. */
+extern char *ctermid __P ((char *__s));
+#endif /* Use POSIX. */
+
+
+#ifdef __USE_XOPEN
+/* Return the name of the current user. */
+extern char *cuserid __P ((char *__s));
+#endif /* Use X/Open. */
+
+
+#ifdef __USE_GNU
+struct obstack; /* See <obstack.h>. */
+
+/* Write formatted output to an obstack. */
+extern int obstack_printf __P ((struct obstack *__obstack,
+ __const char *__format, ...));
+extern int obstack_vprintf __P ((struct obstack *__obstack,
+ __const char *__format,
+ _G_va_list __args));
+#endif /* Use GNU. */
+
+
+#if defined __USE_POSIX || defined __USE_MISC
+/* These are defined in POSIX.1:1996. */
+
+/* Acquire ownership of STREAM. */
+extern void flockfile __P ((FILE *__stream));
+
+/* Try to acquire ownership of STREAM but do not block if it is not
+ possible. */
+extern int ftrylockfile __P ((FILE *__stream));
+
+/* Relinquish the ownership granted for STREAM. */
+extern void funlockfile __P ((FILE *__stream));
+#endif /* POSIX || misc */
+
+__END_DECLS
+
+#endif /* <stdio.h> included. */
#endif /* !_STDIO_H */
_nl_C_name,
NULL, 0, 0, /* no file mapped */
MAX_USAGE_COUNT,
- 53,
+ 54,
{
{ string: "Sun" },
{ string: "Mon" },
{ string: "" },
{ string: "" },
{ word: 0 },
+ { word: 0 },
{ string: "" },
{ string: "" },
}
int
main (int argc, char *argv[])
{
+ int remaining;
+
/* Set initial values for global variables. */
show_category_name = 0;
show_keyword_name = 0;
textdomain (PACKAGE);
/* Parse and process arguments. */
- argp_parse (&argp, argc, argv, 0, 0, NULL);
+ argp_parse (&argp, argc, argv, 0, &remaining, NULL);
/* `-a' requests the names of all available locales. */
if (do_all != 0)
/* If no real argument is given we have to print the contents of the
current locale definition variables. These are LANG and the LC_*. */
- if (optind == argc && show_keyword_name == 0 && show_category_name == 0)
+ if (remaining == argc && show_keyword_name == 0 && show_category_name == 0)
{
show_locale_vars ();
exit (EXIT_SUCCESS);
}
/* Process all given names. */
- while (optind < argc)
- show_info (argv[optind++]);
+ while (remaining < argc)
+ show_info (argv[remaining++]);
exit (EXIT_SUCCESS);
}
struct charset_t *charset;
struct localedef_t *localedef;
struct copy_def_list_t *act_add_locdef;
+ int remaining;
/* Set initial values for global variables. */
copy_list = NULL;
textdomain (_libc_intl_domainname);
/* Parse and process arguments. */
- argp_parse (&argp, argc, argv, 0, 0, NULL);
+ argp_parse (&argp, argc, argv, 0, &remaining, NULL);
/* XXX POSIX is violated since for unknown option a exit value > 3
must be used. */
character map. */
verbose |= posix_conformance;
- if (argc - optind != 1)
+ if (argc - remaining != 1)
{
/* We need exactly one non-option parameter. */
argp_help (&argp, stdout, ARGP_HELP_SEE,
/* The parameter describes the output path of the constructed files.
If the described files cannot be written return a NULL pointer. */
- output_path = construct_output_path (argv[optind]);
+ output_path = construct_output_path (argv[remaining]);
cannot_write_why = errno;
/* Now that the parameters are processed we have to reset the local
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-/* V2.6.4-pt2 Sat Dec 14 1996
+/* V2.6.4-pt3 Thu Feb 20 1997
This work is mainly derived from malloc-2.6.4 by Doug Lea
<dl@cs.oswego.edu>, which is available from:
#define mALLOC_STATs __malloc_stats
#define mALLOC_USABLE_SIZe __malloc_usable_size
#define mALLOC_TRIm __malloc_trim
+#define mALLOC_GET_STATe __malloc_get_state
+#define mALLOC_SET_STATe __malloc_set_state
#else
#define mALLOC_STATs malloc_stats
#define mALLOC_USABLE_SIZe malloc_usable_size
#define mALLOC_TRIm malloc_trim
+#define mALLOC_GET_STATe malloc_get_state
+#define mALLOC_SET_STATe malloc_set_state
#endif
void mALLOC_STATs(void);
int mALLOPt(int, int);
struct mallinfo mALLINFo(void);
-#else
+Void_t* mALLOC_GET_STATe(void);
+int mALLOC_SET_STATe(Void_t*);
+
+#else /* !__STD_C */
+
#ifndef _LIBC
void ptmalloc_init();
#endif
void mALLOC_STATs();
int mALLOPt();
struct mallinfo mALLINFo();
-#endif
+Void_t* mALLOC_GET_STATe();
+int mALLOC_SET_STATe();
+
+#endif /* __STD_C */
#ifdef __cplusplus
\f
+/* Get/set state: malloc_get_state() records the current state of all
+ malloc variables (_except_ for the actual heap contents and `hook'
+ function pointers) in a system dependent, opaque data structure.
+ This data structure is dynamically allocated and can be free()d
+ after use. malloc_set_state() restores the state of all malloc
+ variables to the previously obtained state. This is especially
+ useful when using this malloc as part of a shared library, and when
+ the heap contents are saved/restored via some other method. The
+ primary example for this is GNU Emacs with its `dumping' procedure.
+ `Hook' function pointers are never saved or restored by these
+ functions. */
+
+#define MALLOC_STATE_MAGIC 0x444c4541l
+#define MALLOC_STATE_VERSION (0*0x100l + 0l) /* major*0x100 + minor */
+
+struct malloc_state {
+ long magic;
+ long version;
+ mbinptr av[NAV * 2 + 2];
+ char* sbrk_base;
+ int sbrked_mem_bytes;
+ unsigned long trim_threshold;
+ unsigned long top_pad;
+ unsigned int n_mmaps_max;
+ unsigned long mmap_threshold;
+ int check_action;
+ unsigned long max_sbrked_mem;
+ unsigned long max_total_mem;
+ unsigned int n_mmaps;
+ unsigned int max_n_mmaps;
+ unsigned long mmapped_mem;
+ unsigned long max_mmapped_mem;
+};
+
+Void_t*
+mALLOC_GET_STATe()
+{
+ mchunkptr victim;
+ struct malloc_state* ms;
+ int i;
+ mbinptr b;
+
+ ptmalloc_init();
+ (void)mutex_lock(&main_arena.mutex);
+ victim = chunk_alloc(&main_arena, request2size(sizeof(*ms)));
+ if(!victim) {
+ (void)mutex_unlock(&main_arena.mutex);
+ return 0;
+ }
+ ms = (struct malloc_state*)chunk2mem(victim);
+ ms->magic = MALLOC_STATE_MAGIC;
+ ms->version = MALLOC_STATE_VERSION;
+ ms->av[0] = main_arena.av[0];
+ ms->av[1] = main_arena.av[1];
+ for(i=0; i<NAV; i++) {
+ b = bin_at(&main_arena, i);
+ if(first(b) == b)
+ ms->av[2*i+2] = ms->av[2*i+3] = 0; /* empty bin (or initial top) */
+ else {
+ ms->av[2*i+2] = first(b);
+ ms->av[2*i+3] = last(b);
+ }
+ }
+ ms->sbrk_base = sbrk_base;
+ ms->sbrked_mem_bytes = sbrked_mem;
+ ms->trim_threshold = trim_threshold;
+ ms->top_pad = top_pad;
+ ms->n_mmaps_max = n_mmaps_max;
+ ms->mmap_threshold = mmap_threshold;
+ ms->check_action = check_action;
+ ms->max_sbrked_mem = max_sbrked_mem;
+#ifdef NO_THREADS
+ ms->max_total_mem = max_total_mem;
+#else
+ ms->max_total_mem = 0;
+#endif
+ ms->n_mmaps = n_mmaps;
+ ms->max_n_mmaps = max_n_mmaps;
+ ms->mmapped_mem = mmapped_mem;
+ ms->max_mmapped_mem = max_mmapped_mem;
+ (void)mutex_unlock(&main_arena.mutex);
+ return (Void_t*)ms;
+}
+
+int
+#if __STD_C
+mALLOC_SET_STATe(Void_t* msptr)
+#else
+mALLOC_SET_STATe(msptr) Void_t* msptr;
+#endif
+{
+ struct malloc_state* ms = (struct malloc_state*)msptr;
+ int i;
+ mbinptr b;
+
+ ptmalloc_init();
+ if(ms->magic != MALLOC_STATE_MAGIC) return -1;
+ /* Must fail if the major version is too high. */
+ if((ms->version & ~0xffl) > (MALLOC_STATE_VERSION & ~0xffl)) return -2;
+ (void)mutex_lock(&main_arena.mutex);
+ main_arena.av[0] = ms->av[0];
+ main_arena.av[1] = ms->av[1];
+ for(i=0; i<NAV; i++) {
+ b = bin_at(&main_arena, i);
+ if(ms->av[2*i+2] == 0)
+ first(b) = last(b) = b;
+ else {
+ first(b) = ms->av[2*i+2];
+ last(b) = ms->av[2*i+3];
+ if(i > 0) {
+ /* Make sure the links to the `av'-bins in the heap are correct. */
+ first(b)->bk = b;
+ last(b)->fd = b;
+ }
+ }
+ }
+ sbrk_base = ms->sbrk_base;
+ sbrked_mem = ms->sbrked_mem_bytes;
+ trim_threshold = ms->trim_threshold;
+ top_pad = ms->top_pad;
+ n_mmaps_max = ms->n_mmaps_max;
+ mmap_threshold = ms->mmap_threshold;
+ check_action = ms->check_action;
+ max_sbrked_mem = ms->max_sbrked_mem;
+#ifdef NO_THREADS
+ max_total_mem = ms->max_total_mem;
+#endif
+ n_mmaps = ms->n_mmaps;
+ max_n_mmaps = ms->max_n_mmaps;
+ mmapped_mem = ms->mmapped_mem;
+ max_mmapped_mem = ms->max_mmapped_mem;
+ /* add version-dependent code here */
+ (void)mutex_unlock(&main_arena.mutex);
+ return 0;
+}
+
+\f
+
#if defined(_LIBC) || defined(MALLOC_HOOKS)
/* A simple, standard set of debugging hooks. Overhead is `only' one
weak_alias (__malloc_stats, malloc_stats)
weak_alias (__malloc_usable_size, malloc_usable_size)
weak_alias (__malloc_trim, malloc_trim)
+weak_alias (__malloc_get_state, malloc_get_state)
+weak_alias (__malloc_set_state, malloc_set_state)
#endif
/*
History:
+ V2.6.4-pt3 Thu Feb 20 1997 Wolfram Gloger (wmglo@dent.med.uni-muenchen.de)
+ * Added malloc_get/set_state() (mainly for use in GNU emacs),
+ using interface from Marcus Daniels
+ * All parameters are now adjustable via environment variables
+
V2.6.4-pt2 Sat Dec 14 1996 Wolfram Gloger (wmglo@dent.med.uni-muenchen.de)
* Added debugging hooks
* Fixed possible deadlock in realloc() when out of memory
/* Prints brief summary statistics on stderr. */
extern void malloc_stats __MALLOC_P ((void));
+/* Record the state of all malloc variables in an opaque data structure. */
+extern __malloc_ptr_t malloc_get_state __MALLOC_P ((void));
+
+/* Restore the state of all malloc variables from data obtained with
+ malloc_get_state(). */
+extern int malloc_set_state __MALLOC_P ((__malloc_ptr_t __ptr));
+
#if defined(__GLIBC__) || defined(MALLOC_HOOKS)
/* Hooks for debugging versions. */
/* Basic platform-independent macro definitions for mutexes and
thread-specific data.
- Copyright (C) 1996 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Wolfram Gloger <wmglo@dent.med.uni-muenchen.de>, 1996.
(__pthread_mutex_unlock != NULL ? __pthread_mutex_unlock (m) : 0)
#elif defined(MUTEX_INITIALIZER)
+/* Assume hurd, with cthreads */
-typedef thread_t thread_id;
+/* Cthreads `mutex_t' is a pointer to a mutex, and malloc wants just the
+ mutex itself. */
+#undef mutex_t
+#define mutex_t struct mutex
-/* mutex */
-typedef mutex_t mutex_t;
+#undef mutex_lock
+#define mutex_lock(m) (__mutex_lock(m), 0)
+
+#undef mutex_unlock
+#define mutex_unlock(m) (__mutex_unlock(m), 0)
+
+#define mutex_trylock(m) (!__mutex_trylock(m))
+
+#include <hurd/threadvar.h>
/* thread specific data */
-typedef pthread_key_t tsd_key_t;
+typedef int tsd_key_t;
+
+static int tsd_keys_alloced = 0;
+
+#define tsd_key_create(key, destr) \
+ (assert (tsd_keys_alloced == 0), tsd_keys_alloced++)
+#define tsd_setspecific(key, data) \
+ (*__hurd_threadvar_location (_HURD_THREADVAR_MALLOC) = (unsigned long)(data))
+#define tsd_getspecific(key, vptr) \
+ ((vptr) = (void *)*__hurd_threadvar_location (_HURD_THREADVAR_MALLOC))
-#define mutex_init(m) __mutex_init (m)
-#define mutex_lock(m) __mutex_lock (m)
-#define mutex_trylock(m) __mutex_trylock (m)
-#define mutex_unlock(m) __mutex_unlock (m)
+/* No we're *not* using pthreads. */
+#define __pthread_initialize ((void (*)(void))0)
#else
--- /dev/null
+/* This program is to generate one of the examples in stdio.texi. */
+
+#include <stdio.h>
+
+
+static void
+print (double v)
+{
+ printf ("|%13.4a|%13.4f|%13.4e|%13.4g|\n", v, v, v, v);
+}
+
+
+int
+main (void)
+{
+ print (0.0);
+ print (0.5);
+ print (1.0);
+ print (-1.0);
+ print (100.0);
+ print (1000.0);
+ print (10000.0);
+ print (12345.0);
+ print (100000.0);
+ print (123456.0);
+
+ return 0;
+}
lower-case letters and @samp{%G} uses upper-case. @xref{Floating-Point
Conversions}, for details.
+@item @samp{%a}, @samp{%A}
+Print a floating-point number in a hexadecimal fractional notation which
+the exponent to base 2 represented in decimal digits. @samp{%a} uses
+lower-case letters and @samp{%A} uses upper-case. @xref{Floating-Point
+Conversions}, for details.
+
@item @samp{%c}
Print a single character. @xref{Other Output Conversions}.
of the result and a decimal-point character appears only if it is
followed by a digit.
+The @samp{%a} and @samp{%A} conversions are meant for representing
+floating-point number exactly in textual form so that they can be
+exchanged as texts between different programs and/or machines. The
+numbers are represented is the form
+@w{[@code{-}]@code{0x}@var{h}@code{.}@var{hhh}@code{p}[@code{+}|@code{-}]@var{dd}}.
+At the left of the decimal-point character exactly one digit is print.
+This character is only @code{0} is the number is denormalized.
+Otherwise the value is unspecifed; it is implemention dependent how many
+bits are used. The number of hexadecimal digits on the right side of
+the decimal-point character is equal to the precision. If the precision
+is zero it is determined to be large enough to provide an exact
+representation of the number (or it is large enough to distinguish two
+adjacent values if the @code{FLT_RADIX} is not a power of 2,
+@pxref{Floating Point Parameters}) For the @samp{%a} conversion
+lower-case characters are used to represent the hexadecimal number and
+the prefix and exponent sign are printed as @code{0x} and @code{p}
+respectively. Otherwise upper-case characters are used and @code{0X}
+and @code{P} are used for the representation of prefix and exponent
+string. The exponent to the base of two is printed as a decimal number
+using at least one digit but at most as many digits as necessary to
+represent the value exactly.
+
+If the value to be printed represents infinity or a NaN, the output is
+@w{[@code{-}]@code{inf}} or @code{nan} respectively if the conversion
+specifier is @samp{%a}, @samp{%e}, @samp{%f}, or @samp{%g} and it is
+@w{[@code{-}]@code{INF}} or @code{NAN} respectively if the conversion is
+@samp{%A}, @samp{%E}, or @samp{%G}.
+
The following flags can be used to modify the behavior:
@comment We use @asis instead of @samp so we can have ` ' as an item.
this template string:
@smallexample
-"|%12.4f|%12.4e|%12.4g|\n"
+"|%13.4a|%13.4f|%13.4e|%13.4g|\n"
@end smallexample
Here is the output:
@smallexample
-| 0.0000| 0.0000e+00| 0|
-| 1.0000| 1.0000e+00| 1|
-| -1.0000| -1.0000e+00| -1|
-| 100.0000| 1.0000e+02| 100|
-| 1000.0000| 1.0000e+03| 1000|
-| 10000.0000| 1.0000e+04| 1e+04|
-| 12345.0000| 1.2345e+04| 1.234e+04|
-| 100000.0000| 1.0000e+05| 1e+05|
-| 123456.0000| 1.2346e+05| 1.234e+05|
+| 0x0.0000p+0| 0.0000| 0.0000e+00| 0|
+| 0x1.0000p-1| 0.5000| 5.0000e-01| 0.5|
+| 0x1.0000p+0| 1.0000| 1.0000e+00| 1|
+| -0x1.0000p+0| -1.0000| -1.0000e+00| -1|
+| 0x1.9000p+6| 100.0000| 1.0000e+02| 100|
+| 0x1.f400p+9| 1000.0000| 1.0000e+03| 1000|
+| 0x1.3880p+13| 10000.0000| 1.0000e+04| 1e+04|
+| 0x1.81c8p+13| 12345.0000| 1.2345e+04| 1.234e+04|
+| 0x1.86a0p+16| 100000.0000| 1.0000e+05| 1e+05|
+| 0x1.e240p+16| 123456.0000| 1.2346e+05| 1.235e+05|
@end smallexample
Notice how the @samp{%g} conversion drops trailing zeros.
/* Declarations for math functions.
- Copyright (C) 1991, 92, 93, 95, 96 Free Software Foundation, Inc.
+ Copyright (C) 1991, 92, 93, 95, 96, 97 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#endif
-#ifdef __USE_SVID
+#if defined __USE_SVID && !defined __cplusplus
/* In SVID error handling, `matherr' is called with this description
- of the exceptional condition. */
+ of the exceptional condition.
+
+ We have a problem when using C++ since `exception' is reserved in
+ C++. */
struct exception
{
int type;
#define HUGE FLT_MAX
#include <float.h> /* Defines FLT_MAX. */
-#endif
+#endif /* SVID && !C++ */
#ifdef __USE_BSD
#define program_name program_invocation_name
#include <errno.h>
+/* In GNU libc we want do not want to use the common name `error' directly.
+ Instead make it a weak alias. */
+#define error __error
+#define error_at_line __error_at_line
+
#else
/* The calling program should define program_name and set it to the
if (status)
exit (status);
}
+
+#ifdef _LIBC
+/* Make the weak alias. */
+#undef error
+#undef error_at_line
+weak_alias (__error, error)
+weak_alias (__error_at_line, error_at_line)
+#endif
-/* Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
+/* Copyright (C) 1992, 93, 94, 95, 96, 97 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#define __attribute__(xyz) /* Ignore. */
#endif
+
+/* For now no version of gcc knows the `restrict' keyword. Define it
+ for now unconditionally to the empty string. */
+#define __restrict
+
#endif /* sys/cdefs.h */
#! /bin/sh
# rellns-sh - Simplified ln program to generate relative symbolic link.
-# Copyright (C) 1996 Free Software Foundation, Inc.
+# Copyright (C) 1996, 1997 Free Software Foundation, Inc.
# Written by Ulrich Drepper <drepper@cygnus.com>, October 1996
#
# This program is free software; you can redistribute it and/or modify
exit 1
fi
-# We only handle the case where SOURCE is the name of an existing file
-if test ! -f $1; then
- echo "rellns: $1 must name an existing file" >&2
- exit 1
-fi
-
case $1 in
/*)
# Make both paths absolute.
routines := \
ctermid cuserid \
- vfprintf vprintf printf_fp reg-printf printf-prs _itoa \
+ vfprintf vprintf printf_fp reg-printf printf-prs _itoa printf_fphex \
fprintf printf snprintf sprintf asprintf dprintf \
vfscanf \
fscanf scanf sscanf \
/* Floating point output for `printf'.
- Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
/* Check for special values: not a number or infinity. */
if (__isnanl (fpnum.ldbl))
{
- special = "NaN";
+ special = isupper (info->spec) ? "NAN" : "nan";
is_neg = 0;
}
else if (__isinfl (fpnum.ldbl))
{
- special = "Inf";
+ special = isupper (info->spec) ? "INF" : "inf";
is_neg = fpnum.ldbl < 0;
}
else
/* Check for special values: not a number or infinity. */
if (__isnan (fpnum.dbl))
{
- special = "NaN";
+ special = isupper (info->spec) ? "NAN" : "nan";
is_neg = 0;
}
else if (__isinf (fpnum.dbl))
{
- special = "Inf";
+ special = isupper (info->spec) ? "INF" : "inf";
is_neg = fpnum.dbl < 0;
}
else
--- /dev/null
+/* Print floating point number in hexadecimal notation according to
+ ISO C 9X.
+ Copyright (C) 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <ctype.h>
+#include <ieee754.h>
+#include <math.h>
+#include <printf.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "_itoa.h"
+#include "../locale/localeinfo.h"
+
+/* #define NDEBUG 1*/ /* Undefine this for debugging assertions. */
+#include <assert.h>
+
+/* This defines make it possible to use the same code for GNU C library and
+ the GNU I/O library. */
+#ifdef USE_IN_LIBIO
+# include <libioP.h>
+# define PUT(f, s, n) _IO_sputn (f, s, n)
+# define PAD(f, c, n) _IO_padn (f, c, n)
+/* We use this file GNU C library and GNU I/O library. So make
+ names equal. */
+# undef putc
+# define putc(c, f) _IO_putc_unlocked (c, f)
+# define size_t _IO_size_t
+# define FILE _IO_FILE
+#else /* ! USE_IN_LIBIO */
+# define PUT(f, s, n) fwrite (s, 1, n, f)
+# define PAD(f, c, n) __printf_pad (f, c, n)
+ssize_t __printf_pad __P ((FILE *, char pad, int n)); /* In vfprintf.c. */
+#endif /* USE_IN_LIBIO */
+\f
+/* Macros for doing the actual output. */
+
+#define outchar(ch) \
+ do \
+ { \
+ register const int outc = (ch); \
+ if (putc (outc, fp) == EOF) \
+ return -1; \
+ ++done; \
+ } while (0)
+
+#define PRINT(ptr, len) \
+ do \
+ { \
+ int outlen = (len); \
+ const char *cp = (ptr); \
+ while (outlen-- > 0) \
+ outchar (*cp++); \
+ } while (0)
+
+#define PADN(ch, len) \
+ do \
+ { \
+ if (PAD (fp, ch, len) != len) \
+ return -1; \
+ done += len; \
+ } \
+ while (0)
+\f
+
+int
+__printf_fphex (FILE *fp,
+ const struct printf_info *info,
+ const void *const *args)
+{
+ /* The floating-point value to output. */
+ union
+ {
+ union ieee754_double dbl;
+ union ieee854_long_double ldbl;
+ }
+ fpnum;
+
+ /* Locale-dependent representation of decimal point. */
+ wchar_t decimal;
+
+ /* "NaN" or "Inf" for the special cases. */
+ const char *special = NULL;
+
+ /* Buffer for the generated number string for the mantissa. The
+ maximal size for the mantissa is 64 bits. */
+ char numbuf[16];
+ char *numstr;
+ char *numend;
+ int negative;
+
+ /* The maximal exponent of two in decimal notation has 5 digits. */
+ char expbuf[5];
+ char *expstr;
+ int expnegative;
+ int exponent;
+
+ /* Non-zero is mantissa is zero. */
+ int zero_mantissa;
+
+ /* The leading digit before the decimal point. */
+ char leading;
+
+ /* Precision. */
+ int precision = info->prec;
+
+ /* Width. */
+ int width = info->width;
+
+ /* Number of characters written. */
+ int done = 0;
+
+
+ /* Figure out the decimal point character. */
+ if (info->extra == 0)
+ {
+ if (mbtowc (&decimal, _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT),
+ strlen (_NL_CURRENT (LC_NUMERIC, DECIMAL_POINT))) <= 0)
+ decimal = (wchar_t) *_NL_CURRENT (LC_NUMERIC, DECIMAL_POINT);
+ }
+ else
+ {
+ if (mbtowc (&decimal, _NL_CURRENT (LC_MONETARY, MON_DECIMAL_POINT),
+ strlen (_NL_CURRENT (LC_MONETARY, MON_DECIMAL_POINT))) <= 0)
+ decimal = (wchar_t) *_NL_CURRENT (LC_MONETARY, MON_DECIMAL_POINT);
+ }
+ /* Give default value. */
+ if (decimal == L'\0')
+ decimal = L'.';
+
+
+ /* Fetch the argument value. */
+ if (info->is_long_double && sizeof (long double) > sizeof (double))
+ {
+ fpnum.ldbl.d = *(const long double *) args[0];
+
+ /* Check for special values: not a number or infinity. */
+ if (__isnanl (fpnum.ldbl.d))
+ {
+ special = isupper (info->spec) ? "NAN" : "nan";
+ negative = 0;
+ }
+ else
+ {
+ if (__isinfl (fpnum.ldbl.d))
+ special = isupper (info->spec) ? "INF" : "inf";
+
+ negative = fpnum.ldbl.d < 0;
+ }
+ }
+ else
+ {
+ fpnum.dbl.d = *(const double *) args[0];
+
+ /* Check for special values: not a number or infinity. */
+ if (__isnan (fpnum.dbl.d))
+ {
+ special = isupper (info->spec) ? "NAN" : "nan";
+ negative = 0;
+ }
+ else
+ {
+ if (__isinf (fpnum.dbl.d))
+ special = isupper (info->spec) ? "INF" : "inf";
+
+ negative = fpnum.dbl.d < 0;
+ }
+ }
+
+ if (special)
+ {
+ int width = info->prec > info->width ? info->prec : info->width;
+
+ if (negative || info->showsign || info->space)
+ --width;
+ width -= 3;
+
+ if (!info->left && width > 0)
+ PADN (' ', width);
+
+ if (negative)
+ outchar ('-');
+ else if (info->showsign)
+ outchar ('+');
+ else if (info->space)
+ outchar (' ');
+
+ PRINT (special, 3);
+
+ if (info->left && width > 0)
+ PADN (' ', width);
+
+ return done;
+ }
+
+ /* We are handling here only 64 and 80 bit IEEE foating point
+ numbers. */
+ if (info->is_long_double == 0 || sizeof (double) == sizeof (long double))
+ {
+ /* We have 52 bits of mantissa plus one implicit digit. Since
+ 52 bits are representable without rest using hexadecimal
+ digits we use only the implicit digits for the number before
+ the decimal point. */
+ if (sizeof (unsigned long int) > 6)
+ {
+ unsigned long int num;
+
+ num = (((unsigned long int) fpnum.dbl.ieee.mantissa0) << 32
+ | fpnum.dbl.ieee.mantissa1);
+
+ zero_mantissa = num == 0;
+
+ numstr = _itoa_word (num, numbuf + sizeof numbuf, 16,
+ info->spec == 'A');
+ }
+ else
+ {
+ unsigned long long int num;
+
+ num = (((unsigned long long int) fpnum.dbl.ieee.mantissa0) << 32
+ | fpnum.dbl.ieee.mantissa1);
+
+ zero_mantissa = num == 0;
+
+ numstr = _itoa (num, numbuf + sizeof numbuf, 16, info->spec == 'A');
+ }
+
+ /* Fill with zeroes. */
+ while (numstr > numbuf + (sizeof numbuf - 13)) /* 52 ÷ 4 = 13 */
+ *--numstr = '0';
+
+ leading = fpnum.dbl.ieee.exponent == 0 ? '0' : '1';
+
+ exponent = fpnum.dbl.ieee.exponent;
+
+ if (exponent != 0 && exponent < IEEE754_DOUBLE_BIAS)
+ {
+ expnegative = 1;
+ exponent = abs (exponent - IEEE754_DOUBLE_BIAS);
+ }
+ else
+ {
+ expnegative = 0;
+ if (exponent != 0)
+ exponent -= IEEE754_DOUBLE_BIAS;
+ }
+ }
+ else
+ {
+ /* The "strange" 80 bit format on ix86 and m68k has an explicit
+ leading digit in the 64 bit mantissa. */
+ assert (sizeof (long double) == 12);
+
+ if (sizeof (unsigned long int) > 6)
+ {
+ unsigned long int num;
+
+ num = (((unsigned long int) fpnum.dbl.ieee.mantissa0) << 32
+ | fpnum.dbl.ieee.mantissa1);
+
+ zero_mantissa = num == 0;
+
+ numstr = _itoa_word (num, numbuf + sizeof numbuf, 16,
+ info->spec == 'A');
+ }
+ else
+ {
+ unsigned long long int num;
+
+ num = (((unsigned long long int) fpnum.ldbl.ieee.mantissa0) << 32
+ | fpnum.ldbl.ieee.mantissa1);
+
+ zero_mantissa = num == 0;
+
+ numstr = _itoa (num, numbuf + sizeof numbuf, 16, info->spec == 'A');
+ }
+
+ /* We use a full nibble for the leading digit. */
+ leading = *numstr++;
+
+ /* Fill with zeroes. */
+ while (numstr > numbuf + (sizeof numbuf - 15)) /* 60 ÷ 4 = 15 */
+ *--numstr = '0';
+
+ /* We have 3 bits from the mantissa in the leading nibble. */
+ exponent = fpnum.ldbl.ieee.exponent - 3;
+
+ if (exponent != 0 && exponent < IEEE854_LONG_DOUBLE_BIAS)
+ {
+ expnegative = 1;
+ exponent = abs (exponent - IEEE854_LONG_DOUBLE_BIAS);
+ }
+ else
+ {
+ expnegative = 0;
+ if (exponent != 0)
+ exponent -= IEEE854_LONG_DOUBLE_BIAS;
+ }
+ }
+
+ /* Look for trailing zeroes. */
+ if (! zero_mantissa)
+ {
+ numend = numbuf + sizeof numbuf;
+ while (numend[-1] == '0')
+ --numend;
+
+ if (precision == -1)
+ precision = numend - numstr;
+ else if (precision < numend - numstr
+ && (numstr[precision] > 5
+ || (numstr[precision] == 5
+ && (precision + 1 < numend - numstr
+ /* Round to even. */
+ || (precision > 0
+ && ((numstr[precision - 1] & 1)
+ ^ (isdigit (numstr[precision - 1]) == 0)))
+ || (precision == 0
+ && ((leading & 1)
+ ^ (isdigit (leading) == 0)))))))
+ {
+ /* Round up. */
+ int cnt = precision;
+ while (--cnt >= 0)
+ {
+ char ch = numstr[cnt];
+ /* We assume that the digits and the letters are ordered
+ like in ASCII. This is true for the rest of GNU, too. */
+ if (ch == '9')
+ {
+ numstr[cnt] = info->spec; /* This is tricky,
+ think about it! */
+ break;
+ }
+ else if (tolower (ch) < 'f')
+ {
+ ++numstr[cnt];
+ break;
+ }
+ else
+ numstr[cnt] = '0';
+ }
+ if (cnt < 0)
+ {
+ /* The mantissa so far was fff...f Now increment the
+ leading digit. Here it is again possible that we
+ get an overflow. */
+ if (leading == '9')
+ leading = info->spec;
+ else if (tolower (leading) < 'f')
+ ++leading;
+ else
+ {
+ leading = 1;
+ if (expnegative)
+ {
+ exponent += 4;
+ if (exponent >= 0)
+ expnegative = 0;
+ }
+ else
+ exponent += 4;
+ }
+ }
+ }
+ }
+ else
+ numend = numstr;
+
+ /* Now we can compute the exponent string. */
+ expstr = _itoa_word (exponent, expbuf + sizeof expbuf, 10, 0);
+
+ /* Now we have all information to compute the size. */
+ width -= ((negative || info->showsign || info->space)
+ /* Sign. */
+ + 2 + 1 + 1 + precision + 1 + 1
+ /* 0x h . hhh P ExpoSign. */
+ + ((expbuf + sizeof expbuf) - expstr));
+ /* Exponent. */
+
+ /* A special case if when the mantissa is zero and the `#' is not
+ given. In this case we must not print the decimal point. */
+ if (zero_mantissa && precision == 0 && !info->alt)
+ ++width; /* This nihilates the +1 for the decimal-point
+ character in the following equation. */
+
+ if (!info->left && width > 0)
+ PADN (' ', width);
+
+ if (negative)
+ outchar ('-');
+ else if (info->showsign)
+ outchar ('+');
+ else if (info->space)
+ outchar (' ');
+
+ outchar ('0');
+ outchar (info->spec == 'A' ? 'X' : 'x');
+ outchar (leading);
+
+ if (!zero_mantissa || precision != 0 || info->alt)
+ outchar (decimal);
+
+ if (!zero_mantissa || precision != 0)
+ {
+ PRINT (numstr, MIN (numend - numstr, precision));
+ if (precision > numend - numstr)
+ PADN ('0', precision - (numend - numstr));
+ }
+
+ if (info->left && info->pad == '0' && width > 0)
+ PADN ('0', width);
+
+ outchar (info->spec == 'A' ? 'P' : 'p');
+
+ outchar (expnegative ? '-' : '+');
+
+ PRINT (expstr, (expbuf + sizeof expbuf) - expstr);
+
+ if (info->left && info->pad != '0' && width > 0)
+ PADN (info->pad, width);
+
+ return done;
+}
if (out != stdout)
pclose (out);
+ fputs ("Test 3:\n", out);
+ {
+ int res, val, n;
+
+ res = sscanf ("-242", "%3o%n", &val, &n);
+ printf ("res = %d, val = %d, n = %d\n", res, val, n);
+ if (res != 1 || val != -20 || n != 3)
+ return 1;
+ }
+
exit(EXIT_SUCCESS);
}
/* '4' */ 8, /* '5' */ 8, /* '6' */ 8, /* '7' */ 8,
/* '8' */ 8, /* '9' */ 8, 0, 0,
0, 0, 0, 0,
- 0, 0, 0, /* 'C' */ 25,
+ 0, /* 'A' */ 26, 0, /* 'C' */ 25,
0, /* 'E' */ 19, 0, /* 'G' */ 19,
0, 0, 0, 0,
/* 'L' */ 12, 0, 0, 0,
0, 0, 0, 0,
/* 'X' */ 18, 0, /* 'Z' */ 13, 0,
0, 0, 0, 0,
- 0, 0, 0, /* 'c' */ 20,
+ 0, /* 'a' */ 26, 0, /* 'c' */ 20,
/* 'd' */ 15, /* 'e' */ 19, /* 'f' */ 19, /* 'g' */ 19,
/* 'h' */ 10, /* 'i' */ 15, 0, 0,
/* 'l' */ 11, /* 'm' */ 24, /* 'n' */ 23, /* 'o' */ 17,
#define STEP0_3_TABLE \
/* Step 0: at the beginning. */ \
- static const void *step0_jumps[26] = \
+ static const void *step0_jumps[27] = \
{ \
REF (form_unknown), \
REF (flag_space), /* for ' ' */ \
REF (form_pointer), /* for 'p' */ \
REF (form_number), /* for 'n' */ \
REF (form_strerror), /* for 'm' */ \
- REF (form_wcharacter) /* for 'C' */ \
+ REF (form_wcharacter), /* for 'C' */ \
+ REF (form_floathex) /* for 'A', 'a' */ \
}; \
/* Step 1: after processing width. */ \
- static const void *step1_jumps[26] = \
+ static const void *step1_jumps[27] = \
{ \
REF (form_unknown), \
REF (form_unknown), /* for ' ' */ \
REF (form_pointer), /* for 'p' */ \
REF (form_number), /* for 'n' */ \
REF (form_strerror), /* for 'm' */ \
- REF (form_wcharacter) /* for 'C' */ \
+ REF (form_wcharacter), /* for 'C' */ \
+ REF (form_floathex) /* for 'A', 'a' */ \
}; \
/* Step 2: after processing precision. */ \
- static const void *step2_jumps[26] = \
+ static const void *step2_jumps[27] = \
{ \
REF (form_unknown), \
REF (form_unknown), /* for ' ' */ \
REF (form_pointer), /* for 'p' */ \
REF (form_number), /* for 'n' */ \
REF (form_strerror), /* for 'm' */ \
- REF (form_wcharacter) /* for 'C' */ \
+ REF (form_wcharacter), /* for 'C' */ \
+ REF (form_floathex) /* for 'A', 'a' */ \
}; \
/* Step 3: after processing first 'l' modifier. */ \
- static const void *step3_jumps[26] = \
+ static const void *step3_jumps[27] = \
{ \
REF (form_unknown), \
REF (form_unknown), /* for ' ' */ \
REF (form_pointer), /* for 'p' */ \
REF (form_number), /* for 'n' */ \
REF (form_strerror), /* for 'm' */ \
- REF (form_wcharacter) /* for 'C' */ \
+ REF (form_wcharacter), /* for 'C' */ \
+ REF (form_floathex) /* for 'A', 'a' */ \
}
#define STEP4_TABLE \
/* Step 4: processing format specifier. */ \
- static const void *step4_jumps[26] = \
+ static const void *step4_jumps[27] = \
{ \
REF (form_unknown), \
REF (form_unknown), /* for ' ' */ \
REF (form_pointer), /* for 'p' */ \
REF (form_number), /* for 'n' */ \
REF (form_strerror), /* for 'm' */ \
- REF (form_wcharacter) /* for 'C' */ \
+ REF (form_wcharacter), /* for 'C' */ \
+ REF (form_floathex) /* for 'A', 'a' */ \
}
} \
break; \
\
+ LABEL (form_floathex): \
+ { \
+ /* FLoating point number printed as hexadecimal number. */ \
+ extern int __printf_fphex __P ((FILE *, const struct printf_info *, \
+ const void **const)); \
+ const void *ptr; \
+ int function_done; \
+ \
+ if (fspec == NULL) \
+ { \
+ struct printf_info info = { prec: prec, \
+ width: width, \
+ spec: spec, \
+ is_long_double: is_long_double, \
+ is_short: is_short, \
+ is_long: is_long, \
+ alt: alt, \
+ space: space, \
+ left: left, \
+ showsign: showsign, \
+ group: group, \
+ pad: pad, \
+ extra: 0 }; \
+ \
+ if (is_long_double) \
+ the_arg.pa_long_double = va_arg (ap, long double); \
+ else \
+ the_arg.pa_double = va_arg (ap, double); \
+ ptr = (const void *) &the_arg; \
+ \
+ function_done = __printf_fphex (s, &info, &ptr); \
+ } \
+ else \
+ { \
+ ptr = (const void *) &args_value[fspec->data_arg]; \
+ \
+ function_done = __printf_fphex (s, &fspec->info, &ptr); \
+ } \
+ \
+ if (function_done < 0) \
+ /* Error in print handler. */ \
+ return -1; \
+ \
+ done += function_done; \
+ } \
+ break; \
+ \
LABEL (form_character): \
/* Character. */ \
if (is_long) \
done = 0;
grouping = (const char *) -1;
#ifdef __va_copy
- /* This macro will be available soon in gcc's <stdarg.h>. Me need it
+ /* This macro will be available soon in gcc's <stdarg.h>. We need it
since on some systems `va_list' is not an integral type. */
__va_copy (ap_save, ap);
#else
if (info->width != 0)
{
w = _itoa_word (info->width, workend + 1, 10, 0);
- while (++w <= workend)
- outchar (*w);
+ while (w <= workend)
+ outchar (*w++);
}
if (info->prec != -1)
{
outchar ('.');
w = _itoa_word (info->prec, workend + 1, 10, 0);
- while (++w <= workend)
- outchar (*w);
+ while (w <= workend)
+ outchar (*w++);
}
if (info->spec != '\0')
if (flags & LONGDBL)
{
if (number_signed)
- num.q = __strtoq_internal (wp, &tw, base, flags & GROUP);
+ num.q = __strtoll_internal (wp, &tw, base, flags & GROUP);
else
- num.uq = __strtouq_internal (wp, &tw, base, flags & GROUP);
+ num.uq = __strtoull_internal (wp, &tw, base, flags & GROUP);
}
else
{
-/* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 93, 94, 95, 96, 97 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#endif
-#if defined(__USE_SVID) || defined(__USE_XOPEN)
+#if defined __USE_SVID || defined __USE_XOPEN
/* Generate a unique temporary filename using up to five characters of PFX
if it is not NULL. The directory to put this file in is searched for
as follows: First the environment variable "TMPDIR" is checked.
/* Open a file and create a new stream for it. */
extern FILE *fopen __P ((__const char *__filename, __const char *__modes));
/* Open a file, replacing an existing stream with it. */
-extern FILE *freopen __P ((__const char *__filename,
- __const char *__modes, FILE *__stream));
+extern FILE *freopen __P ((__const char *__restrict __filename,
+ __const char *__rstrict __modes,
+ FILE *__restrict __stream));
/* Return a new, zeroed, stream.
You must set its cookie and io_mode.
/* If BUF is NULL, make STREAM unbuffered.
Else make it use buffer BUF, of size BUFSIZ. */
-extern void setbuf __P ((FILE *__stream, char *__buf));
+extern void setbuf __P ((FILE *__restrict __stream, char *__restrict __buf));
/* Make STREAM use buffering mode MODE.
If BUF is not NULL, use N bytes of it for buffering;
else allocate an internal buffer N bytes long. */
-extern int setvbuf __P ((FILE *__stream, char *__buf,
+extern int setvbuf __P ((FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n));
#ifdef __USE_BSD
/* Write formatted output to STREAM. */
-extern int fprintf __P ((FILE *__stream, __const char *__format, ...));
+extern int fprintf __P ((FILE *__restrict __stream,
+ __const char *__restrict __format, ...));
/* Write formatted output to stdout. */
-extern int printf __P ((__const char *__format, ...));
+extern int printf __P ((__const char *__restrict __format, ...));
/* Write formatted output to S. */
-extern int sprintf __P ((char *__s, __const char *__format, ...));
+extern int sprintf __P ((char *__restrict __s,
+ __const char *__restrict __format, ...));
/* Write formatted output to S from argument list ARG. */
-extern int vfprintf __P ((FILE *__s, __const char *__format,
+extern int vfprintf __P ((FILE *__restrict __s,
+ __const char *__restrict __format,
__gnuc_va_list __arg));
/* Write formatted output to stdout from argument list ARG. */
-extern int vprintf __P ((__const char *__format, __gnuc_va_list __arg));
+extern int vprintf __P ((__const char *__restrict __format,
+ __gnuc_va_list __arg));
/* Write formatted output to S from argument list ARG. */
-extern int vsprintf __P ((char *__s, __const char *__format,
+extern int vsprintf __P ((char *__restrict __s,
+ __const char *__restrict __format,
__gnuc_va_list __arg));
#ifdef __OPTIMIZE__
extern __inline int
-vprintf (const char *__fmt, __gnuc_va_list __arg)
+vprintf (const char *__restrict __fmt, __gnuc_va_list __arg)
{
return vfprintf (stdout, __fmt, __arg);
}
/* Read formatted input from STREAM. */
-extern int fscanf __P ((FILE *__stream, __const char *__format, ...));
+extern int fscanf __P ((FILE *__restrict __stream,
+ __const char *__restrict __format, ...));
/* Read formatted input from stdin. */
-extern int scanf __P ((__const char *__format, ...));
+extern int scanf __P ((__const char *__restrict __format, ...));
/* Read formatted input from S. */
-extern int sscanf __P ((__const char *__s, __const char *__format, ...));
+extern int sscanf __P ((__const char *__restrict __s,
+ __const char *__restrict __format, ...));
#ifdef __USE_GNU
/* Read formatted input from S into argument list ARG. */
/* Get a newline-terminated string of finite length from STREAM. */
-extern char *fgets __P ((char *__s, int __n, FILE *__stream));
+extern char *fgets __P ((char *__restrict __s, int __n,
+ FILE *__restrict __stream));
/* Get a newline-terminated string from stdin, removing the newline.
DO NOT USE THIS FUNCTION!! There is no limit on how much it will read. */
#ifdef __OPTIMIZE__
extern __inline ssize_t
-__getline (char **__lineptr, size_t *__n, FILE *__stream)
-{
- return __getdelim (__lineptr, __n, '\n', __stream);
-}
-
-extern __inline ssize_t
-getdelim (char **__lineptr, size_t *__n, int __delimiter, FILE *__stream)
-{
- return __getdelim (__lineptr, __n, __delimiter, __stream);
-}
-extern __inline ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
- return __getline (__lineptr, __n, __stream);
+ return __getdelim (__lineptr, __n, '\n', __stream);
}
#endif /* Optimizing. */
#endif
/* Write a string to STREAM. */
-extern int fputs __P ((__const char *__s, FILE *__stream));
+extern int fputs __P ((__const char *__restrict __s,
+ FILE *__restrict __stream));
/* Write a string, followed by a newline, to stdout. */
extern int puts __P ((__const char *__s));
/* Read chunks of generic data from STREAM. */
-extern size_t fread __P ((__ptr_t __ptr, size_t __size,
- size_t __n, FILE *__stream));
+extern size_t fread __P ((__ptr_t __restrict __ptr, size_t __size,
+ size_t __n, FILE *__restrict __stream));
/* Write chunks of generic data to STREAM. */
-extern size_t fwrite __P ((__const __ptr_t __ptr, size_t __size,
- size_t __n, FILE *__s));
+extern size_t fwrite __P ((__const __ptr_t __restrict __ptr, size_t __size,
+ size_t __n, FILE *__restrict __s));
/* Seek to a certain position on STREAM. */
extern void rewind __P ((FILE *__stream));
/* Get STREAM's position. */
-extern int fgetpos __P ((FILE *__stream, fpos_t *__pos));
+extern int fgetpos __P ((FILE *__restrict __stream, fpos_t *__restrict __pos));
/* Set STREAM's position. */
extern int fsetpos __P ((FILE *__stream, __const fpos_t *__pos));
drand48_r erand48_r lrand48_r nrand48_r mrand48_r jrand48_r \
srand48_r seed48_r lcong48_r \
drand48-iter \
- strtol strtoul strtoq strtouq \
+ strtol strtoul strtoll strtoull \
strtof strtod strtold \
system canonicalize \
a64l l64a \
/* Convert a string to a long integer. */
extern long int atol __P ((__const char *__nptr));
-#if defined (__GNUC__) && defined (__USE_MISC)
+#if defined __USE_ISOC9X || (defined __GNUC__ && defined __USE_MISC)
/* These functions will part of the standard C library in ISO C 9X. */
extern long long int atoll __P ((__const char *__nptr));
#endif
/* Convert a string to a floating-point number. */
-extern double strtod __P ((__const char *__nptr, char **__endptr));
+extern double strtod __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr));
#ifdef __USE_GNU
/* Likewise for `float' and `long double' sizes of floating-point numbers. */
-extern float strtof __P ((__const char *__nptr, char **__endptr));
-extern __long_double_t strtold __P ((__const char *__nptr, char **__endptr));
+extern float strtof __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr));
+
+extern __long_double_t strtold __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr));
#endif
/* Convert a string to a long integer. */
-extern long int strtol __P ((__const char *__nptr, char **__endptr,
- int __base));
+extern long int strtol __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr, int __base));
/* Convert a string to an unsigned long integer. */
-extern unsigned long int strtoul __P ((__const char *__nptr,
- char **__endptr, int __base));
+extern unsigned long int strtoul __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr,
+ int __base));
-#if defined (__GNUC__) && defined (__USE_BSD)
+#if defined __GNUC__ && defined __USE_BSD
/* Convert a string to a quadword integer. */
-extern long long int strtoq __P ((__const char *__nptr, char **__endptr,
- int __base));
+extern long long int strtoq __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr, int __base));
/* Convert a string to an unsigned quadword integer. */
-extern unsigned long long int strtouq __P ((__const char *__nptr,
- char **__endptr, int __base));
+extern unsigned long long int strtouq __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr,
+ int __base));
#endif /* GCC and use BSD. */
-#if defined (__GNUC__) && defined (__USE_MISC)
+#if defined __USE_ISOC9X || (defined __GNUC__ && defined __USE_MISC)
/* These functions will part of the standard C library in ISO C 9X. */
/* Convert a string to a quadword integer. */
-extern long long int strtoll __P ((__const char *__nptr, char **__endptr,
- int __base));
+extern long long int strtoll __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr, int __base));
/* Convert a string to an unsigned quadword integer. */
-extern unsigned long long int strtoull __P ((__const char *__nptr,
- char **__endptr, int __base));
-#endif /* GCC and use MISC. */
+extern unsigned long long int strtoull __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr,
+ int __base));
+#endif /* ISO C 9X or GCC and use MISC. */
/* The internal entry points for `strtoX' take an extra flag argument
saying whether or not to parse locale-dependent number grouping. */
-extern double __strtod_internal __P ((__const char *__nptr,
- char **__endptr, int __group));
-extern float __strtof_internal __P ((__const char *__nptr, char **__endptr,
- int __group));
-extern __long_double_t __strtold_internal __P ((__const char *__nptr,
- char **__endptr, int __group));
-extern long int __strtol_internal __P ((__const char *__nptr, char **__endptr,
+extern double __strtod_internal __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr,
+ int __group));
+extern float __strtof_internal __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr, int __group));
+extern __long_double_t __strtold_internal __P ((__const char *
+ __restrict __nptr,
+ char **__restrict __endptr,
+ int __group));
+extern long int __strtol_internal __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr,
int __base, int __group));
-extern unsigned long int __strtoul_internal __P ((__const char *__nptr,
- char **__endptr, int __base,
- int __group));
+extern unsigned long int __strtoul_internal __P ((__const char *
+ __restrict __nptr,
+ char **__restrict __endptr,
+ int __base, int __group));
#ifdef __GNUC__
-extern long long int __strtoq_internal __P ((__const char *__nptr,
- char **__endptr, int __base,
- int __group));
-extern unsigned long long int __strtouq_internal __P ((__const char *__nptr,
- char **__endptr,
- int __base,
- int __group));
+extern long long int __strtoll_internal __P ((__const char *__restrict __nptr,
+ char **__restrict __endptr,
+ int __base, int __group));
+extern unsigned long long int __strtoull_internal __P ((__const char *
+ __restrict __nptr,
+ char **
+ __restrict __endptr,
+ int __base,
+ int __group));
#endif /* GCC */
#if defined (__OPTIMIZE__) && __GNUC__ >= 2
/* Define inline functions which call the internal entry points. */
-extern __inline double strtod (__const char *__nptr, char **__endptr)
+extern __inline double strtod (__const char *__restrict __nptr,
+ char **__restrict __endptr)
{ return __strtod_internal (__nptr, __endptr, 0); }
-extern __inline long int strtol (__const char *__nptr,
- char **__endptr, int __base)
+extern __inline long int strtol (__const char *__restrict __nptr,
+ char **__restrict __endptr, int __base)
{ return __strtol_internal (__nptr, __endptr, __base, 0); }
-extern __inline unsigned long int strtoul (__const char *__nptr,
- char **__endptr, int __base)
+extern __inline unsigned long int strtoul (__const char *__restrict __nptr,
+ char **__restrict __endptr,
+ int __base)
{ return __strtoul_internal (__nptr, __endptr, __base, 0); }
#ifdef __USE_GNU
-extern __inline float strtof (__const char *__nptr, char **__endptr)
+extern __inline float strtof (__const char *__restrict __nptr,
+ char **__restrict __endptr)
{ return __strtof_internal (__nptr, __endptr, 0); }
-extern __inline __long_double_t strtold (__const char *__nptr, char **__endptr)
+extern __inline __long_double_t strtold (__const char *__restrict __nptr,
+ char **__restrict __endptr)
{ return __strtold_internal (__nptr, __endptr, 0); }
#endif
#ifdef __USE_BSD
-extern __inline long long int strtoq (__const char *__nptr, char **__endptr,
- int __base)
-{ return __strtoq_internal (__nptr, __endptr, __base, 0); }
-extern __inline unsigned long long int strtouq (__const char *__nptr,
- char **__endptr, int __base)
-{ return __strtouq_internal (__nptr, __endptr, __base, 0); }
+extern __inline long long int strtoq (__const char *__restrict __nptr,
+ char **__restrict __endptr, int __base)
+{ return __strtoll_internal (__nptr, __endptr, __base, 0); }
+extern __inline unsigned long long int strtouq (__const char *__restrict __nptr,
+ char **__restrict __endptr,
+ int __base)
+{ return __strtoull_internal (__nptr, __endptr, __base, 0); }
#endif
-#ifdef __USE_MISC
-extern __inline long long int strtoll (__const char *__nptr, char **__endptr,
- int __base)
-{ return __strtoq_internal (__nptr, __endptr, __base, 0); }
-extern __inline unsigned long long int strtoull (__const char *__nptr,
- char **__endptr, int __base)
-{ return __strtouq_internal (__nptr, __endptr, __base, 0); }
+#if defined __USE_MISC || defined __USE_ISOC9X
+extern __inline long long int strtoll (__const char *__restrict __nptr,
+ char **__restrict __endptr, int __base)
+{ return __strtoll_internal (__nptr, __endptr, __base, 0); }
+extern __inline unsigned long long int strtoull (__const char *
+ __restrict __nptr,
+ char **__restrict __endptr,
+ int __base)
+{ return __strtoull_internal (__nptr, __endptr, __base, 0); }
#endif
extern __inline double atof (__const char *__nptr)
/* Return the absolute value of X. */
extern int abs __P ((int __x)) __attribute__ ((__const__));
extern long int labs __P ((long int __x)) __attribute__ ((__const__));
-#ifdef __USE_GNU
-extern long long int llabs __P ((long long int __x)) __attribute__ ((__const__));
+#if defined __USE_ISOC9X
+extern long long int llabs __P ((long long int __x))
+ __attribute__ ((__const__));
#endif
of the value of NUMER over DENOM. */
/* GCC may have built-ins for these someday. */
extern div_t div __P ((int __numer, int __denom)) __attribute__ ((__const__));
-extern ldiv_t ldiv __P ((long int __numer, long int __denom)) __attribute__ ((__const__));
-#ifdef __USE_GNU
-extern lldiv_t lldiv __P ((long long int __numer, long long int __denom)) __attribute__ ((__const__));
+extern ldiv_t ldiv __P ((long int __numer, long int __denom))
+ __attribute__ ((__const__));
+#ifdef __USE_ISOC9X
+extern lldiv_t lldiv __P ((long long int __numer, long long int __denom))
+ __attribute__ ((__const__));
#endif
extern int mblen __P ((__const char *__s, size_t __n));
/* Return the length of the given multibyte character,
putting its `wchar_t' representation in *PWC. */
-extern int mbtowc __P ((wchar_t *__pwc, __const char *__s, size_t __n));
+extern int mbtowc __P ((wchar_t *__restrict __pwc,
+ __const char *__restrict __s, size_t __n));
/* Put the multibyte character represented
by WCHAR in S, returning its length. */
extern int wctomb __P ((char *__s, wchar_t __wchar));
/* Convert a multibyte string to a wide char string. */
-extern size_t mbstowcs __P ((wchar_t *__pwcs, __const char *__s, size_t __n));
+extern size_t mbstowcs __P ((wchar_t *__restrict __pwcs,
+ __const char *__restrict __s, size_t __n));
/* Convert a wide char string to multibyte string. */
-extern size_t wcstombs __P ((char *__s, __const wchar_t *__pwcs, size_t __n));
+extern size_t wcstombs __P ((char *__restrict __s,
+ __const wchar_t *__restrict __pwcs, size_t __n));
#ifdef __USE_SVID
# define L_(Ch) L##Ch
# define ISSPACE(Ch) iswspace (Ch)
# define TOLOWER(Ch) towlower (Ch)
+# define STRNCASECMP(S1, S2, N) __wcsncasecmp ((S1), (S2), (N))
#else
# define STRING_TYPE char
# define CHAR_TYPE char
# define L_(Ch) Ch
# define ISSPACE(Ch) isspace (Ch)
# define TOLOWER(Ch) tolower (Ch)
+# define STRNCASECMP(S1, S2, N) __strncasecmp ((S1), (S2), (N))
#endif
/* End of configuration part. */
\f
#include <ctype.h>
#include <errno.h>
#include <float.h>
+#include <ieee754.h>
#include "../locale/localeinfo.h"
#include <math.h>
#include <stdlib.h>
No character is used even if a sign was found. */
if ((c < L_('0') || c > L_('9'))
&& ((wint_t) c != decimal || cp[1] < L_('0') || cp[1] > L_('9')))
- RETURN (0.0, nptr);
+ {
+ int matched = 0;
+ /* Check for `INF' or `INFINITY'. */
+ if (TOLOWER (c) == L_('i') && ((STRNCASECMP (cp, L_("nf"), 2) == 0
+ && (matched = 2))
+ || (STRNCASECMP (cp, L_("nfinity"), 7)
+ == 0
+ && (matched = 7))))
+ {
+ /* Return +/- inifity. */
+ if (endptr != NULL)
+ *endptr = (STRING_TYPE *) (cp + matched);
+
+ return negative ? -FLOAT_HUGE_VAL : FLOAT_HUGE_VAL;
+ }
+
+ if (TOLOWER (c) == L_('n') && STRNCASECMP (cp, L_("an"), 2) == 0)
+ {
+ /* Return NaN. */
+ if (endptr != NULL)
+ {
+ cp += 2;
+
+ /* Match `(n-char-sequence-digit)'. */
+ if (*cp == L_('('))
+ {
+ const STRING_TYPE *startp = cp;
+ do
+ ++cp;
+ while ((*cp >= '0' && *cp <= '9')
+ || (TOLOWER (*cp) >= 'a' && TOLOWER (*cp) <= 'z')
+ || *cp == L_('_'));
+
+ if (*cp != L_(')'))
+ /* The closing brace is missing. Only match the NAN
+ part. */
+ cp = startp;
+ }
+
+ *endptr = (STRING_TYPE *) cp;
+ }
+
+ return NAN;
+ }
+
+ /* It is really a text we do not recognize. */
+ RETURN (0.0, nptr);
+ }
/* Record the start of the digits, in case we will check their grouping. */
start_of_digits = startp = cp;
#define FLT FLT
#define STRTOF strtof
#define MPN2FLOAT __mpn_construct_float
-#define FLOAT_HUGE_VAL HUGE_VALf
+#define FLOAT_HUGE_VAL HUGE_VALF
#include "strtod.c"
-/* strtol - Convert string representation of a number into an integer value.
+/* Convert string representation of a number into an integer value.
Copyright (C) 1991, 92, 94, 95, 96, 97 Free Software Foundation, Inc.
This file is part of the GNU C Library.
# include "../locale/localeinfo.h"
#endif
-/* Nonzero if we are defining `strtoul' or `strtouq', operating on
+/* Nonzero if we are defining `strtoul' or `strtoull', operating on
unsigned integers. */
#ifndef UNSIGNED
# define UNSIGNED 0
#if UNSIGNED
# ifdef USE_WIDE_CHAR
# ifdef QUAD
-# define strtol wcstouq
+# define strtol wcstoull
# else
# define strtol wcstoul
# endif
# else
# ifdef QUAD
-# define strtol strtouq
+# define strtol strtoull
# else
# define strtol strtoul
# endif
#else
# ifdef USE_WIDE_CHAR
# ifdef QUAD
-# define strtol wcstoq
+# define strtol wcstoll
# else
# define strtol wcstol
# endif
# else
# ifdef QUAD
-# define strtol strtoq
+# define strtol strtoll
# endif
# endif
#endif
-/* If QUAD is defined, we are defining `strtoq' or `strtouq',
+/* If QUAD is defined, we are defining `strtoll' or `strtoull',
operating on `long long int's. */
#ifdef QUAD
# define LONG long long
? -((unsigned LONG int) (LONG_MIN + 1)) + 1
: (unsigned LONG int) LONG_MAX))
overflow = 1;
-#else
- overflow |= negative;
#endif
if (overflow)
#define FLT LDBL
#define STRTOF strtold
#define MPN2FLOAT __mpn_construct_long_double
-#define FLOAT_HUGE_VAL HUGE_VALl
+#define FLOAT_HUGE_VAL HUGE_VALL
#include "strtod.c"
#include <strtol.c>
-weak_alias (strtoq, strtoll)
+weak_alias (strtoll, strtoq)
#include <strtoul.c>
-weak_alias (strtouq, strtoull)
+weak_alias (strtoull, strtouq)
{ "0xffffffffg", 0xffffffff, 0, 'g', 0 },
{ "0xf1f2f3f4f5", 0xffffffff, 0, 0, ERANGE },
{ "-0x123456789", 0xffffffff, 0, 0, ERANGE },
- { "-0xfedcba98", 0xffffffff, 0, 0, ERANGE },
+ { "-0xfedcba98", 0x01234568, 0, 0, 0 },
{ NULL, 0, 0, 0, 0 },
#else
/* assume 64 bit long... */
{ "0xffffffffffffffffg", 0xffffffffffffffff, 0, 'g', 0 },
{ "0xf1f2f3f4f5f6f7f8f9", 0xffffffffffffffff, 0, 0, ERANGE },
{ "-0x123456789abcdef01", 0xffffffffffffffff, 0, 0, ERANGE },
- { "-0xfedcba987654321", 0xffffffffffffffff, 0, 0, ERANGE },
+ { "-0xfedcba987654321", 0x0123456789abcdf, 0, 0, 0 },
{ NULL, 0, 0, 0, 0 },
#endif
};
/* Copy N bytes of SRC to DEST. */
-extern __ptr_t memcpy __P ((__ptr_t __dest, __const __ptr_t __src,
- size_t __n));
+extern __ptr_t memcpy __P ((__ptr_t __restrict __dest,
+ __const __ptr_t __restrict __src, size_t __n));
/* Copy N bytes of SRC to DEST, guaranteeing
correct behavior for overlapping strings. */
extern __ptr_t memmove __P ((__ptr_t __dest, __const __ptr_t __src,
/* Copy SRC to DEST. */
-extern char *strcpy __P ((char *__dest, __const char *__src));
+extern char *strcpy __P ((char *__restrict __dest,
+ __const char *__restrict __src));
/* Copy no more than N characters of SRC to DEST. */
-extern char *strncpy __P ((char *__dest, __const char *__src, size_t __n));
+extern char *strncpy __P ((char *__restrict __dest,
+ __const char *__restrict __src, size_t __n));
/* Append SRC onto DEST. */
-extern char *strcat __P ((char *__dest, __const char *__src));
+extern char *strcat __P ((char *__restrict __dest,
+ __const char *__restrict __src));
/* Append no more than N characters from SRC onto DEST. */
-extern char *strncat __P ((char *__dest, __const char *__src, size_t __n));
+extern char *strncat __P ((char *__restrict __dest,
+ __const char *__restrict __src, size_t __n));
/* Compare S1 and S2. */
extern int strcmp __P ((__const char *__s1, __const char *__s2));
/* Compare the collated forms of S1 and S2. */
extern int strcoll __P ((__const char *__s1, __const char *__s2));
/* Put a transformation of SRC into no more than N bytes of DEST. */
-extern size_t strxfrm __P ((char *__dest, __const char *__src, size_t __n));
+extern size_t strxfrm __P ((char *__restrict __dest,
+ __const char *__restrict __src, size_t __n));
#ifdef __USE_GNU
/* The following functions are equivalent to the both above but they
/* Find the first occurrence of NEEDLE in HAYSTACK. */
extern char *strstr __P ((__const char *__haystack, __const char *__needle));
/* Divide S into tokens separated by characters in DELIM. */
-extern char *strtok __P ((char *__s, __const char *__delim));
+extern char *strtok __P ((char *__restrict __s,
+ __const char *__restrict __delim));
#if defined __USE_POSIX || defined __USE_MISC
/* Divide S into tokens separated by characters in DELIM. Information
-/* `HUGE_VAL' constant for IEEE 754 machines (where it is infinity).
+/* `HUGE_VAL' constants for IEEE 754 machines (where it is infinity).
Used by <stdlib.h> and <math.h> functions for overflow.
- Copyright (C) 1992, 1995, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1995, 1996, 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
#endif /* GCC. */
-/* GNU extensions: (float) HUGE_VALf and (long double) HUGE_VALl. */
+/* ISO C 9X extensions: (float) HUGE_VALF and (long double) HUGE_VALL. */
-#ifdef __USE_GNU
+#ifdef __USE_ISOC9X
#if __BYTE_ORDER == __BIG_ENDIAN
-#define __HUGE_VALf_bytes { 0x7f, 0x80, 0, 0 }
+#define __HUGE_VALF_bytes { 0x7f, 0x80, 0, 0 }
#endif
#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define __HUGE_VALf_bytes { 0, 0, 0x80, 0x7f }
+#define __HUGE_VALF_bytes { 0, 0, 0x80, 0x7f }
#endif
#define __huge_valf_t union { unsigned char __c[4]; float __f; }
#ifdef __GNUC__
-#define HUGE_VALf (__extension__ \
- ((__huge_valf_t) { __c: __HUGE_VALf_bytes }).__f)
+#define HUGE_VALF (__extension__ \
+ ((__huge_valf_t) { __c: __HUGE_VALF_bytes }).__f)
#else /* Not GCC. */
-static __huge_valf_t __huge_valf = { __HUGE_VALf_bytes };
-#define HUGE_VALf (__huge_valf.__f)
+static __huge_valf_t __huge_valf = { __HUGE_VALF_bytes };
+#define HUGE_VALF (__huge_valf.__f)
#endif /* GCC. */
+
#if __BYTE_ORDER == __BIG_ENDIAN
-#define __HUGE_VALl_bytes { 0x7f, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+#define __HUGE_VALL_bytes { 0x7f, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
#endif
#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define __HUGE_VALl_bytes { 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0x7f, 0, 0 }
+#define __HUGE_VALL_bytes { 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0x7f, 0, 0 }
#endif
#define __huge_vall_t union { unsigned char __c[12]; long double __ld; }
#ifdef __GNUC__
-#define HUGE_VALl (__extension__ \
- ((__huge_vall_t) { __c: __HUGE_VALl_bytes }).__ld)
+#define HUGE_VALL (__extension__ \
+ ((__huge_vall_t) { __c: __HUGE_VALL_bytes }).__ld)
#else /* Not GCC. */
-static __huge_vall_t __huge_vall = { __HUGE_VALl_bytes };
-#define HUGE_VALl (__huge_vall.__ld)
+static __huge_vall_t __huge_vall = { __HUGE_VALL_bytes };
+#define HUGE_VALL (__huge_vall.__ld)
#endif /* GCC. */
-#endif /* __USE_GNU. */
+
+/* Expression representing positive infinity. Here it is the same as
+ HUGE_VALF. */
+#define INFINITY HUGE_VALF
+
+#endif /* __USE_ISOC9X. */
#endif /* huge_val.h */
{
u_int64_t xxl = ((u_int64_t) se) << 32 | x0;
xxl /= 3;
- xxl += B1_EXP << 16 | B1_MANT;
+ xxl += ((u_int64_t) B1_EXP) << 32 | B1_MANT;
SET_LDOUBLE_MSW(t,xxl&0xffffffffu);
xxl >>= 32;
SET_LDOUBLE_EXP(t,xxl);
char *
gai_strerror (int code)
{
- int i;
+ size_t i;
for (i = 0; i < sizeof (values) / sizeof (values[0]); ++i)
if (values[i].code == code)
return (char *) values[i].msg;
chown - chown 3 __chown chown
chroot - chroot 1 chroot
close - close 1 __libc_close __close close
-dup - dup 2 __dup dup
+dup - dup 1 __dup dup
dup2 - dup2 2 __dup2 dup2
fchdir - fchdir 1 fchdir
fcntl - fcntl 3 __libc_fcntl __fcntl fcntl
#define socket accept
+#define NARGS 3
#include <socket.S>
#define socket bind
+#define NARGS 3
#include <socket.S>
#define socket connect
+#define NARGS 3
#include <socket.S>
#define socket getpeername
+#define NARGS 3
#include <socket.S>
#define socket getsockname
+#define NARGS 3
#include <socket.S>
#define socket getsockopt
+#define NARGS 5
#include <socket.S>
-/* Copyright (C) 1995, 1996 Free Software Foundation, Inc.
-This file is part of the GNU C Library.
-
-The GNU C Library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Library General Public License as
-published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version.
-
-The GNU C Library 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
-Library General Public License for more details.
-
-You should have received a copy of the GNU Library General Public
-License along with the GNU C Library; see the file COPYING.LIB. If
-not, write to the Free Software Foundation, Inc., 675 Mass Ave,
-Cambridge, MA 02139, USA. */
+/* Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
#include <sysdep.h>
#include <sys/socketcall.h>
#define socket listen
+#define NARGS 2
#include <socket.S>
#define socket recv
+#define NARGS 4
#include <socket.S>
#define socket recvfrom
+#define NARGS 6
#include <socket.S>
#define socket recvmsg
+#define NARGS 3
#include <socket.S>
#define socket send
+#define NARGS 4
#include <socket.S>
#define socket sendmsg
+#define NARGS 3
#include <socket.S>
#define socket sendto
+#define NARGS 6
#include <socket.S>
#define socket setsockopt
+#define NARGS 5
#include <socket.S>
#define socket shutdown
+#define NARGS 2
#include <socket.S>
#define socket socketpair
+#define NARGS 4
#include <socket.S>
/* System-dependent timing definitions. Linux version.
- Copyright (C) 1996 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
XSI-conformant systems. */
# define CLOCKS_PER_SEC 1000000
+# ifndef __STRICT_ANSI__
/* Even though CLOCKS_PER_SEC has such a strange value CLK_TCK
presents the real value for clock ticks per second for the system. */
-# define CLK_TCK 100
+# define CLK_TCK 100
+# endif
#endif /* timebits.h */
/* Format TP into S according to FORMAT.
Write no more than MAXSIZE characters and return the number
of characters written, or 0 if it would exceed MAXSIZE. */
-extern size_t strftime __P ((char *__s, size_t __maxsize,
- __const char *__format, __const struct tm *__tp));
+extern size_t strftime __P ((char *__restrict __s, size_t __maxsize,
+ __const char *__restrict __format,
+ __const struct tm *__restrict __tp));
#ifdef __USE_XOPEN
/* Parse S according to FORMAT and store binary time information in TP.
btowc wctob mbsinit \
mbrlen mbrtowc wcrtomb mbsrtowcs wcsrtombs \
mbsnrtowcs wcsnrtombs \
- wcstol wcstoul wcstoq wcstouq wcstod wcstold wcstof \
+ wcstol wcstoul wcstoll wcstoull wcstod wcstold wcstof \
wcscoll wcsxfrm \
wcwidth wcswidth \
- wcscoll_l wcsxfrm_l
+ wcscoll_l wcsxfrm_l \
+ wcscasecmp wcsncase
include ../Rules
CFLAGS-wcstol.c = -I../stdlib
CFLAGS-wcstoul.c = -I../stdlib
-CFLAGS-wcstoq.c = -I../stdlib
-CFLAGS-wcstouq.c = -I../stdlib
+CFLAGS-wcstoll.c = -I../stdlib
+CFLAGS-wcstoull.c = -I../stdlib
CFLAGS-wcstod.c = -I../stdlib
CFLAGS-wcstold.c = -I../stdlib
CFLAGS-wcstof.c = -I../stdlib
/* Copy SRC to DEST. */
-extern wchar_t *wcscpy __P ((wchar_t *__dest, __const wchar_t *__src));
+extern wchar_t *wcscpy __P ((wchar_t *__restrict __dest,
+ __const wchar_t *__restrict __src));
/* Copy no more than N wide-characters of SRC to DEST. */
-extern wchar_t *wcsncpy __P ((wchar_t *__dest, __const wchar_t *__src,
- size_t __n));
+extern wchar_t *wcsncpy __P ((wchar_t *__restrict __dest,
+ __const wchar_t *__restrict __src, size_t __n));
/* Append SRC onto DEST. */
-extern wchar_t *wcscat __P ((wchar_t *__dest, __const wchar_t *__src));
+extern wchar_t *wcscat __P ((wchar_t *__restrict __dest,
+ __const wchar_t *__restrict __src));
/* Append no more than N wide-characters of SRC onto DEST. */
-extern wchar_t *wcsncat __P ((wchar_t *__dest, __const wchar_t *__src,
- size_t __n));
+extern wchar_t *wcsncat __P ((wchar_t *__restrict __dest,
+ __const wchar_t *__restrict __src, size_t __n));
/* Compare S1 and S2. */
extern int wcscmp __P ((__const wchar_t *__s1, __const wchar_t *__s2));
extern int wcsncmp __P ((__const wchar_t *__s1, __const wchar_t *__s2,
size_t __n));
+#ifdef __USE_GNU
+/* Compare S1 and S2, ignoring case. */
+extern int __wcscasecmp __P ((__const wchar_t *__s1, __const wchar_t *__s2));
+extern int wcscasecmp __P ((__const wchar_t *__s1, __const wchar_t *__s2));
+
+/* Compare no more than N chars of S1 and S2, ignoring case. */
+extern int __wcsncasecmp __P ((__const wchar_t *__s1, __const wchar_t *__s2,
+ size_t __n));
+extern int wcsncasecmp __P ((__const wchar_t *__s1, __const wchar_t *__s2,
+ size_t __n));
+#endif
+
/* Compare S1 and S2, both interpreted as appropriate to the
LC_COLLATE category of the current locale. */
extern int wcscoll __P ((__const wchar_t *__s1, __const wchar_t *__s2));
/* Transform S2 into array pointed to by S1 such that if wcscmp is
applied to two transformed strings the result is the as applying
`wcscoll' to the original strings. */
-extern size_t wcsxfrm __P ((wchar_t *__s1, __const wchar_t *__s2, size_t __n));
+extern size_t wcsxfrm __P ((wchar_t *__restrict __s1,
+ __const wchar_t *__restrict __s2, size_t __n));
#ifdef __USE_GNU
/* Similar to the two functions above but take the information from
/* Compare S1 and S2, both interpreted as appropriate to the
LC_COLLATE category of the given locale. */
extern int __wcscoll_l __P ((__const wchar_t *__s1, __const wchar_t *__s2,
- __locale_t loc));
+ __locale_t __loc));
/* Transform S2 into array pointed to by S1 such that if wcscmp is
applied to two transformed strings the result is the as applying
`wcscoll' to the original strings. */
extern size_t __wcsxfrm_l __P ((wchar_t *__s1, __const wchar_t *__s2,
- size_t __n, __locale_t loc));
+ size_t __n, __locale_t __loc));
#endif
/* Duplicate S, returning an identical malloc'd string. */
extern wchar_t *wcsstr __P ((__const wchar_t *__haystack,
__const wchar_t *__needle));
/* Divide WCS into tokens separated by characters in DELIM. */
-extern wchar_t *wcstok __P ((wchar_t *__s, __const wchar_t *__delim,
- wchar_t **ptr));
+extern wchar_t *wcstok __P ((wchar_t *__restrict __s,
+ __const wchar_t *__restrict __delim,
+ wchar_t **__restrict __ptr));
/* Return the number of wide-characters in S. */
extern size_t wcslen __P ((__const wchar_t *__s));
extern wchar_t *wmemchr __P ((__const wchar_t *__s, wchar_t __c, size_t __n));
/* Compare N bytes of S1 and S2. */
-extern int wmemcmp __P ((__const wchar_t *__s1, __const wchar_t *__s2,
- size_t __n));
+extern int wmemcmp __P ((__const wchar_t *__restrict __s1,
+ __const wchar_t *__restrict __s2, size_t __n));
/* Copy N bytes of SRC to DEST. */
-extern wchar_t *wmemcpy __P ((wchar_t *__s1, __const wchar_t *__s2,
- size_t __n));
+extern wchar_t *wmemcpy __P ((wchar_t *__restrict __s1,
+ __const wchar_t *__restrict __s2, size_t __n));
/* Copy N bytes of SRC to DEST, guaranteeing
correct behavior for overlapping strings. */
/* Write wide character representation of multibyte character pointed
to by S to PWC. */
-extern size_t __mbrtowc __P ((wchar_t *__pwc, __const char *__s, size_t __n,
- mbstate_t *__p));
-extern size_t mbrtowc __P ((wchar_t *__pwc, __const char *__s, size_t __n,
+extern size_t __mbrtowc __P ((wchar_t *__restrict __pwc,
+ __const char *__restrict __s, size_t __n,
+ mbstate_t *__restrict __p));
+extern size_t mbrtowc __P ((wchar_t *__restrict __pwc,
+ __const char *__restrict __s, size_t __n,
mbstate_t *__p));
/* Write multibyte representation of wide character WC to S. */
-extern size_t __wcrtomb __P ((char *__s, wchar_t __wc, mbstate_t *__ps));
-extern size_t wcrtomb __P ((char *__s, wchar_t __wc, mbstate_t *__ps));
+extern size_t __wcrtomb __P ((char *__restrict __s, wchar_t __wc,
+ mbstate_t *__restrict __ps));
+extern size_t wcrtomb __P ((char *__restrict __s, wchar_t __wc,
+ mbstate_t *__restrict __ps));
/* Return number of bytes in multibyte character pointed to by S. */
-extern size_t __mbrlen __P ((__const char *__s, size_t __n, mbstate_t *__ps));
-extern size_t mbrlen __P ((__const char *__s, size_t __n, mbstate_t *__ps));
+extern size_t __mbrlen __P ((__const char *__restrict __s, size_t __n,
+ mbstate_t *__restrict __ps));
+extern size_t mbrlen __P ((__const char *__restrict __s, size_t __n,
+ mbstate_t *__restrict __ps));
#if defined (__OPTIMIZE__) \
&& (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7))
/* Define inline function as optimization. */
-extern __inline size_t mbrlen (__const char *s, size_t n, mbstate_t *ps)
-{ return ps != NULL ? __mbrtowc (NULL, s, n, ps) : __mbrlen (s, n, NULL); }
+extern __inline size_t mbrlen (__const char *__restrict __s, size_t __n,
+ mbstate_t *__restrict __ps)
+{ return (__ps != NULL
+ ? __mbrtowc (NULL, __s, __n, __ps) : __mbrlen (__s, __n, NULL)); }
#endif
/* Write wide character representation of multibyte character string
SRC to DST. */
-extern size_t __mbsrtowcs __P ((wchar_t *__dst, __const char **__src,
- size_t __len, mbstate_t *__ps));
-extern size_t mbsrtowcs __P ((wchar_t *__dst, __const char **__src,
- size_t __len, mbstate_t *__ps));
+extern size_t __mbsrtowcs __P ((wchar_t *__restrict __dst,
+ __const char **__restrict __src,
+ size_t __len, mbstate_t *__restrict __ps));
+extern size_t mbsrtowcs __P ((wchar_t *__restrict __dst,
+ __const char **__restrict __src,
+ size_t __len, mbstate_t *__restrict __ps));
/* Write multibyte character representation of wide character string
SRC to DST. */
-extern size_t __wcsrtombs __P ((char *__dst, __const wchar_t **__src,
- size_t __len, mbstate_t *__ps));
-extern size_t wcsrtombs __P ((char *__dst, __const wchar_t **__src,
- size_t __len, mbstate_t *__ps));
+extern size_t __wcsrtombs __P ((char *__restrict __dst,
+ __const wchar_t **__restrict __src,
+ size_t __len, mbstate_t *__restrict __ps));
+extern size_t wcsrtombs __P ((char *__restrict __dst,
+ __const wchar_t **__restrict __src,
+ size_t __len, mbstate_t *__restrict __ps));
#ifdef __USE_GNU
/* Write wide character representation of at most NMC bytes of the
multibyte character string SRC to DST. */
-extern size_t __mbsnrtowcs __P ((wchar_t *__dst, __const char **__src,
- size_t __nmc, size_t __len, mbstate_t *__ps));
-extern size_t mbsnrtowcs __P ((wchar_t *__dst, __const char **__src,
- size_t __nmc, size_t __len, mbstate_t *__ps));
+extern size_t __mbsnrtowcs __P ((wchar_t *__restrict __dst,
+ __const char **__restrict __src, size_t __nmc,
+ size_t __len, mbstate_t *__restrict __ps));
+extern size_t mbsnrtowcs __P ((wchar_t *__restrict __dst,
+ __const char **__restrict __src, size_t __nmc,
+ size_t __len, mbstate_t *__restrict __ps));
/* Write multibyte character representation of at most NWC characters
from the wide character string SRC to DST. */
-extern size_t __wcsnrtombs __P ((char *__dst, __const wchar_t **__src,
- size_t __nwc, size_t __len, mbstate_t *__ps));
-extern size_t wcsnrtombs __P ((char *__dst, __const wchar_t **__src,
- size_t __nwc, size_t __len, mbstate_t *__ps));
+extern size_t __wcsnrtombs __P ((char *__restrict __dst,
+ __const wchar_t **__restrict __src,
+ size_t __nwc, size_t __len,
+ mbstate_t *__restrict __ps));
+extern size_t wcsnrtombs __P ((char *__restrict __dst,
+ __const wchar_t **__restrict __src,
+ size_t __nwc, size_t __len,
+ mbstate_t *__restrict __ps));
/* The following functions are extensions found in X/Open CAE. */
/* Convert initial portion of the wide string NPTR to `double'
representation. */
-extern double wcstod __P ((__const wchar_t *__nptr, wchar_t **__endptr));
+extern double wcstod __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr));
#ifdef __USE_GNU
/* Likewise for `float' and `long double' sizes of floating-point numbers. */
-extern float wcstof __P ((__const wchar_t *__nptr, wchar_t **__endptr));
-extern __long_double_t wcstold __P ((__const wchar_t *__nptr,
- wchar_t **__endptr));
+extern float wcstof __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr));
+extern __long_double_t wcstold __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr));
#endif /* GNU */
/* Convert initial portion of wide string NPTR to `long int'
representation. */
-extern long int wcstol __P ((__const wchar_t *__nptr, wchar_t **__endptr,
- int __base));
+extern long int wcstol __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr, int __base));
/* Convert initial portion of wide string NPTR to `unsigned long int'
representation. */
-extern unsigned long int wcstoul __P ((__const wchar_t *__nptr,
- wchar_t **__endptr, int __base));
+extern unsigned long int wcstoul __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr,
+ int __base));
-#if defined (__GNUC__) && defined (__USE_GNU)
+#if defined __GNUC__ && defined __USE_GNU
/* Convert initial portion of wide string NPTR to `long int'
representation. */
-extern long long int wcstoq __P ((__const wchar_t *__nptr, wchar_t **__endptr,
- int __base));
+extern long long int wcstoq __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr, int __base));
/* Convert initial portion of wide string NPTR to `unsigned long long int'
representation. */
-extern unsigned long long int wcstouq __P ((__const wchar_t *__nptr,
- wchar_t **__endptr, int __base));
+extern unsigned long long int wcstouq __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr,
+ int __base));
#endif /* GCC and use GNU. */
+#if defined __USE_ISOC9X || (defined __GNUC__ && defined __USE_GNU)
+/* Convert initial portion of wide string NPTR to `long int'
+ representation. */
+extern long long int wcstoll __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr, int __base));
+
+/* Convert initial portion of wide string NPTR to `unsigned long long int'
+ representation. */
+extern unsigned long long int wcstoull __P ((__const wchar_t *
+ __restrict __nptr,
+ wchar_t **__restrict __endptr,
+ int __base));
+#endif /* ISO C 9X or GCC and GNU. */
+
/* The internal entry points for `wcstoX' take an extra flag argument
saying whether or not to parse locale-dependent number grouping. */
-extern double __wcstod_internal __P ((__const wchar_t *__nptr,
- wchar_t **__endptr, int __group));
-extern float __wcstof_internal __P ((__const wchar_t *__nptr,
- wchar_t **__endptr, int __group));
-extern __long_double_t __wcstold_internal __P ((__const wchar_t *__nptr,
- wchar_t **__endptr,
+extern double __wcstod_internal __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr,
+ int __group));
+extern float __wcstof_internal __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr,
+ int __group));
+extern __long_double_t __wcstold_internal __P ((__const wchar_t *
+ __restrict __nptr,
+ wchar_t **__restrict __endptr,
int __group));
-extern long int __wcstol_internal __P ((__const wchar_t *__nptr,
- wchar_t **__endptr, int __base,
- int __group));
-extern unsigned long int __wcstoul_internal __P ((__const wchar_t *__nptr,
- wchar_t **__endptr,
+extern long int __wcstol_internal __P ((__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr,
+ int __base, int __group));
+extern unsigned long int __wcstoul_internal __P ((__const wchar_t *
+ __restrict __nptr,
+ wchar_t **
+ __restrict __endptr,
int __base, int __group));
#if defined __GNUC__ && defined __USE_GNU
-extern long long int __wcstoq_internal __P ((__const wchar_t *__nptr,
- wchar_t **__endptr, int __base,
- int __group));
-extern unsigned long long int __wcstouq_internal __P ((__const wchar_t *__nptr,
- wchar_t **__endptr,
- int __base,
- int __group));
+extern long long int __wcstoll_internal __P ((__const wchar_t *
+ __restrict __nptr,
+ wchar_t **__restrict __endptr,
+ int __base, int __group));
+extern unsigned long long int __wcstoull_internal __P ((__const wchar_t *
+ __restrict __nptr,
+ wchar_t **
+ __restrict __endptr,
+ int __base,
+ int __group));
#endif /* GCC and use GNU. */
#if defined (__OPTIMIZE__) && __GNUC__ >= 2
/* Define inline functions which call the internal entry points. */
-extern __inline double wcstod (__const wchar_t *__nptr, wchar_t **__endptr)
+extern __inline double wcstod (__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr)
{ return __wcstod_internal (__nptr, __endptr, 0); }
-extern __inline long int wcstol (__const wchar_t *__nptr,
- wchar_t **__endptr, int __base)
+extern __inline long int wcstol (__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr, int __base)
{ return __wcstol_internal (__nptr, __endptr, __base, 0); }
-extern __inline unsigned long int wcstoul (__const wchar_t *__nptr,
- wchar_t **__endptr, int __base)
+extern __inline unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr,
+ int __base)
{ return __wcstoul_internal (__nptr, __endptr, __base, 0); }
#ifdef __USE_GNU
-extern __inline float wcstof (__const wchar_t *__nptr, wchar_t **__endptr)
+extern __inline float wcstof (__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr)
{ return __wcstof_internal (__nptr, __endptr, 0); }
-extern __inline __long_double_t wcstold (__const wchar_t *__nptr,
- wchar_t **__endptr)
+extern __inline __long_double_t wcstold (__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr)
{ return __wcstold_internal (__nptr, __endptr, 0); }
-extern __inline long long int wcstoq (__const wchar_t *__nptr,
- wchar_t **__endptr, int __base)
-{ return __wcstoq_internal (__nptr, __endptr, __base, 0); }
-extern __inline unsigned long long int wcstouq (__const wchar_t *__nptr,
- wchar_t **__endptr, int __base)
-{ return __wcstouq_internal (__nptr, __endptr, __base, 0); }
+extern __inline long long int wcstoq (__const wchar_t *__restrict __nptr,
+ wchar_t **__restrict __endptr,
+ int __base)
+{ return __wcstoll_internal (__nptr, __endptr, __base, 0); }
+extern __inline unsigned long long int wcstouq (__const wchar_t *
+ __restrict __nptr,
+ wchar_t **__restrict __endptr,
+ int __base)
+{ return __wcstoull_internal (__nptr, __endptr, __base, 0); }
#endif /* Use GNU. */
#endif /* Optimizing GCC >=2. */
--- /dev/null
+/* Copyright (C) 1991, 1992, 1995, 1996, 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <wctype.h>
+#include <wchar.h>
+
+#ifndef weak_alias
+# define __wcscasecmp wcscasecmp
+#endif
+
+/* Compare S1 and S2, ignoring case, returning less than, equal to or
+ greater than zero if S1 is lexicographically less than,
+ equal to or greater than S2. */
+int
+__wcscasecmp (s1, s2)
+ const wchar_t *s1;
+ const wchar_t *s2;
+{
+ wint_t c1, c2;
+
+ if (s1 == s2)
+ return 0;
+
+ do
+ {
+ c1 = towlower (*s1++);
+ c2 = towlower (*s2++);
+ if (c1 == '\0')
+ break;
+ }
+ while (c1 == c2);
+
+ return c1 - c2;
+}
+#ifdef weak_alias
+weak_alias (__wcscasecmp, wcscasecmp)
+#endif
--- /dev/null
+/* Compare at most N wide characters of two strings without taking care
+ for the case.
+ Copyright (C) 1992, 1996, 1997 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the GNU C Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+#include <wchar.h>
+#include <wctype.h>
+
+#ifndef weak_alias
+# define __wcsncasecmp wcsncasecmp
+#endif
+
+/* Compare no more than N wide characters of S1 and S2,
+ ignoring case, returning less than, equal to or
+ greater than zero if S1 is lexicographically less
+ than, equal to or greater than S2. */
+int
+__wcsncasecmp (s1, s2, n)
+ const wchar_t *s1;
+ const wchar_t *s2;
+ size_t n;
+{
+ wint_t c1, c2;
+
+ if (s1 == s2 || n == 0)
+ return 0;
+
+ do
+ {
+ c1 = (wint_t) towlower (*s1++);
+ c2 = (wint_t) towlower (*s2++);
+ if (c1 == L'\0' || c1 != c2)
+ return c1 - c2;
+ } while (--n > 0);
+
+ return c1 - c2;
+}
+#ifdef weak_alias
+weak_alias (__wcsncasecmp, wcsncasecmp)
+#endif
#define FLT LDBL
#define STRTOF wcstof
#define MPN2FLOAT __mpn_construct_float
-#define FLOAT_HUGE_VAL HUGE_VALf
+#define FLOAT_HUGE_VAL HUGE_VALF
#define USE_WIDE_CHAR 1
#include "../stdlib/strtod.c"
#define FLT LDBL
#define STRTOF wcstold
#define MPN2FLOAT __mpn_construct_long_double
-#define FLOAT_HUGE_VAL HUGE_VALl
+#define FLOAT_HUGE_VAL HUGE_VALL
#define USE_WIDE_CHAR 1
#include "../stdlib/strtod.c"
#define QUAD 1
#include "wcstol.c"
+
+weak_alias (wcstoll, wcstoq)
#define QUAD 1
#include "wcstoul.c"
+
+weak_alias (wcstoull, wcstouq)
projects / thirdparty / glibc.git / commitdiff
