AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-24 05:50:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

update from main archive 970225

Browse Source 
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>
1997-02-20 01:28  Miles Bader  <miles@gnu.ai.mit.edu>
1997-02-19 13:56  Miles Bader  <miles@gnu.ai.mit.edu>
1997-02-18 15:39  Miles Bader  <miles@gnu.ai.mit.edu>
1997-02-17 10:58  Miles Bader  <miles@gnu.ai.mit.edu>
1997-02-15 10:23  Miles Bader  <miles@gnu.ai.mit.edu>
	(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.

	* sysdeps/mach/hurd/i386/init-first.c (__libc_argv, __libc_argc):
	__hurd_sigthread_stack_end, __hurd_sigthread_stack_variables,
	__hurd_threadvar_max, __hurd_threadvar_stack_offset,
	__hurd_threadvar_stack_mask): Variables removed.
1997-02-14 14:07  Miles Bader  <miles@gnu.ai.mit.edu>
	* hurd/hurd.h (_hurd_pids_changed_stamp, _hurd_pids_changed_sync):
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-15 04:51  Ulrich Drepper  <drepper@cygnus.com>
This commit is contained in:
Ulrich Drepper 1997-02-25 05:18:05 +00:00
parent 6bac11d993
commit 2f6d1f1be9
81 changed files with 2553 additions and 667 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
ChangeLog
View File

@ -1,4 +1,168 @@
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.
@ -6,12 +170,12 @@ Fri Feb 21 00:22:28 1997 Miles Bader <miles@gnu.ai.mit.edu>
* 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.
@ -20,7 +184,7 @@ Wed Feb 19 13:56:04 1997 Miles Bader <miles@gnu.ai.mit.edu>
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.
@ -30,7 +194,7 @@ Tue Feb 18 15:39:08 1997 Miles Bader <miles@gnu.ai.mit.edu>
* 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.
@ -40,16 +204,18 @@ Mon Feb 17 10:58:14 1997 Miles Bader <miles@gnu.ai.mit.edu>
* 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.
@ -80,7 +246,7 @@ Sat Feb 15 10:23:32 1997 Miles Bader <miles@gnu.ai.mit.edu>
__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):
Declare extern.
@ -103,6 +269,26 @@ Fri Feb 14 14:07:19 1997 Miles Bader <miles@gnu.ai.mit.edu>
* 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.
@ -436,7 +622,7 @@ Fri Feb 14 14:07:19 1997 Miles Bader <miles@gnu.ai.mit.edu>
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

12
Makefile
View File

@ -277,19 +277,25 @@ parent_echo-distinfo:
$(addprefix +nodist+,$(generated))
# 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)
# 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

11
catgets/gencat.c
View File

@ -152,6 +152,7 @@ int
main (int argc, char *argv[])
{
struct catalog *result;
int remaining;
/* Set program name for messages. */
error_print_progname = error_print;
@ -166,18 +167,18 @@ main (int argc, char *argv[])
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, "-");

13
db/makedb.c
View File

@ -99,6 +99,7 @@ main (argc, argv)
FILE *input_file;
DB *db_file;
int status;
int remaining;
/* Set locale via LC_ALL. */
setlocale (LC_ALL, "");
@ -110,27 +111,27 @@ main (argc, argv)
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. */

42
elf/ldd.bash.in
View File

@ -69,6 +69,7 @@ Report bugs using the \`glibcbug' script to <bugs@gnu.ai.mit.edu>."
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"
@ -86,20 +87,29 @@ case $# in
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
${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
fi
exit ;;
*)
set -e # Bail out immediately if ${RTLD} loses on any argument.
result=0
for file; do
echo "${file}:"
@ -113,13 +123,23 @@ case $# in
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

41
elf/ldd.sh.in
View File

@ -66,6 +66,7 @@ Try \`ldd --help' for more information."
esac
done
add_env="LD_TRACE_LOADED_OBJECTS=1 LD_WARN=$warn LD_BIND_NOW=$bind_now"
case $# in
0)
echo >&2 "\
@ -85,13 +86,23 @@ Try \`ldd --help' for more information."
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
@ -114,13 +125,23 @@ Try \`ldd --help' for more information."
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

4
elf/rtld.c
View File

@ -155,6 +155,7 @@ dl_main (const ElfW(Phdr) *phdr,
const char *preloadlist;
size_t file_size;
char *file;
int has_interp = 0;
mode = getenv ("LD_TRACE_LOADED_OBJECTS") != NULL ? trace : normal;
@ -299,6 +300,7 @@ of this helper program; chances are you did not intend to run this program.\n",
_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)
@ -315,7 +317,7 @@ of this helper program; chances are you did not intend to run this program.\n",
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);

19
features.h
View File

@ -24,6 +24,7 @@
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
@ -44,6 +45,7 @@
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.
@ -69,6 +71,7 @@
/* Undefine everything, so we get a clean slate. */
#undef __USE_ISOC9X
#undef __USE_POSIX
#undef __USE_POSIX2
#undef __USE_POSIX199309
@ -102,6 +105,8 @@
/* 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
@ -118,14 +123,20 @@
/* 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 && \

2
glibcbug.in
View File

@ -232,7 +232,7 @@ sed -e "
/^>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

320
isomac.c Normal file
View File

@ -0,0 +1,320 @@
/* 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 */

6
libio/clearerr.c
View File

@ -1,4 +1,4 @@
/* 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
@ -28,7 +28,3 @@ clearerr (fp)
_IO_clearerr (fp);
_IO_funlockfile (fp);
}
#ifdef _IO_MTSAFE_IO
weak_alias (clearerr, clearerr_locked)
#endif

8
libio/feof.c
View File

@ -36,11 +36,3 @@ _IO_feof (fp)
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

5
libio/ferror.c
View File

@ -36,8 +36,3 @@ _IO_ferror (fp)
return result;
}
weak_alias (_IO_ferror, ferror)
#ifdef _IO_MTSAFE_IO
weak_alias (ferror, ferror_locked)
#endif

1
libio/fileno.c
View File

@ -43,5 +43,4 @@ fileno (fp)
(at least at thread level). */
weak_alias (fileno, fileno_unlocked)
weak_alias (fileno, fileno_locked)
#endif

2
libio/fputc.c
View File

@ -38,5 +38,3 @@ fputc (c, fp)
_IO_cleanup_region_end (1);
return result;
}
weak_alias (fputc, fputc_locked)

6
libio/getc.c
View File

@ -41,9 +41,3 @@ _IO_getc (fp)
}
#undef getc
weak_alias (_IO_getc, getc)
#ifdef _IO_MTSAFE_IO
# undef getc_locked
weak_alias (getc, getc_locked)
#endif

6
libio/getchar.c
View File

@ -37,9 +37,3 @@ getchar ()
_IO_cleanup_region_end (1);
return result;
}
#ifdef _IO_MTSAFE_IO
# undef getchar_locked
weak_alias (getchar, getchar_locked)
#endif

4
libio/iofflush.c
View File

@ -44,7 +44,3 @@ _IO_fflush (fp)
}
weak_alias (_IO_fflush, fflush)
#ifdef _IO_MTSAFE_IO
weak_alias (_IO_fflush, fflush_locked)
#endif

34
libio/putc.c
View File

@ -1,20 +1,20 @@
/* 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"
@ -36,9 +36,3 @@ _IO_putc (c, fp)
}
#undef putc
weak_alias (_IO_putc, putc)
#ifdef _IO_MTSAFE_IO
# undef putc_locked
weak_alias (putc, putc_locked)
#endif

34
libio/putchar.c
View File

@ -1,20 +1,20 @@
/* 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"
@ -33,9 +33,3 @@ putchar (c)
__libc_cleanup_region_end (1);
return result;
}
#ifdef _IO_MTSAFE_IO
# undef putchar_locked
weak_alias (putchar, putchar_locked)
#endif

722
libio/stdio.h
View File

@ -1,209 +1,191 @@
/* 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
#ifndef BUFSIZ
#define BUFSIZ _IO_BUFSIZ
#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. */
#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
/* Default buffer size. */
#ifndef BUFSIZ
#define BUFSIZ _IO_BUFSIZ
#endif
typedef struct _IO_FILE FILE;
typedef _IO_fpos_t fpos_t;
#include <stdio_lim.h>
/* End of file character.
Some things throughout the library rely on this being -1. */
#ifndef EOF
#define EOF (-1)
#endif
/* 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*/
/* 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));
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*));
/* 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
/* 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));
/* Return the name of the controlling terminal. */
extern char *ctermid __P ((char *__buf));
/* 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));
/* 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
@ -211,77 +193,409 @@ extern int vasprintf __P ((char **, const char *, _G_va_list));
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));
/* 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
extern int sys_nerr;
extern const char *const sys_errlist[];
/* 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
/* 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
extern int _sys_nerr;
extern const char *const _sys_errlist[];
/* 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
/* 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));
/* 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, ...));
# ifndef _LIBC
# define getc_locked(fp) _IO_getc (fp)
# define getchar_locked() _IO_getc (stdin)
# define putchar_locked(c) _IO_putc (c, stdout)
# endif
#endif
#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 */
#ifdef __OPTIMIZE__
extern __inline int
getc_unlocked (FILE *__fp)
{
return _IO_getc_unlocked (__fp);
}
#define getc(_fp) _IO_getc (_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 __cplusplus
#ifdef __OPTIMIZE__
extern __inline int
putchar (int __c)
{
return _IO_putc (__c, stdout);
}
#endif
#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 */

3
locale/C-time.c
View File

@ -27,7 +27,7 @@ const struct locale_data _nl_C_LC_TIME =
_nl_C_name,
NULL, 0, 0, /* no file mapped */
MAX_USAGE_COUNT,
53,
54,
{
{ string: "Sun" },
{ string: "Mon" },
@ -80,6 +80,7 @@ const struct locale_data _nl_C_LC_TIME =
{ string: "" },
{ string: "" },
{ word: 0 },
{ word: 0 },
{ string: "" },
{ string: "" },
}

10
locale/programs/locale.c
View File

@ -166,6 +166,8 @@ static void show_info (const char *name);
int
main (int argc, char *argv[])
{
int remaining;
/* Set initial values for global variables. */
show_category_name = 0;
show_keyword_name = 0;
@ -179,7 +181,7 @@ main (int argc, char *argv[])
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)
@ -203,15 +205,15 @@ main (int argc, char *argv[])
/* 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);
}

7
locale/programs/localedef.c
View File

@ -148,6 +148,7 @@ main (int argc, char *argv[])
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;
@ -163,7 +164,7 @@ main (int argc, char *argv[])
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. */
@ -172,7 +173,7 @@ main (int argc, char *argv[])
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,
@ -185,7 +186,7 @@ main (int argc, char *argv[])
/* 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

162
malloc/malloc.c
View File

@ -19,7 +19,7 @@
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:
@ -874,6 +874,8 @@ extern Void_t* sbrk();
#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
@ -889,6 +891,8 @@ extern Void_t* sbrk();
#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
@ -912,7 +916,11 @@ size_t mALLOC_USABLE_SIZe(Void_t*);
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
@ -929,7 +937,10 @@ size_t mALLOC_USABLE_SIZe();
void mALLOC_STATs();
int mALLOPt();
struct mallinfo mALLINFo();
#endif
Void_t* mALLOC_GET_STATe();
int mALLOC_SET_STATe();
#endif /* __STD_C */
#ifdef __cplusplus
@ -3775,6 +3786,144 @@ int mALLOPt(param_number, value) int param_number; int value;
/* 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;
}
#if defined(_LIBC) || defined(MALLOC_HOOKS)
/* A simple, standard set of debugging hooks. Overhead is `only' one
@ -4048,12 +4197,19 @@ weak_alias (__libc_mallopt, __mallopt) weak_alias (__libc_mallopt, mallopt)
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

7
malloc/malloc.h
View File

@ -171,6 +171,13 @@ extern size_t malloc_usable_size __MALLOC_P ((__malloc_ptr_t __ptr));
/* 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. */

36
malloc/thread-m.h
View File

@ -1,6 +1,6 @@
/* 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.
@ -66,19 +66,37 @@ static Void_t *malloc_key_data;
(__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;
#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)
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))
/* No we're *not* using pthreads. */
#define __pthread_initialize ((void (*)(void))0)
#else

28
manual/stdio-fp.c Normal file
View File

@ -0,0 +1,28 @@
/* 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;
}

55
manual/stdio.texi
View File

@ -1007,6 +1007,12 @@ whichever is more appropriate for its magnitude. @samp{%g} uses
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}.
@ -1194,6 +1200,34 @@ than -4 or greater than or equal to the precision; otherwise they use the
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.
@ -1255,21 +1289,22 @@ floating-point conversions. All of the numbers were printed using
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.

11
math/math.h
View File

@ -1,5 +1,5 @@
/* 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
@ -99,9 +99,12 @@ extern _LIB_VERSION_TYPE _LIB_VERSION;
#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;
@ -128,7 +131,7 @@ extern int matherr __P ((struct exception *));
#define HUGE FLT_MAX
#include <float.h> /* Defines FLT_MAX. */
#endif
#endif /* SVID && !C++ */
#ifdef __USE_BSD

13
misc/error.c
View File

@ -71,6 +71,11 @@ unsigned int error_message_count;
#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
@ -230,3 +235,11 @@ error_at_line (status, errnum, file_name, line_number, message, va_alist)
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

7
misc/sys/cdefs.h
View File

@ -1,4 +1,4 @@
/* 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
@ -102,4 +102,9 @@
#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 */

8
rellns-sh
View File

@ -1,6 +1,6 @@
#! /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
@ -22,12 +22,6 @@ if test $# -ne 2; then
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.

2
stdio-common/Makefile
View File

@ -25,7 +25,7 @@ headers := stdio_lim.h printf.h
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 \

10
stdio-common/printf_fp.c
View File

@ -1,5 +1,5 @@
/* 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.
@ -291,12 +291,12 @@ __printf_fp (FILE *fp,
/* 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
@ -316,12 +316,12 @@ __printf_fp (FILE *fp,
/* 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

440
stdio-common/printf_fphex.c Normal file
View File

@ -0,0 +1,440 @@
/* 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 */
/* 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)
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;
}

10
stdio-common/tstscanf.c
View File

@ -140,5 +140,15 @@ main (int argc, char **argv)
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);
}

86
stdio-common/vfprintf.c
View File

@ -238,7 +238,7 @@ vfprintf (FILE *s, const CHAR_T *format, va_list ap)
/* '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,
@ -246,7 +246,7 @@ vfprintf (FILE *s, const CHAR_T *format, va_list ap)
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,
@ -270,7 +270,7 @@ vfprintf (FILE *s, const CHAR_T *format, va_list ap)
#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 ' ' */ \
@ -297,10 +297,11 @@ vfprintf (FILE *s, const CHAR_T *format, va_list ap)
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 ' ' */ \
@ -327,10 +328,11 @@ vfprintf (FILE *s, const CHAR_T *format, va_list ap)
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 ' ' */ \
@ -357,10 +359,11 @@ vfprintf (FILE *s, const CHAR_T *format, va_list ap)
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 ' ' */ \
@ -387,12 +390,13 @@ vfprintf (FILE *s, const CHAR_T *format, va_list ap)
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 ' ' */ \
@ -419,7 +423,8 @@ vfprintf (FILE *s, const CHAR_T *format, va_list ap)
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' */ \
}
@ -702,6 +707,53 @@ vfprintf (FILE *s, const CHAR_T *format, va_list ap)
} \
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) \
@ -881,7 +933,7 @@ vfprintf (FILE *s, const CHAR_T *format, va_list ap)
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
@ -1405,16 +1457,16 @@ printf_unknown (FILE *s, const struct printf_info *info,
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')

4
stdio-common/vfscanf.c
View File

@ -841,9 +841,9 @@ __vfscanf (FILE *s, const char *format, va_list argptr)
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
{

69
stdio/stdio.h
View File

@ -1,4 +1,4 @@
/* 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
@ -307,7 +307,7 @@ 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.
@ -339,8 +339,9 @@ extern int fcloseall __P ((void));
/* 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.
@ -376,11 +377,11 @@ extern FILE *open_memstream __P ((char **__bufloc, size_t *__sizeloc));
/* 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
@ -394,24 +395,29 @@ extern void setlinebuf __P ((FILE *__stream));
/* 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);
}
@ -443,11 +449,13 @@ extern int dprintf __P ((int __fd, __const char *__fmt, ...));
/* 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. */
@ -556,7 +564,8 @@ extern int putw __P ((int __w, FILE *__stream));
/* 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. */
@ -582,27 +591,17 @@ ssize_t getline __P ((char **__lineptr, size_t *__n, FILE *__stream));
#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));
@ -612,11 +611,11 @@ extern int ungetc __P ((int __c, FILE *__stream));
/* 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. */
@ -627,7 +626,7 @@ extern long int ftell __P ((FILE *__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));

2
stdlib/Makefile
View File

@ -38,7 +38,7 @@ routines := \
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 \

147
stdlib/stdlib.h
View File

@ -79,69 +79,83 @@ extern int atoi __P ((__const char *__nptr));
/* 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));
#if defined (__GNUC__) && defined (__USE_BSD)
/* Convert a string to a quadword integer. */
extern long long int strtoq __P ((__const char *__nptr, char **__endptr,
extern unsigned long int strtoul __P ((__const char *__restrict __nptr,
char **__restrict __endptr,
int __base));
#if defined __GNUC__ && defined __USE_BSD
/* Convert a string to a quadword integer. */
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,
extern double __strtod_internal __P ((__const char *__restrict __nptr,
char **__restrict __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 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 *
__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));
#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,
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 */
@ -149,38 +163,45 @@ extern unsigned long long int __strtouq_internal __P ((__const char *__nptr,
#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,
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 __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); }
{ return __strtoull_internal (__nptr, __endptr, __base, 0); }
#endif
#ifdef __USE_MISC
extern __inline long long int strtoll (__const char *__nptr, char **__endptr,
#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 __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); }
{ return __strtoull_internal (__nptr, __endptr, __base, 0); }
#endif
extern __inline double atof (__const char *__nptr)
@ -483,8 +504,9 @@ extern void qsort __P ((__ptr_t __base, size_t __nmemb, size_t __size,
/* 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
@ -492,9 +514,11 @@ extern long long int llabs __P ((long long int __x)) __attribute__ ((__const__))
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
@ -548,7 +572,8 @@ extern int qfcvt_r __P ((__long_double_t __value, int __ndigit, int *__decpt,
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));
@ -560,9 +585,11 @@ extern __inline int mblen (__const char *__s, size_t __n)
/* 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

50
stdlib/strtod.c
View File

@ -41,18 +41,21 @@
# 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. */
#include <ctype.h>
#include <errno.h>
#include <float.h>
#include <ieee754.h>
#include "../locale/localeinfo.h"
#include <math.h>
#include <stdlib.h>
@ -433,7 +436,54 @@ INTERNAL (STRTOF) (nptr, endptr, group)
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')))
{
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;

2
stdlib/strtof.c
View File

@ -5,6 +5,6 @@
#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"

16
stdlib/strtol.c
View File

@ -1,4 +1,4 @@
/* 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.
@ -54,7 +54,7 @@ extern int errno;
# 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
@ -67,13 +67,13 @@ extern int errno;
#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
@ -81,18 +81,18 @@ extern int errno;
#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
@ -312,8 +312,6 @@ INTERNAL (strtol) (nptr, endptr, base, group)
? -((unsigned LONG int) (LONG_MIN + 1)) + 1
: (unsigned LONG int) LONG_MAX))
overflow = 1;
#else
overflow |= negative;
#endif
if (overflow)

2
stdlib/strtold.c
View File

@ -5,6 +5,6 @@
#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"

2
stdlib/strtoq.c → stdlib/strtoll.c
View File

@ -21,4 +21,4 @@
#include <strtol.c>
weak_alias (strtoq, strtoll)
weak_alias (strtoll, strtoq)

2
stdlib/strtouq.c → stdlib/strtoull.c
View File

@ -21,4 +21,4 @@
#include <strtoul.c>
weak_alias (strtouq, strtoull)
weak_alias (strtoull, strtouq)

4
stdlib/tst-strtol.c
View File

@ -38,7 +38,7 @@ static const struct ltest tests[] =
{ "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... */
@ -66,7 +66,7 @@ static const struct ltest tests[] =
{ "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
};

22
string/string.h
View File

@ -34,8 +34,8 @@ __BEGIN_DECLS
/* 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,
@ -64,14 +64,18 @@ extern __ptr_t memchr __P ((__const __ptr_t __s, int __c, size_t __n));
/* 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));
@ -81,7 +85,8 @@ extern int strncmp __P ((__const char *__s1, __const char *__s2, size_t __n));
/* 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
@ -150,7 +155,8 @@ extern char *strpbrk __P ((__const char *__s, __const char *__accept));
/* 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

40
sysdeps/ieee754/huge_val.h
View File

@ -1,6 +1,6 @@
/* `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
@ -44,43 +44,49 @@ static __huge_val_t __huge_val = { __HUGE_VAL_bytes };
#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 */

2
sysdeps/libm-ieee754/s_cbrtl.c
View File

@ -90,7 +90,7 @@ G = 3.57142857142857150787e-01L; /* 5/14 */
{
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);

2
sysdeps/posix/gai_strerror.c
View File

@ -43,7 +43,7 @@ values[] =
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;

2
sysdeps/unix/syscalls.list
View File

@ -7,7 +7,7 @@ chmod - chmod 2 __chmod chmod
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

1
sysdeps/unix/sysv/linux/accept.S
View File

@ -1,2 +1,3 @@
#define socket accept
#define NARGS 3
#include <socket.S>

1
sysdeps/unix/sysv/linux/bind.S
View File

@ -1,2 +1,3 @@
#define socket bind
#define NARGS 3
#include <socket.S>

1
sysdeps/unix/sysv/linux/connect.S
View File

@ -1,2 +1,3 @@
#define socket connect
#define NARGS 3
#include <socket.S>

1
sysdeps/unix/sysv/linux/getpeername.S
View File

@ -1,2 +1,3 @@
#define socket getpeername
#define NARGS 3
#include <socket.S>

1
sysdeps/unix/sysv/linux/getsockname.S
View File

@ -1,2 +1,3 @@
#define socket getsockname
#define NARGS 3
#include <socket.S>

1
sysdeps/unix/sysv/linux/getsockopt.S
View File

@ -1,2 +1,3 @@
#define socket getsockopt
#define NARGS 5
#include <socket.S>

28
sysdeps/unix/sysv/linux/i386/socket.S
View File

@ -1,20 +1,20 @@
/* Copyright (C) 1995, 1996 Free Software Foundation, Inc.
This file is part of the GNU C Library.
/* 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 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 <sysdep.h>
#include <sys/socketcall.h>

1
sysdeps/unix/sysv/linux/listen.S
View File

@ -1,2 +1,3 @@
#define socket listen
#define NARGS 2
#include <socket.S>

1
sysdeps/unix/sysv/linux/recv.S
View File

@ -1,2 +1,3 @@
#define socket recv
#define NARGS 4
#include <socket.S>

1
sysdeps/unix/sysv/linux/recvfrom.S
View File

@ -1,2 +1,3 @@
#define socket recvfrom
#define NARGS 6
#include <socket.S>

1
sysdeps/unix/sysv/linux/recvmsg.S
View File

@ -1,2 +1,3 @@
#define socket recvmsg
#define NARGS 3
#include <socket.S>

1
sysdeps/unix/sysv/linux/send.S
View File

@ -1,2 +1,3 @@
#define socket send
#define NARGS 4
#include <socket.S>

1
sysdeps/unix/sysv/linux/sendmsg.S
View File

@ -1,2 +1,3 @@
#define socket sendmsg
#define NARGS 3
#include <socket.S>

1
sysdeps/unix/sysv/linux/sendto.S
View File

@ -1,2 +1,3 @@
#define socket sendto
#define NARGS 6
#include <socket.S>

1
sysdeps/unix/sysv/linux/setsockopt.S
View File

@ -1,2 +1,3 @@
#define socket setsockopt
#define NARGS 5
#include <socket.S>

1
sysdeps/unix/sysv/linux/shutdown.S
View File

@ -1,2 +1,3 @@
#define socket shutdown
#define NARGS 2
#include <socket.S>

1
sysdeps/unix/sysv/linux/socketpair.S
View File

@ -1,2 +1,3 @@
#define socket socketpair
#define NARGS 4
#include <socket.S>

4
sysdeps/unix/sysv/linux/timebits.h
View File

@ -1,5 +1,5 @@
/* 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
@ -43,8 +43,10 @@ struct timeval
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
# endif
#endif /* timebits.h */

5
time/time.h
View File

@ -152,8 +152,9 @@ extern time_t __mktime_internal __P ((struct tm *__tp,
/* 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.

9
wcsmbs/Makefile
View File

@ -30,10 +30,11 @@ routines := wcscat wcschr wcscmp wcscpy wcscspn wcsdup wcslen wcsncat \
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
@ -42,8 +43,8 @@ CFLAGS-wcswidth.c = -I../wctype
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

232
wcsmbs/wchar.h
View File

@ -64,16 +64,18 @@ typedef struct
/* 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));
@ -81,13 +83,26 @@ 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
@ -97,12 +112,12 @@ extern size_t wcsxfrm __P ((wchar_t *__s1, __const wchar_t *__s2, size_t __n));
/* 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. */
@ -127,8 +142,9 @@ extern wchar_t *wcspbrk __P ((__const wchar_t *__wcs,
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));
@ -138,12 +154,12 @@ 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. */
@ -168,55 +184,73 @@ extern int mbsinit __P ((__const mbstate_t *__ps));
/* 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. */
@ -232,61 +266,87 @@ extern int wcswidth __P ((__const wchar_t *__s, size_t __n));
/* 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,
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. */
@ -295,29 +355,35 @@ extern unsigned long long int __wcstouq_internal __P ((__const wchar_t *__nptr,
#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. */

56
wcsmbs/wcscasecmp.c Normal file
View File

@ -0,0 +1,56 @@
/* 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

55
wcsmbs/wcsncase.c Normal file
View File

@ -0,0 +1,55 @@
/* 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

2
wcsmbs/wcstof.c
View File

@ -25,7 +25,7 @@
#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"

2
wcsmbs/wcstold.c
View File

@ -25,7 +25,7 @@
#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"

2
wcsmbs/wcstoq.c → wcsmbs/wcstoll.c
View File

@ -21,3 +21,5 @@
#define QUAD 1
#include "wcstol.c"
weak_alias (wcstoll, wcstoq)

2
wcsmbs/wcstouq.c → wcsmbs/wcstoull.c
View File

@ -21,3 +21,5 @@
#define QUAD 1
#include "wcstoul.c"
weak_alias (wcstoull, wcstouq)