OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /or1k/trunk/newlib-1.10.0/newlib/libc/string
    from Rev 1010 to Rev 1765
    ↔ Reverse comparison
  •

Rev 1010 → Rev 1765

/Makefile.in
0,0 → 1,423
# Makefile.in generated automatically by automake 1.4 from Makefile.am
 
# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
 
 
 
SHELL = @SHELL@
 
srcdir = @srcdir@
top_srcdir = @top_srcdir@
VPATH = @srcdir@
prefix = @prefix@
exec_prefix = @exec_prefix@
 
bindir = @bindir@
sbindir = @sbindir@
libexecdir = @libexecdir@
datadir = @datadir@
sysconfdir = @sysconfdir@
sharedstatedir = @sharedstatedir@
localstatedir = @localstatedir@
libdir = @libdir@
infodir = @infodir@
mandir = @mandir@
includedir = @includedir@
oldincludedir = /usr/include
 
DESTDIR =
 
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
 
top_builddir = ..
 
ACLOCAL = @ACLOCAL@
AUTOCONF = @AUTOCONF@
AUTOMAKE = @AUTOMAKE@
AUTOHEADER = @AUTOHEADER@
 
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS)
INSTALL_DATA = @INSTALL_DATA@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
transform = @program_transform_name@
 
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
host_alias = @host_alias@
host_triplet = @host@
AR = @AR@
AS = @AS@
CC = @CC@
CPP = @CPP@
CRT0 = @CRT0@
DLLTOOL = @DLLTOOL@
EXEEXT = @EXEEXT@
LDFLAGS = @LDFLAGS@
LIBC_MACHINE_LIB = @LIBC_MACHINE_LIB@
LIBC_POSIX_LIB = @LIBC_POSIX_LIB@
LIBC_SIGNAL_DEF = @LIBC_SIGNAL_DEF@
LIBC_SIGNAL_LIB = @LIBC_SIGNAL_LIB@
LIBC_SYSCALL_LIB = @LIBC_SYSCALL_LIB@
LIBC_SYS_LIB = @LIBC_SYS_LIB@
LIBC_UNIX_LIB = @LIBC_UNIX_LIB@
LIBTOOL = @LIBTOOL@
LN_S = @LN_S@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
NEWLIB_CFLAGS = @NEWLIB_CFLAGS@
OBJDUMP = @OBJDUMP@
PACKAGE = @PACKAGE@
RANLIB = @RANLIB@
VERSION = @VERSION@
aext = @aext@
libm_machine_dir = @libm_machine_dir@
machine_dir = @machine_dir@
newlib_basedir = @newlib_basedir@
oext = @oext@
sys_dir = @sys_dir@
 
AUTOMAKE_OPTIONS = cygnus
 
INCLUDES = $(NEWLIB_CFLAGS) $(CROSS_CFLAGS) $(TARGET_CFLAGS)
 
LIB_SOURCES = \
bcmp.c \
bcopy.c \
bzero.c \
index.c \
memchr.c \
memcmp.c \
memcpy.c \
memmove.c \
memset.c \
rindex.c \
strcat.c \
strchr.c \
strcmp.c \
strcasecmp.c \
strcoll.c \
strcpy.c \
strcspn.c \
strerror.c \
strlen.c \
strlwr.c \
strncat.c \
strncmp.c \
strncasecmp.c \
strncpy.c \
strnlen.c \
strpbrk.c \
strrchr.c \
strspn.c \
strtok.c \
strtok_r.c \
strupr.c \
strxfrm.c \
strstr.c \
swab.c \
u_strerr.c
 
 
libstring_la_LDFLAGS = -Xcompiler -nostdlib
 
@USE_LIBTOOL_TRUE@noinst_LTLIBRARIES = @USE_LIBTOOL_TRUE@libstring.la
@USE_LIBTOOL_TRUE@libstring_la_SOURCES = @USE_LIBTOOL_TRUE@$(LIB_SOURCES)
@USE_LIBTOOL_TRUE@noinst_DATA = @USE_LIBTOOL_TRUE@objectlist.awk.in
@USE_LIBTOOL_FALSE@noinst_DATA =
@USE_LIBTOOL_FALSE@noinst_LIBRARIES = @USE_LIBTOOL_FALSE@lib.a
@USE_LIBTOOL_FALSE@lib_a_SOURCES = @USE_LIBTOOL_FALSE@$(LIB_SOURCES)
 
CHEWOUT_FILES = \
bcmp.def memcpy.def strcmp.def strncat.def strstr.def \
bcopy.def memmove.def strcoll.def strncmp.def strtok.def \
bzero.def memset.def strcpy.def strncpy.def strxfrm.def \
index.def rindex.def strcspn.def strpbrk.def swab.def \
memchr.def strcat.def strerror.def strrchr.def \
memcmp.def strchr.def strlen.def strspn.def strnlen.def \
strcasecmp.def strncasecmp.def strlwr.def strupr.def
 
 
SUFFIXES = .def
 
CHEW = ../../doc/makedoc -f $(srcdir)/../../doc/doc.str
 
TARGETDOC = ../tmp.texi
 
CLEANFILES = $(CHEWOUT_FILES) *.ref
mkinstalldirs = $(SHELL) $(top_srcdir)/../../mkinstalldirs
CONFIG_CLEAN_FILES =
LIBRARIES = $(noinst_LIBRARIES)
 
 
DEFS = @DEFS@ -I. -I$(srcdir)
CPPFLAGS = @CPPFLAGS@
LIBS = @LIBS@
lib_a_LIBADD =
@USE_LIBTOOL_FALSE@lib_a_OBJECTS = bcmp.o bcopy.o bzero.o index.o \
@USE_LIBTOOL_FALSE@memchr.o memcmp.o memcpy.o memmove.o memset.o \
@USE_LIBTOOL_FALSE@rindex.o strcat.o strchr.o strcmp.o strcasecmp.o \
@USE_LIBTOOL_FALSE@strcoll.o strcpy.o strcspn.o strerror.o strlen.o \
@USE_LIBTOOL_FALSE@strlwr.o strncat.o strncmp.o strncasecmp.o strncpy.o \
@USE_LIBTOOL_FALSE@strpbrk.o strrchr.o strspn.o strtok.o strtok_r.o \
@USE_LIBTOOL_FALSE@strupr.o strxfrm.o strstr.o swab.o u_strerr.o strnlen.o
LTLIBRARIES = $(noinst_LTLIBRARIES)
 
libstring_la_LIBADD =
@USE_LIBTOOL_TRUE@libstring_la_OBJECTS = bcmp.lo bcopy.lo bzero.lo \
@USE_LIBTOOL_TRUE@index.lo memchr.lo memcmp.lo memcpy.lo memmove.lo \
@USE_LIBTOOL_TRUE@memset.lo rindex.lo strcat.lo strchr.lo strcmp.lo \
@USE_LIBTOOL_TRUE@strcasecmp.lo strcoll.lo strcpy.lo strcspn.lo \
@USE_LIBTOOL_TRUE@strerror.lo strlen.lo strlwr.lo strncat.lo strncmp.lo \
@USE_LIBTOOL_TRUE@strncasecmp.lo strncpy.lo strpbrk.lo strrchr.lo \
@USE_LIBTOOL_TRUE@strspn.lo strtok.lo strtok_r.lo strupr.lo strxfrm.lo \
@USE_LIBTOOL_TRUE@strstr.lo swab.lo u_strerr.lo strnlen.lo
CFLAGS = @CFLAGS@
COMPILE = $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(LDFLAGS) -o $@
DATA = $(noinst_DATA)
 
DIST_COMMON = Makefile.am Makefile.in
 
 
DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
 
TAR = gtar
GZIP_ENV = --best
SOURCES = $(lib_a_SOURCES) $(libstring_la_SOURCES)
OBJECTS = $(lib_a_OBJECTS) $(libstring_la_OBJECTS)
 
all: all-redirect
.SUFFIXES:
.SUFFIXES: .S .c .def .lo .o .s
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) $(srcdir)/../../Makefile.shared
cd $(top_srcdir) && $(AUTOMAKE) --cygnus string/Makefile
 
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
cd $(top_builddir) \
&& CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
 
 
mostlyclean-noinstLIBRARIES:
 
clean-noinstLIBRARIES:
-test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
 
distclean-noinstLIBRARIES:
 
maintainer-clean-noinstLIBRARIES:
 
.c.o:
$(COMPILE) -c $<
 
.s.o:
$(COMPILE) -c $<
 
.S.o:
$(COMPILE) -c $<
 
mostlyclean-compile:
-rm -f *.o core *.core
 
clean-compile:
 
distclean-compile:
-rm -f *.tab.c
 
maintainer-clean-compile:
 
.c.lo:
$(LIBTOOL) --mode=compile $(COMPILE) -c $<
 
.s.lo:
$(LIBTOOL) --mode=compile $(COMPILE) -c $<
 
.S.lo:
$(LIBTOOL) --mode=compile $(COMPILE) -c $<
 
mostlyclean-libtool:
-rm -f *.lo
 
clean-libtool:
-rm -rf .libs _libs
 
distclean-libtool:
 
maintainer-clean-libtool:
 
lib.a: $(lib_a_OBJECTS) $(lib_a_DEPENDENCIES)
-rm -f lib.a
$(AR) cru lib.a $(lib_a_OBJECTS) $(lib_a_LIBADD)
$(RANLIB) lib.a
 
mostlyclean-noinstLTLIBRARIES:
 
clean-noinstLTLIBRARIES:
-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
 
distclean-noinstLTLIBRARIES:
 
maintainer-clean-noinstLTLIBRARIES:
 
libstring.la: $(libstring_la_OBJECTS) $(libstring_la_DEPENDENCIES)
$(LINK) $(libstring_la_LDFLAGS) $(libstring_la_OBJECTS) $(libstring_la_LIBADD) $(LIBS)
 
tags: TAGS
 
ID: $(HEADERS) $(SOURCES) $(LISP)
list='$(SOURCES) $(HEADERS)'; \
unique=`for i in $$list; do echo $$i; done | \
awk ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
here=`pwd` && cd $(srcdir) \
&& mkid -f$$here/ID $$unique $(LISP)
 
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) $(LISP)
tags=; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS)'; \
unique=`for i in $$list; do echo $$i; done | \
awk ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \
|| (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags $$unique $(LISP) -o $$here/TAGS)
 
mostlyclean-tags:
 
clean-tags:
 
distclean-tags:
-rm -f TAGS ID
 
maintainer-clean-tags:
 
distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)
 
subdir = string
 
distdir: $(DISTFILES)
@for file in $(DISTFILES); do \
if test -f $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
cp -pr $$d/$$file $(distdir)/$$file; \
else \
test -f $(distdir)/$$file \
|| ln $$d/$$file $(distdir)/$$file 2> /dev/null \
|| cp -p $$d/$$file $(distdir)/$$file || :; \
fi; \
done
info-am:
info: info-am
dvi-am:
dvi: dvi-am
check-am:
check: check-am
installcheck-am:
installcheck: installcheck-am
install-info-am:
install-info: install-info-am
install-exec-am:
install-exec: install-exec-am
 
install-data-am:
install-data: install-data-am
 
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
install: install-am
uninstall-am:
uninstall: uninstall-am
all-am: Makefile $(LIBRARIES) $(LTLIBRARIES) $(DATA)
all-redirect: all-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install
installdirs:
 
 
mostlyclean-generic:
 
clean-generic:
-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
 
distclean-generic:
-rm -f Makefile $(CONFIG_CLEAN_FILES)
-rm -f config.cache config.log stamp-h stamp-h[0-9]*
 
maintainer-clean-generic:
mostlyclean-am: mostlyclean-noinstLIBRARIES mostlyclean-compile \
mostlyclean-libtool mostlyclean-noinstLTLIBRARIES \
mostlyclean-tags mostlyclean-generic
 
mostlyclean: mostlyclean-am
 
clean-am: clean-noinstLIBRARIES clean-compile clean-libtool \
clean-noinstLTLIBRARIES clean-tags clean-generic \
mostlyclean-am
 
clean: clean-am
 
distclean-am: distclean-noinstLIBRARIES distclean-compile \
distclean-libtool distclean-noinstLTLIBRARIES \
distclean-tags distclean-generic clean-am
-rm -f libtool
 
distclean: distclean-am
 
maintainer-clean-am: maintainer-clean-noinstLIBRARIES \
maintainer-clean-compile maintainer-clean-libtool \
maintainer-clean-noinstLTLIBRARIES \
maintainer-clean-tags maintainer-clean-generic \
distclean-am
@echo "This command is intended for maintainers to use;"
@echo "it deletes files that may require special tools to rebuild."
 
maintainer-clean: maintainer-clean-am
 
.PHONY: mostlyclean-noinstLIBRARIES distclean-noinstLIBRARIES \
clean-noinstLIBRARIES maintainer-clean-noinstLIBRARIES \
mostlyclean-compile distclean-compile clean-compile \
maintainer-clean-compile mostlyclean-libtool distclean-libtool \
clean-libtool maintainer-clean-libtool mostlyclean-noinstLTLIBRARIES \
distclean-noinstLTLIBRARIES clean-noinstLTLIBRARIES \
maintainer-clean-noinstLTLIBRARIES tags mostlyclean-tags distclean-tags \
clean-tags maintainer-clean-tags distdir info-am info dvi-am dvi check \
check-am installcheck-am installcheck install-info-am install-info \
install-exec-am install-exec install-data-am install-data install-am \
install uninstall-am uninstall all-redirect all-am all installdirs \
mostlyclean-generic distclean-generic clean-generic \
maintainer-clean-generic clean mostlyclean distclean maintainer-clean
 
 
objectlist.awk.in: $(noinst_LTLIBRARIES)
-rm -f objectlist.awk.in
for i in `ls *.lo` ; \
do \
echo $$i `pwd`/$$i >> objectlist.awk.in ; \
done
 
.c.def:
$(CHEW) < $< > $*.def 2> $*.ref
touch stmp-def
 
doc: $(CHEWOUT_FILES)
cat $(srcdir)/strings.tex >> $(TARGETDOC)
 
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
/strcasecmp.c
0,0 → 1,56
/*
FUNCTION
<<strcasecmp>>---case insensitive character string compare
INDEX
strcasecmp
 
ANSI_SYNOPSIS
#include <string.h>
int strcasecmp(const char *<[a]>, const char *<[b]>);
 
TRAD_SYNOPSIS
#include <string.h>
int strcasecmp(<[a]>, <[b]>)
char *<[a]>;
char *<[b]>;
 
DESCRIPTION
<<strcasecmp>> compares the string at <[a]> to
the string at <[b]> in a case-insensitive manner.
 
RETURNS
 
If <<*<[a]>>> sorts lexicographically after <<*<[b]>>> (after
both are converted to upper case), <<strcasecmp>> returns a
number greater than zero. If the two strings match,
<<strcasecmp>> returns zero. If <<*<[a]>>> sorts
lexicographically before <<*<[b]>>>, <<strcasecmp>> returns a
number less than zero.
 
PORTABILITY
<<strcasecmp>> is in the Berkeley Software Distribution.
 
<<strcasecmp>> requires no supporting OS subroutines. It uses
tolower() from elsewhere in this library.
 
QUICKREF
strcasecmp
*/
 
#include <string.h>
#include <ctype.h>
 
int
_DEFUN (strcasecmp, (s1, s2),
_CONST char *s1 _AND
_CONST char *s2)
{
while (*s1 != '\0' && tolower(*s1) == tolower(*s2))
{
s1++;
s2++;
}
 
return tolower(*(unsigned char *) s1) - tolower(*(unsigned char *) s2);
}
/u_strerr.c
0,0 → 1,8
#include <_ansi.h>
 
char *
_DEFUN(_user_strerror, (errnum),
int errnum)
{
return 0;
}
/strchr.c
0,0 → 1,108
/*
FUNCTION
<<strchr>>---search for character in string
 
INDEX
strchr
 
ANSI_SYNOPSIS
#include <string.h>
char * strchr(const char *<[string]>, int <[c]>);
 
TRAD_SYNOPSIS
#include <string.h>
char * strchr(<[string]>, <[c]>);
char *<[string]>;
int *<[c]>;
 
DESCRIPTION
This function finds the first occurence of <[c]> (converted to
a char) in the string pointed to by <[string]> (including the
terminating null character).
 
RETURNS
Returns a pointer to the located character, or a null pointer
if <[c]> does not occur in <[string]>.
 
PORTABILITY
<<strchr>> is ANSI C.
 
<<strchr>> requires no supporting OS subroutines.
 
QUICKREF
strchr ansi pure
*/
 
#include <string.h>
#include <limits.h>
 
/* Nonzero if X is not aligned on a "long" boundary. */
#define UNALIGNED(X) ((long)X & (sizeof (long) - 1))
 
/* How many bytes are loaded each iteration of the word copy loop. */
#define LBLOCKSIZE (sizeof (long))
 
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
/* Nonzero if X (a long int) contains a NULL byte. */
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif
 
/* DETECTCHAR returns nonzero if (long)X contains the byte used
to fill (long)MASK. */
#define DETECTCHAR(X,MASK) (DETECTNULL(X ^ MASK))
 
char *
_DEFUN (strchr, (s1, i),
_CONST char *s1 _AND
int i)
{
_CONST unsigned char *s = (_CONST unsigned char *)s1;
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
unsigned char c = (unsigned int)i;
 
while (*s && *s != c)
{
s++;
}
 
if (*s != c)
{
s = NULL;
}
 
return (char *) s;
#else
unsigned char c = (unsigned char)i;
unsigned long mask,j;
unsigned long *aligned_addr;
 
if (!UNALIGNED (s))
{
mask = 0;
for (j = 0; j < LBLOCKSIZE; j++)
mask = (mask << 8) | c;
 
aligned_addr = (unsigned long*)s;
while (!DETECTNULL (*aligned_addr) && !DETECTCHAR (*aligned_addr, mask))
aligned_addr++;
 
/* The block of bytes currently pointed to by aligned_addr
contains either a null or the target char, or both. We
catch it using the bytewise search. */
 
s = (unsigned char*)aligned_addr;
}
 
while (*s && *s != c)
s++;
if (*s == c)
return (char *)s;
return NULL;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/memmove.c
0,0 → 1,143
/*
FUNCTION
<<memmove>>---move possibly overlapping memory
 
INDEX
memmove
 
ANSI_SYNOPSIS
#include <string.h>
void *memmove(void *<[dst]>, const void *<[src]>, size_t <[length]>);
 
TRAD_SYNOPSIS
#include <string.h>
void *memmove(<[dst]>, <[src]>, <[length]>)
void *<[dst]>;
void *<[src]>;
size_t <[length]>;
 
DESCRIPTION
This function moves <[length]> characters from the block of
memory starting at <<*<[src]>>> to the memory starting at
<<*<[dst]>>>. <<memmove>> reproduces the characters correctly
at <<*<[dst]>>> even if the two areas overlap.
 
 
RETURNS
The function returns <[dst]> as passed.
 
PORTABILITY
<<memmove>> is ANSI C.
 
<<memmove>> requires no supporting OS subroutines.
 
QUICKREF
memmove ansi pure
*/
 
#include <string.h>
#include <_ansi.h>
#include <stddef.h>
#include <limits.h>
 
/* Nonzero if either X or Y is not aligned on a "long" boundary. */
#define UNALIGNED(X, Y) \
(((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))
 
/* How many bytes are copied each iteration of the 4X unrolled loop. */
#define BIGBLOCKSIZE (sizeof (long) << 2)
 
/* How many bytes are copied each iteration of the word copy loop. */
#define LITTLEBLOCKSIZE (sizeof (long))
 
/* Threshhold for punting to the byte copier. */
#define TOO_SMALL(LEN) ((LEN) < BIGBLOCKSIZE)
 
/*SUPPRESS 20*/
_PTR
_DEFUN (memmove, (dst_void, src_void, length),
_PTR dst_void _AND
_CONST _PTR src_void _AND
size_t length)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
char *dst = dst_void;
_CONST char *src = src_void;
 
if (src < dst && dst < src + length)
{
/* Have to copy backwards */
src += length;
dst += length;
while (length--)
{
*--dst = *--src;
}
}
else
{
while (length--)
{
*dst++ = *src++;
}
}
 
return dst_void;
#else
char *dst = dst_void;
_CONST char *src = src_void;
long *aligned_dst;
_CONST long *aligned_src;
int len = length;
 
if (src < dst && dst < src + len)
{
/* Destructive overlap...have to copy backwards */
src += len;
dst += len;
while (len--)
{
*--dst = *--src;
}
}
else
{
/* Use optimizing algorithm for a non-destructive copy to closely
match memcpy. If the size is small or either SRC or DST is unaligned,
then punt into the byte copy loop. This should be rare. */
if (!TOO_SMALL(len) && !UNALIGNED (src, dst))
{
aligned_dst = (long*)dst;
aligned_src = (long*)src;
 
/* Copy 4X long words at a time if possible. */
while (len >= BIGBLOCKSIZE)
{
*aligned_dst++ = *aligned_src++;
*aligned_dst++ = *aligned_src++;
*aligned_dst++ = *aligned_src++;
*aligned_dst++ = *aligned_src++;
len -= BIGBLOCKSIZE;
}
 
/* Copy one long word at a time if possible. */
while (len >= LITTLEBLOCKSIZE)
{
*aligned_dst++ = *aligned_src++;
len -= LITTLEBLOCKSIZE;
}
 
/* Pick up any residual with a byte copier. */
dst = (char*)aligned_dst;
src = (char*)aligned_src;
}
 
while (len--)
{
*dst++ = *src++;
}
}
 
return dst_void;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/index.c
0,0 → 1,44
/*
FUNCTION
<<index>>---search for character in string
 
INDEX
index
 
ANSI_SYNOPSIS
#include <string.h>
char * index(const char *<[string]>, int <[c]>);
 
TRAD_SYNOPSIS
#include <string.h>
char * index(<[string]>, <[c]>);
char *<[string]>;
int *<[c]>;
 
DESCRIPTION
This function finds the first occurence of <[c]> (converted to
a char) in the string pointed to by <[string]> (including the
terminating null character).
 
This function is identical to <<strchr>>.
 
RETURNS
Returns a pointer to the located character, or a null pointer
if <[c]> does not occur in <[string]>.
 
PORTABILITY
<<index>> requires no supporting OS subroutines.
 
QUICKREF
index - pure
*/
 
#include <string.h>
 
char *
_DEFUN (index, (s, c),
_CONST char *s _AND
int c)
{
return strchr (s, c);
}
/memchr.c
0,0 → 1,143
/*
FUNCTION
<<memchr>>---find character in memory
 
INDEX
memchr
 
ANSI_SYNOPSIS
#include <string.h>
void *memchr(const void *<[src]>, int <[c]>, size_t <[length]>);
 
TRAD_SYNOPSIS
#include <string.h>
void *memchr(<[src]>, <[c]>, <[length]>)
void *<[src]>;
void *<[c]>;
size_t <[length]>;
 
DESCRIPTION
This function searches memory starting at <<*<[src]>>> for the
character <[c]>. The search only ends with the first
occurrence of <[c]>, or after <[length]> characters; in
particular, <<NULL>> does not terminate the search.
 
RETURNS
If the character <[c]> is found within <[length]> characters
of <<*<[src]>>>, a pointer to the character is returned. If
<[c]> is not found, then <<NULL>> is returned.
 
PORTABILITY
<<memchr>>> is ANSI C.
 
<<memchr>> requires no supporting OS subroutines.
 
QUICKREF
memchr ansi pure
*/
 
#include <_ansi.h>
#include <string.h>
#include <limits.h>
 
/* Nonzero if either X or Y is not aligned on a "long" boundary. */
#define UNALIGNED(X) ((long)X & (sizeof (long) - 1))
 
/* How many bytes are loaded each iteration of the word copy loop. */
#define LBLOCKSIZE (sizeof (long))
 
/* Threshhold for punting to the bytewise iterator. */
#define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE)
 
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
/* Nonzero if X (a long int) contains a NULL byte. */
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif
 
#ifndef DETECTNULL
#error long int is not a 32bit or 64bit byte
#endif
 
 
_PTR
_DEFUN (memchr, (src_void, c, length),
_CONST _PTR src_void _AND
int c _AND
size_t length)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
_CONST unsigned char *src = (_CONST unsigned char *) src_void;
 
c &= 0xff;
while (length--)
{
if (*src == c)
return (char *) src;
src++;
}
return NULL;
#else
_CONST unsigned char *src = (_CONST unsigned char *) src_void;
unsigned long *asrc;
unsigned long buffer;
unsigned long mask;
int i, j;
 
c &= 0xff;
/* If the size is small, or src is unaligned, then
use the bytewise loop. We can hope this is rare. */
if (!TOO_SMALL (length) && !UNALIGNED (src))
{
/* The fast code reads the ASCII one word at a time and only
performs the bytewise search on word-sized segments if they
contain the search character, which is detected by XORing
the word-sized segment with a word-sized block of the search
character and then detecting for the presence of NULL in the
result. */
asrc = (unsigned long*) src;
mask = 0;
for (i = 0; i < LBLOCKSIZE; i++)
mask = (mask << 8) + c;
 
while (length >= LBLOCKSIZE)
{
buffer = *asrc;
buffer ^= mask;
if (DETECTNULL (buffer))
{
src = (unsigned char*) asrc;
for ( j = 0; j < LBLOCKSIZE; j++ )
{
if (*src == c)
return (char*) src;
src++;
}
}
length -= LBLOCKSIZE;
asrc++;
}
/* If there are fewer than LBLOCKSIZE characters left,
then we resort to the bytewise loop. */
 
src = (unsigned char*) asrc;
}
 
while (length--)
{
if (*src == c)
return (char*) src;
src++;
}
 
return NULL;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/bcopy.c
0,0 → 1,38
/*
FUNCTION
<<bcopy>>---copy memory regions
 
ANSI_SYNOPSIS
#include <string.h>
void bcopy(const char *<[in]>, char *<[out]>, size_t <[n]>);
 
TRAD_SYNOPSIS
void bcopy(<[in]>, <[out]>, <[n]>
char *<[in]>;
char *<[out]>;
size_t <[n]>;
 
DESCRIPTION
This function copies <[n]> bytes from the memory region
pointed to by <[in]> to the memory region pointed to by
<[out]>.
 
This function is implemented in term of <<memmove>>.
 
PORTABILITY
<<bcopy>> requires no supporting OS subroutines.
 
QUICKREF
bcopy - pure
*/
 
#include <string.h>
 
void
_DEFUN (bcopy, (b1, b2, length),
_CONST char *b1 _AND
char *b2 _AND
size_t length)
{
memmove ((_PTR) b2, (_PTR) b1, length);
}
/bcmp.c
0,0 → 1,50
/*
FUNCTION
<<bcmp>>---compare two memory areas
 
INDEX
bcmp
 
ANSI_SYNOPSIS
#include <string.h>
int bcmp(const char *<[s1]>, const char *<[s2]>, size_t <[n]>);
 
TRAD_SYNOPSIS
#include <string.h>
int bcmp(<[s1]>, <[s2]>, <[n]>)
char *<[s1]>;
char *<[s2]>;
size_t <[n]>;
 
DESCRIPTION
This function compares not more than <[n]> characters of the
object pointed to by <[s1]> with the object pointed to by <[s2]>.
 
This function is identical to <<memcmp>>.
 
 
RETURNS
The function returns an integer greater than, equal to or
less than zero according to whether the object pointed to by
<[s1]> is greater than, equal to or less than the object
pointed to by <[s2]>.
 
PORTABILITY
<<bcmp>> requires no supporting OS subroutines.
 
QUICKREF
bcmp ansi pure
*/
 
#include <string.h>
 
int
_DEFUN (bcmp, (m1, m2, n),
_CONST char *m1 _AND
_CONST char *m2 _AND
size_t n)
 
{
return memcmp (m1, m2, n);
}
/strerror.c
0,0 → 1,761
/***
**** CAUTION!!! KEEP DOC CONSISTENT---if you change text of a message
**** here, change two places:
**** 1) the leading doc section (alphabetized by macro)
**** 2) the real text inside switch(errnum)
***/
 
/*
FUNCTION
<<strerror>>---convert error number to string
 
INDEX
strerror
 
ANSI_SYNOPSIS
#include <string.h>
char *strerror(int <[errnum]>);
 
TRAD_SYNOPSIS
#include <string.h>
char *strerror(<[errnum]>)
int <[errnum]>;
 
DESCRIPTION
<<strerror>> converts the error number <[errnum]> into a
string. The value of <[errnum]> is usually a copy of <<errno>>.
If <<errnum>> is not a known error number, the result points to an
empty string.
 
This implementation of <<strerror>> prints out the following strings
for each of the values defined in `<<errno.h>>':
 
o+
o E2BIG
Arg list too long
 
o EACCES
Permission denied
 
o EADDRINUSE
Address already in use
 
o EADV
Advertise error
 
o EAFNOSUPPORT
Address family not supported by protocol family
 
o EAGAIN
No more processes
 
o EALREADY
Socket already connected
 
o EBADF
Bad file number
 
o EBADMSG
Bad message
 
o EBUSY
Device or resource busy
 
o ECHILD
No children
 
o ECOMM
Communication error
 
o ECONNABORTED
Software caused connection abort
 
o ECONNREFUSED
Connection refused
 
o EDEADLK
Deadlock
 
o EDESTADDRREQ
Destination address required
 
o EEXIST
File exists
 
o EDOM
Math argument
 
o EFAULT
Bad address
 
o EFBIG
File too large
 
o EHOSTDOWN
Host is down
 
o EHOSTUNREACH
Host is unreachable
 
o EIDRM
Identifier removed
 
o EINPROGRESS
Connection already in progress
 
o EINTR
Interrupted system call
 
o EINVAL
Invalid argument
 
o EIO
I/O error
 
o EISCONN
Socket is already connected
 
o EISDIR
Is a directory
 
o ELIBACC
Cannot access a needed shared library
 
o ELIBBAD
Accessing a corrupted shared library
 
o ELIBEXEC
Cannot exec a shared library directly
 
o ELIBMAX
Attempting to link in more shared libraries than system limit
 
o ELIBSCN
<<.lib>> section in a.out corrupted
 
o EMFILE
Too many open files
 
o EMLINK
Too many links
 
o EMSGSIZE
Message too long
 
o EMULTIHOP
Multihop attempted
 
o ENAMETOOLONG
File or path name too long
 
o ENETDOWN
Network interface not configured
 
o ENETUNREACH
Network is unreachable
 
o ENFILE
Too many open files in system
 
o ENODEV
No such device
 
o ENOENT
No such file or directory
 
o ENOEXEC
Exec format error
 
o ENOLCK
No lock
 
o ENOLINK
Virtual circuit is gone
 
o ENOMEM
Not enough space
 
o ENOMSG
No message of desired type
 
o ENONET
Machine is not on the network
 
o ENOPKG
No package
 
o ENOPROTOOPT
Protocol not available
 
o ENOSPC
No space left on device
 
o ENOSR
No stream resources
 
o ENOSTR
Not a stream
 
o ENOSYS
Function not implemented
 
o ENOTBLK
Block device required
 
o ENOTCONN
Socket is not connected
 
o ENOTDIR
Not a directory
 
o ENOTEMPTY
Directory not empty
 
o ENOTSOCK
Socket operation on non-socket
 
o ENOTSUP
Not supported
 
o ENOTTY
Not a character device
 
o ENXIO
No such device or address
 
o EPERM
Not owner
 
o EPIPE
Broken pipe
 
o EPROTO
Protocol error
 
o EPROTOTYPE
Protocol wrong type for socket
 
o EPROTONOSUPPORT
Unknown protocol
 
o ERANGE
Result too large
 
o EREMOTE
Resource is remote
 
o EROFS
Read-only file system
 
o ESHUTDOWN
Can't send after socket shutdown
 
o ESOCKTNOSUPPORT
Socket type not supported
 
o ESPIPE
Illegal seek
 
o ESRCH
No such process
 
o ESRMNT
Srmount error
 
o ETIME
Stream ioctl timeout
 
o ETIMEDOUT
Connection timed out
 
o ETXTBSY
Text file busy
 
o EXDEV
Cross-device link
 
o-
 
RETURNS
This function returns a pointer to a string. Your application must
not modify that string.
 
PORTABILITY
ANSI C requires <<strerror>>, but does not specify the strings used
for each error number.
 
Although this implementation of <<strerror>> is reentrant, ANSI C
declares that subsequent calls to <<strerror>> may overwrite the
result string; therefore portable code cannot depend on the reentrancy
of this subroutine.
 
This implementation of <<strerror>> provides for user-defined
extensibility. <<errno.h>> defines <[__ELASTERROR]>, which can be
used as a base for user-defined error values. If the user supplies a
routine named <<_user_strerror>>, and <[errnum]> passed to
<<strerror>> does not match any of the supported values,
<<_user_strerror>> is called with <[errnum]> as its argument.
 
<<_user_strerror>> takes one argument of type <[int]>, and returns a
character pointer. If <[errnum]> is unknown to <<_user_strerror>>,
<<_user_strerror>> returns <[NULL]>. The default <<_user_strerror>>
returns <[NULL]> for all input values.
 
<<strerror>> requires no supporting OS subroutines.
 
QUICKREF
strerror ansi pure
*/
 
#include <errno.h>
#include <string.h>
 
char *
_DEFUN (strerror, (errnum),
int errnum)
{
char *error;
extern char *_user_strerror _PARAMS ((int));
 
switch (errnum)
{
/* go32 defines EPERM as EACCES */
#if defined (EPERM) && (!defined (EACCES) || (EPERM != EACCES))
case EPERM:
error = "Not owner";
break;
#endif
#ifdef ENOENT
case ENOENT:
error = "No such file or directory";
break;
#endif
#ifdef ESRCH
case ESRCH:
error = "No such process";
break;
#endif
#ifdef EINTR
case EINTR:
error = "Interrupted system call";
break;
#endif
#ifdef EIO
case EIO:
error = "I/O error";
break;
#endif
/* go32 defines ENXIO as ENODEV */
#if defined (ENXIO) && (!defined (ENODEV) || (ENXIO != ENODEV))
case ENXIO:
error = "No such device or address";
break;
#endif
#ifdef E2BIG
case E2BIG:
error = "Arg list too long";
break;
#endif
#ifdef ENOEXEC
case ENOEXEC:
error = "Exec format error";
break;
#endif
#ifdef EALREADY
case EALREADY:
error = "Socket already connected";
break;
#endif
#ifdef EBADF
case EBADF:
error = "Bad file number";
break;
#endif
#ifdef ECHILD
case ECHILD:
error = "No children";
break;
#endif
#ifdef EDESTADDRREQ
case EDESTADDRREQ:
error = "Destination address required";
break;
#endif
#ifdef EAGAIN
case EAGAIN:
error = "No more processes";
break;
#endif
#ifdef ENOMEM
case ENOMEM:
error = "Not enough space";
break;
#endif
#ifdef EACCES
case EACCES:
error = "Permission denied";
break;
#endif
#ifdef EFAULT
case EFAULT:
error = "Bad address";
break;
#endif
#ifdef ENOTBLK
case ENOTBLK:
error = "Block device required";
break;
#endif
#ifdef EBUSY
case EBUSY:
error = "Device or resource busy";
break;
#endif
#ifdef EEXIST
case EEXIST:
error = "File exists";
break;
#endif
#ifdef EXDEV
case EXDEV:
error = "Cross-device link";
break;
#endif
#ifdef ENODEV
case ENODEV:
error = "No such device";
break;
#endif
#ifdef ENOTDIR
case ENOTDIR:
error = "Not a directory";
break;
#endif
#ifdef EHOSTDOWN
case EHOSTDOWN:
error = "Host is down";
break;
#endif
#ifdef EINPROGRESS
case EINPROGRESS:
error = "Connection already in progress";
break;
#endif
#ifdef EISDIR
case EISDIR:
error = "Is a directory";
break;
#endif
#ifdef EINVAL
case EINVAL:
error = "Invalid argument";
break;
#endif
#ifdef ENETDOWN
case ENETDOWN:
error = "Network interface is not configured";
break;
#endif
#ifdef ENFILE
case ENFILE:
error = "Too many open files in system";
break;
#endif
#ifdef EMFILE
case EMFILE:
error = "Too many open files";
break;
#endif
#ifdef ENOTTY
case ENOTTY:
error = "Not a character device";
break;
#endif
#ifdef ETXTBSY
case ETXTBSY:
error = "Text file busy";
break;
#endif
#ifdef EFBIG
case EFBIG:
error = "File too large";
break;
#endif
#ifdef EHOSTUNREACH
case EHOSTUNREACH:
error = "Host is unreachable";
break;
#endif
#ifdef ENOSPC
case ENOSPC:
error = "No space left on device";
break;
#endif
#ifdef ENOTSUP
case ENOTSUP:
error = "Not supported";
break;
#endif
#ifdef ESPIPE
case ESPIPE:
error = "Illegal seek";
break;
#endif
#ifdef EROFS
case EROFS:
error = "Read-only file system";
break;
#endif
#ifdef EMLINK
case EMLINK:
error = "Too many links";
break;
#endif
#ifdef EPIPE
case EPIPE:
error = "Broken pipe";
break;
#endif
#ifdef EDOM
case EDOM:
error = "Math argument";
break;
#endif
#ifdef ERANGE
case ERANGE:
error = "Result too large";
break;
#endif
#ifdef ENOMSG
case ENOMSG:
error = "No message of desired type";
break;
#endif
#ifdef EIDRM
case EIDRM:
error = "Identifier removed";
break;
#endif
#ifdef EDEADLK
case EDEADLK:
error = "Deadlock";
break;
#endif
#ifdef ENETUNREACH
case ENETUNREACH:
error = "Network is unreachable";
break;
#endif
#ifdef ENOLCK
case ENOLCK:
error = "No lock";
break;
#endif
#ifdef ENOSTR
case ENOSTR:
error = "Not a stream";
break;
#endif
#ifdef ETIME
case ETIME:
error = "Stream ioctl timeout";
break;
#endif
#ifdef ENOSR
case ENOSR:
error = "No stream resources";
break;
#endif
#ifdef ENONET
case ENONET:
error = "Machine is not on the network";
break;
#endif
#ifdef ENOPKG
case ENOPKG:
error = "No package";
break;
#endif
#ifdef EREMOTE
case EREMOTE:
error = "Resource is remote";
break;
#endif
#ifdef ENOLINK
case ENOLINK:
error = "Virtual circuit is gone";
break;
#endif
#ifdef EADV
case EADV:
error = "Advertise error";
break;
#endif
#ifdef ESRMNT
case ESRMNT:
error = "Srmount error";
break;
#endif
#ifdef ECOMM
case ECOMM:
error = "Communication error";
break;
#endif
#ifdef EPROTO
case EPROTO:
error = "Protocol error";
break;
#endif
#ifdef EPROTONOSUPPORT
case EPROTONOSUPPORT:
error = "Unknown protocol";
break;
#endif
#ifdef EMULTIHOP
case EMULTIHOP:
error = "Multihop attempted";
break;
#endif
#ifdef EBADMSG
case EBADMSG:
error = "Bad message";
break;
#endif
#ifdef ELIBACC
case ELIBACC:
error = "Cannot access a needed shared library";
break;
#endif
#ifdef ELIBBAD
case ELIBBAD:
error = "Accessing a corrupted shared library";
break;
#endif
#ifdef ELIBSCN
case ELIBSCN:
error = ".lib section in a.out corrupted";
break;
#endif
#ifdef ELIBMAX
case ELIBMAX:
error = "Attempting to link in more shared libraries than system limit";
break;
#endif
#ifdef ELIBEXEC
case ELIBEXEC:
error = "Cannot exec a shared library directly";
break;
#endif
#ifdef ENOSYS
case ENOSYS:
error = "Function not implemented";
break;
#endif
#ifdef ENMFILE
case ENMFILE:
error = "No more files";
break;
#endif
#ifdef ENOTEMPTY
case ENOTEMPTY:
error = "Directory not empty";
break;
#endif
#ifdef ENAMETOOLONG
case ENAMETOOLONG:
error = "File or path name too long";
break;
#endif
#ifdef ELOOP
case ELOOP:
error = "Too many symbolic links";
break;
#endif
#ifdef ENOBUFS
case ENOBUFS:
error = "No buffer space available";
break;
#endif
#ifdef EAFNOSUPPORT
case EAFNOSUPPORT:
error = "Address family not supported by protocol family";
break;
#endif
#ifdef EPROTOTYPE
case EPROTOTYPE:
error = "Protocol wrong type for socket";
break;
#endif
#ifdef ENOTSOCK
case ENOTSOCK:
error = "Socket operation on non-socket";
break;
#endif
#ifdef ENOPROTOOPT
case ENOPROTOOPT:
error = "Protocol not available";
break;
#endif
#ifdef ESHUTDOWN
case ESHUTDOWN:
error = "Can't send after socket shutdown";
break;
#endif
#ifdef ECONNREFUSED
case ECONNREFUSED:
error = "Connection refused";
break;
#endif
#ifdef EADDRINUSE
case EADDRINUSE:
error = "Address already in use";
break;
#endif
#ifdef ECONNABORTED
case ECONNABORTED:
error = "Software caused connection abort";
break;
#endif
#if (defined(EWOULDBLOCK) && (!defined (EAGAIN) || (EWOULDBLOCK != EAGAIN)))
case EWOULDBLOCK:
error = "Operation would block";
break;
#endif
#ifdef ENOTCONN
case ENOTCONN:
error = "Socket is not connected";
break;
#endif
#ifdef ESOCKTNOSUPPORT
case ESOCKTNOSUPPORT:
error = "Socket type not supported";
break;
#endif
#ifdef EISCONN
case EISCONN:
error = "Socket is already connected";
break;
#endif
#ifdef EOPNOTSUPP
case EOPNOTSUPP:
error = "Operation not supported on socket";
break;
#endif
#ifdef EMSGSIZE
case EMSGSIZE:
error = "Message too long";
break;
#endif
#ifdef ETIMEDOUT
case ETIMEDOUT:
error = "Connection timed out";
break;
#endif
default:
if ((error = _user_strerror (errnum)) == 0)
error = "";
break;
}
 
return error;
}
/strncasecmp.c
0,0 → 1,64
/*
FUNCTION
<<strncasecmp>>---case insensitive character string compare
INDEX
strncasecmp
 
ANSI_SYNOPSIS
#include <string.h>
int strncasecmp(const char *<[a]>, const char * <[b]>, size_t <[length]>);
 
TRAD_SYNOPSIS
#include <string.h>
int strncasecmp(<[a]>, <[b]>, <[length]>)
char *<[a]>;
char *<[b]>;
size_t <[length]>
 
DESCRIPTION
<<strncasecmp>> compares up to <[length]> characters
from the string at <[a]> to the string at <[b]> in a
case-insensitive manner.
 
RETURNS
 
If <<*<[a]>>> sorts lexicographically after <<*<[b]>>> (after
both are converted to upper case), <<strncasecmp>> returns a
number greater than zero. If the two strings are equivalent,
<<strncasecmp>> returns zero. If <<*<[a]>>> sorts
lexicographically before <<*<[b]>>>, <<strncasecmp>> returns a
number less than zero.
 
PORTABILITY
<<strncasecmp>> is in the Berkeley Software Distribution.
 
<<strncasecmp>> requires no supporting OS subroutines. It uses
tolower() from elsewhere in this library.
 
QUICKREF
strncasecmp
*/
 
#include <string.h>
#include <ctype.h>
 
int
_DEFUN (strncasecmp, (s1, s2, n),
_CONST char *s1 _AND
_CONST char *s2 _AND
size_t n)
{
if (n == 0)
return 0;
 
while (n-- != 0 && tolower(*s1) == tolower(*s2))
{
if (n == 0 || *s1 == '\0' || *s2 == '\0')
break;
s1++;
s2++;
}
 
return tolower(*(unsigned char *) s1) - tolower(*(unsigned char *) s2);
}
/strcpy.c
0,0 → 1,99
/*
FUNCTION
<<strcpy>>---copy string
 
INDEX
strcpy
 
ANSI_SYNOPSIS
#include <string.h>
char *strcpy(char *<[dst]>, const char *<[src]>);
 
TRAD_SYNOPSIS
#include <string.h>
char *strcpy(<[dst]>, <[src]>)
char *<[dst]>;
char *<[src]>;
 
DESCRIPTION
<<strcpy>> copies the string pointed to by <[src]>
(including the terminating null character) to the array
pointed to by <[dst]>.
 
RETURNS
This function returns the initial value of <[dst]>.
 
PORTABILITY
<<strcpy>> is ANSI C.
 
<<strcpy>> requires no supporting OS subroutines.
 
QUICKREF
strcpy ansi pure
*/
 
#include <string.h>
#include <limits.h>
 
/*SUPPRESS 560*/
/*SUPPRESS 530*/
 
/* Nonzero if either X or Y is not aligned on a "long" boundary. */
#define UNALIGNED(X, Y) \
(((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))
 
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
/* Nonzero if X (a long int) contains a NULL byte. */
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif
 
#ifndef DETECTNULL
#error long int is not a 32bit or 64bit byte
#endif
 
char*
_DEFUN (strcpy, (dst0, src0),
char *dst0 _AND
_CONST char *src0)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
char *s = dst0;
 
while (*dst0++ = *src0++)
;
 
return s;
#else
char *dst = dst0;
_CONST char *src = src0;
long *aligned_dst;
_CONST long *aligned_src;
 
/* If SRC or DEST is unaligned, then copy bytes. */
if (!UNALIGNED (src, dst))
{
aligned_dst = (long*)dst;
aligned_src = (long*)src;
 
/* SRC and DEST are both "long int" aligned, try to do "long int"
sized copies. */
while (!DETECTNULL(*aligned_src))
{
*aligned_dst++ = *aligned_src++;
}
 
dst = (char*)aligned_dst;
src = (char*)aligned_src;
}
 
while (*dst++ = *src++)
;
return dst0;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/strpbrk.c
0,0 → 1,58
/*
FUNCTION
<<strpbrk>>---find chars in string
 
INDEX
strpbrk
 
ANSI_SYNOPSIS
#include <string.h>
char *strpbrk(const char *<[s1]>, const char *<[s2]>);
 
TRAD_SYNOPSIS
#include <string.h>
char *strpbrk(<[s1]>, <[s2]>)
char *<[s1]>;
char *<[s2]>;
 
DESCRIPTION
This function locates the first occurence in the string
pointed to by <[s1]> of any character in string pointed to by
<[s2]> (excluding the terminating null character).
 
RETURNS
<<strpbrk>> returns a pointer to the character found in <[s1]>, or a
null pointer if no character from <[s2]> occurs in <[s1]>.
 
PORTABILITY
<<strpbrk>> requires no supporting OS subroutines.
*/
 
#include <string.h>
 
char *
_DEFUN (strpbrk, (s1, s2),
_CONST char *s1 _AND
_CONST char *s2)
{
_CONST char *c = s2;
if (!*s1)
return (char *) NULL;
 
while (*s1)
{
for (c = s2; *c; c++)
{
if (*s1 == *c)
break;
}
if (*c)
break;
s1++;
}
 
if (*c == '\0')
s1 = NULL;
 
return (char *) s1;
}
/strrchr.c
0,0 → 1,59
/*
FUNCTION
<<strrchr>>---reverse search for character in string
 
INDEX
strrchr
 
ANSI_SYNOPSIS
#include <string.h>
char * strrchr(const char *<[string]>, int <[c]>);
 
TRAD_SYNOPSIS
#include <string.h>
char * strrchr(<[string]>, <[c]>);
char *<[string]>;
int *<[c]>;
 
DESCRIPTION
This function finds the last occurence of <[c]> (converted to
a char) in the string pointed to by <[string]> (including the
terminating null character).
 
RETURNS
Returns a pointer to the located character, or a null pointer
if <[c]> does not occur in <[string]>.
 
PORTABILITY
<<strrchr>> is ANSI C.
 
<<strrchr>> requires no supporting OS subroutines.
 
QUICKREF
strrchr ansi pure
*/
 
#include <string.h>
 
char *
_DEFUN (strrchr, (s, i),
_CONST char *s _AND
int i)
{
_CONST char *last = NULL;
 
if (i)
{
while (s=strchr(s, i))
{
last = s;
s++;
}
}
else
{
last = strchr(s, i);
}
return (char *) last;
}
/strspn.c
0,0 → 1,59
/*
FUNCTION
<<strspn>>---find initial match
 
INDEX
strspn
 
ANSI_SYNOPSIS
#include <string.h>
size_t strspn(const char *<[s1]>, const char *<[s2]>);
 
TRAD_SYNOPSIS
#include <string.h>
size_t strspn(<[s1]>, <[s2]>)
char *<[s1]>;
char *<[s2]>;
 
DESCRIPTION
This function computes the length of the initial segment of
the string pointed to by <[s1]> which consists entirely of
characters from the string pointed to by <[s2]> (excluding the
terminating null character).
 
RETURNS
<<strspn>> returns the length of the segment found.
 
PORTABILITY
<<strspn>> is ANSI C.
 
<<strspn>> requires no supporting OS subroutines.
 
QUICKREF
strspn ansi pure
*/
 
#include <string.h>
 
size_t
_DEFUN (strspn, (s1, s2),
_CONST char *s1 _AND
_CONST char *s2)
{
_CONST char *s = s1;
_CONST char *c;
 
while (*s1)
{
for (c = s2; *c; c++)
{
if (*s1 == *c)
break;
}
if (*c == '\0')
break;
s1++;
}
 
return s1 - s;
}
/memcpy.c
0,0 → 1,111
/*
FUNCTION
<<memcpy>>---copy memory regions
 
ANSI_SYNOPSIS
#include <string.h>
void* memcpy(void *<[out]>, const void *<[in]>, size_t <[n]>);
 
TRAD_SYNOPSIS
void *memcpy(<[out]>, <[in]>, <[n]>
void *<[out]>;
void *<[in]>;
size_t <[n]>;
 
DESCRIPTION
This function copies <[n]> bytes from the memory region
pointed to by <[in]> to the memory region pointed to by
<[out]>.
 
If the regions overlap, the behavior is undefined.
 
RETURNS
<<memcpy>> returns a pointer to the first byte of the <[out]>
region.
 
PORTABILITY
<<memcpy>> is ANSI C.
 
<<memcpy>> requires no supporting OS subroutines.
 
QUICKREF
memcpy ansi pure
*/
 
#include <_ansi.h>
#include <stddef.h>
#include <limits.h>
 
/* Nonzero if either X or Y is not aligned on a "long" boundary. */
#define UNALIGNED(X, Y) \
(((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))
 
/* How many bytes are copied each iteration of the 4X unrolled loop. */
#define BIGBLOCKSIZE (sizeof (long) << 2)
 
/* How many bytes are copied each iteration of the word copy loop. */
#define LITTLEBLOCKSIZE (sizeof (long))
 
/* Threshhold for punting to the byte copier. */
#define TOO_SMALL(LEN) ((LEN) < BIGBLOCKSIZE)
 
_PTR
_DEFUN (memcpy, (dst0, src0, len0),
_PTR dst0 _AND
_CONST _PTR src0 _AND
size_t len0)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
char *dst = (char *) dst0;
char *src = (char *) src0;
 
_PTR save = dst0;
 
while (len0--)
{
*dst++ = *src++;
}
 
return save;
#else
char *dst = dst0;
_CONST char *src = src0;
long *aligned_dst;
_CONST long *aligned_src;
int len = len0;
 
/* If the size is small, or either SRC or DST is unaligned,
then punt into the byte copy loop. This should be rare. */
if (!TOO_SMALL(len) && !UNALIGNED (src, dst))
{
aligned_dst = (long*)dst;
aligned_src = (long*)src;
 
/* Copy 4X long words at a time if possible. */
while (len >= BIGBLOCKSIZE)
{
*aligned_dst++ = *aligned_src++;
*aligned_dst++ = *aligned_src++;
*aligned_dst++ = *aligned_src++;
*aligned_dst++ = *aligned_src++;
len -= BIGBLOCKSIZE;
}
 
/* Copy one long word at a time if possible. */
while (len >= LITTLEBLOCKSIZE)
{
*aligned_dst++ = *aligned_src++;
len -= LITTLEBLOCKSIZE;
}
 
/* Pick up any residual with a byte copier. */
dst = (char*)aligned_dst;
src = (char*)aligned_src;
}
 
while (len--)
*dst++ = *src++;
 
return dst0;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/strupr.c
0,0 → 1,49
/*
FUNCTION
<<strupr>>---force string to uppercase
INDEX
strupr
 
ANSI_SYNOPSIS
#include <string.h>
char *strupr(char *<[a]>);
 
TRAD_SYNOPSIS
#include <string.h>
char *strupr(<[a]>)
char *<[a]>;
 
DESCRIPTION
<<strupr>> converts each characters in the string at <[a]> to
upper case.
 
RETURNS
<<strupr>> returns its argument, <[a]>.
 
PORTABILITY
<<strupr>> is not widely portable.
 
<<strupr>> requires no supporting OS subroutines.
 
QUICKREF
strupr */
 
#include <string.h>
#include <ctype.h>
 
char *
strupr (a)
char *a;
{
char *ret = a;
 
while (*a != '\0')
{
if (islower (*a))
*a = toupper (*a);
++a;
}
 
return ret;
}
/strcat.c
0,0 → 1,104
/*
FUNCTION
<<strcat>>---concatenate strings
 
INDEX
strcat
 
ANSI_SYNOPSIS
#include <string.h>
char *strcat(char *<[dst]>, const char *<[src]>);
 
TRAD_SYNOPSIS
#include <string.h>
char *strcat(<[dst]>, <[src]>)
char *<[dst]>;
char *<[src]>;
 
DESCRIPTION
<<strcat>> appends a copy of the string pointed to by <[src]>
(including the terminating null character) to the end of the
string pointed to by <[dst]>. The initial character of
<[src]> overwrites the null character at the end of <[dst]>.
 
RETURNS
This function returns the initial value of <[dst]>
 
PORTABILITY
<<strcat>> is ANSI C.
 
<<strcat>> requires no supporting OS subroutines.
 
QUICKREF
strcat ansi pure
*/
 
#include <string.h>
#include <limits.h>
 
/* Nonzero if X is aligned on a "long" boundary. */
#define ALIGNED(X) \
(((long)X & (sizeof (long) - 1)) == 0)
 
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
/* Nonzero if X (a long int) contains a NULL byte. */
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif
 
#ifndef DETECTNULL
#error long int is not a 32bit or 64bit byte
#endif
 
 
/*SUPPRESS 560*/
/*SUPPRESS 530*/
 
char *
_DEFUN (strcat, (s1, s2),
char *s1 _AND
_CONST char *s2)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
char *s = s1;
 
while (*s1)
s1++;
 
while (*s1++ = *s2++)
;
return s;
#else
char *s = s1;
 
 
/* Skip over the data in s1 as quickly as possible. */
if (ALIGNED (s1))
{
unsigned long *aligned_s1 = (unsigned long *)s1;
while (!DETECTNULL (*aligned_s1))
aligned_s1++;
 
s1 = (char *)aligned_s1;
}
 
while (*s1)
s1++;
 
/* s1 now points to the its trailing null character, we can
just use strcpy to do the work for us now.
 
?!? We might want to just include strcpy here.
Also, this will cause many more unaligned string copies because
s1 is much less likely to be aligned. I don't know if its worth
tweaking strcpy to handle this better. */
strcpy (s1, s2);
return s;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/strstr.c
0,0 → 1,73
/*
FUNCTION
<<strstr>>---find string segment
 
INDEX
strstr
 
ANSI_SYNOPSIS
#include <string.h>
char *strstr(const char *<[s1]>, const char *<[s2]>);
 
TRAD_SYNOPSIS
#include <string.h>
char *strstr(<[s1]>, <[s2]>)
char *<[s1]>;
char *<[s2]>;
 
DESCRIPTION
Locates the first occurence in the string pointed to by <[s1]> of
the sequence of characters in the string pointed to by <[s2]>
(excluding the terminating null character).
 
RETURNS
Returns a pointer to the located string segment, or a null
pointer if the string <[s2]> is not found. If <[s2]> points to
a string with zero length, the <[s1]> is returned.
 
PORTABILITY
<<strstr>> is ANSI C.
 
<<strstr>> requires no supporting OS subroutines.
 
QUICKREF
strstr ansi pure
*/
 
#include <string.h>
 
char *
_DEFUN (strstr, (searchee, lookfor),
_CONST char *searchee _AND
_CONST char *lookfor)
{
if (*searchee == 0)
{
if (*lookfor)
return (char *) NULL;
return (char *) searchee;
}
 
while (*searchee)
{
size_t i;
i = 0;
 
while (1)
{
if (lookfor[i] == 0)
{
return (char *) searchee;
}
 
if (lookfor[i] != searchee[i])
{
break;
}
i++;
}
searchee++;
}
 
return (char *) NULL;
}
/strncpy.c
0,0 → 1,125
/*
FUNCTION
<<strncpy>>---counted copy string
 
INDEX
strncpy
 
ANSI_SYNOPSIS
#include <string.h>
char *strncpy(char *<[dst]>, const char *<[src]>, size_t <[length]>);
 
TRAD_SYNOPSIS
#include <string.h>
char *strncpy(<[dst]>, <[src]>, <[length]>)
char *<[dst]>;
char *<[src]>;
size_t <[length]>;
 
DESCRIPTION
<<strncpy>> copies not more than <[length]> characters from the
the string pointed to by <[src]> (including the terminating
null character) to the array pointed to by <[dst]>. If the
string pointed to by <[src]> is shorter than <[length]>
characters, null characters are appended to the destination
array until a total of <[length]> characters have been
written.
 
RETURNS
This function returns the initial value of <[dst]>.
 
PORTABILITY
<<strncpy>> is ANSI C.
 
<<strncpy>> requires no supporting OS subroutines.
 
QUICKREF
strncpy ansi pure
*/
 
#include <string.h>
#include <limits.h>
 
/*SUPPRESS 560*/
/*SUPPRESS 530*/
 
/* Nonzero if either X or Y is not aligned on a "long" boundary. */
#define UNALIGNED(X, Y) \
(((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))
 
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
/* Nonzero if X (a long int) contains a NULL byte. */
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif
 
#ifndef DETECTNULL
#error long int is not a 32bit or 64bit byte
#endif
 
#define TOO_SMALL(LEN) ((LEN) < sizeof (long))
 
char *
_DEFUN (strncpy, (dst0, src0),
char *dst0 _AND
_CONST char *src0 _AND
size_t count)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
char *dscan;
_CONST char *sscan;
 
dscan = dst0;
sscan = src0;
while (count > 0)
{
--count;
if ((*dscan++ = *sscan++) == '\0')
break;
}
while (count-- > 0)
*dscan++ = '\0';
 
return dst0;
#else
char *dst = dst0;
_CONST char *src = src0;
long *aligned_dst;
_CONST long *aligned_src;
 
/* If SRC and DEST is aligned and count large enough, then copy words. */
if (!UNALIGNED (src, dst) && !TOO_SMALL (count))
{
aligned_dst = (long*)dst;
aligned_src = (long*)src;
 
/* SRC and DEST are both "long int" aligned, try to do "long int"
sized copies. */
while (count >= sizeof (long int) && !DETECTNULL(*aligned_src))
{
count -= sizeof (long int);
*aligned_dst++ = *aligned_src++;
}
 
dst = (char*)aligned_dst;
src = (char*)aligned_src;
}
 
while (count > 0)
{
--count;
if ((*dst++ = *src++) == '\0')
break;
}
 
while (count-- > 0)
*dst++ = '\0';
 
return dst0;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/strxfrm.c
0,0 → 1,75
/*
FUNCTION
<<strxfrm>>---transform string
 
INDEX
strxfrm
 
ANSI_SYNOPSIS
#include <string.h>
size_t strxfrm(char *<[s1]>, const char *<[s2]>, size_t <[n]>);
 
TRAD_SYNOPSIS
#include <string.h>
size_t strxfrm(<[s1]>, <[s2]>, <[n]>);
char *<[s1]>;
char *<[s2]>;
size_t <[n]>;
 
DESCRIPTION
This function transforms the string pointed to by <[s2]> and
places the resulting string into the array pointed to by
<[s1]>. The transformation is such that if the <<strcmp>>
function is applied to the two transformed strings, it returns
a value greater than, equal to, or less than zero,
correspoinding to the result of a <<strcoll>> function applied
to the same two original strings.
 
No more than <[n]> characters are placed into the resulting
array pointed to by <[s1]>, including the terminating null
character. If <[n]> is zero, <[s1]> may be a null pointer. If
copying takes place between objects that overlap, the behavior
is undefined.
 
With a C locale, this function just copies.
 
RETURNS
The <<strxfrm>> function returns the length of the transformed string
(not including the terminating null character). If the value returned
is <[n]> or more, the contents of the array pointed to by
<[s1]> are indeterminate.
 
PORTABILITY
<<strxfrm>> is ANSI C.
 
<<strxfrm>> requires no supporting OS subroutines.
 
QUICKREF
strxfrm ansi pure
*/
 
#include <string.h>
 
size_t
_DEFUN (strxfrm, (s1, s2, n),
char *s1 _AND
_CONST char *s2 _AND
size_t n)
{
size_t res;
res = 0;
while (n-- > 0)
{
if ((*s1++ = *s2++) != '\0')
++res;
else
return res;
}
while (*s2)
{
++s2;
++res;
}
 
return res;
}
/strtok_r.c
0,0 → 1,85
/*
* Copyright (c) 1988 Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
 
#include <string.h>
 
char *
_DEFUN (strtok_r, (s, delim, lasts),
register char *s _AND
register const char *delim _AND
char **lasts)
{
register char *spanp;
register int c, sc;
char *tok;
 
 
if (s == NULL && (s = *lasts) == NULL)
return (NULL);
 
/*
* Skip (span) leading delimiters (s += strspn(s, delim), sort of).
*/
cont:
c = *s++;
for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
if (c == sc)
goto cont;
}
 
if (c == 0) { /* no non-delimiter characters */
*lasts = NULL;
return (NULL);
}
tok = s - 1;
 
/*
* Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
* Note that delim must have one NUL; we stop if we see that, too.
*/
for (;;) {
c = *s++;
spanp = (char *)delim;
do {
if ((sc = *spanp++) == c) {
if (c == 0)
s = NULL;
else
s[-1] = 0;
*lasts = s;
return (tok);
}
} while (sc != 0);
}
/* NOTREACHED */
}
/strings.tex
0,0 → 1,137
@node Strings
@chapter Strings and Memory (@file{string.h})
 
This chapter describes string-handling functions and functions for
managing areas of memory. The corresponding declarations are in
@file{string.h}.
 
@menu
* bcmp:: Compare two memory areas
* bcopy:: Copy memory regions
* bzero:: Initialize memory to zero
* index:: Search for character in string
* memchr:: Find character in memory
* memcmp:: Compare two memory areas
* memcpy:: Copy memory regions
* memmove:: Move possibly overlapping memory
* memset:: Set an area of memory
* rindex:: Reverse search for character in string
* strcasecmp:: Compare strings ignoring case
* strcat:: Concatenate strings
* strchr:: Search for character in string
* strcmp:: Character string compare
* strcoll:: Locale specific character string compare
* strcpy:: Copy string
* strcspn:: Count chars not in string
* strerror:: Convert error number to string
* strlen:: Character string length
* strlwr:: Convert string to lower case
* strncasecmp:: Compare strings ignoring case
* strncat:: Concatenate strings
* strncmp:: Character string compare
* strncpy:: Counted copy string
* strpbrk:: Find chars in string
* strrchr:: Reverse search for character in string
* strspn:: Find initial match
* strstr:: Find string segment
* strtok:: Get next token from a string
* strupr:: Convert string to upper case
* strxfrm:: Transform string
* swab:: Swap adjacent bytes
@end menu
 
@page
@include string/bcmp.def
 
@page
@include string/bcopy.def
 
@page
@include string/bzero.def
 
@page
@include string/index.def
 
@page
@include string/memchr.def
 
@page
@include string/memcmp.def
 
@page
@include string/memcpy.def
 
@page
@include string/memmove.def
 
@page
@include string/memset.def
 
@page
@include string/rindex.def
 
@page
@include string/strcasecmp.def
 
@page
@include string/strcat.def
 
@page
@include string/strchr.def
 
@page
@include string/strcmp.def
 
@page
@include string/strcoll.def
 
@page
@include string/strcpy.def
 
@page
@include string/strcspn.def
 
@page
@include string/strerror.def
 
@page
@include string/strlen.def
 
@page
@include string/strlwr.def
 
@page
@include string/strncasecmp.def
 
@page
@include string/strncat.def
 
@page
@include string/strncmp.def
 
@page
@include string/strncpy.def
 
@page
@include string/strpbrk.def
 
@page
@include string/strrchr.def
 
@page
@include string/strspn.def
 
@page
@include string/strstr.def
 
@page
@include string/strtok.def
 
@page
@include string/strupr.def
 
@page
@include string/strxfrm.def
 
@page
@include string/swab.def
/strlen.c
0,0 → 1,88
/*
FUNCTION
<<strlen>>---character string length
INDEX
strlen
 
ANSI_SYNOPSIS
#include <string.h>
size_t strlen(const char *<[str]>);
 
TRAD_SYNOPSIS
#include <string.h>
size_t strlen(<[str]>)
char *<[src]>;
 
DESCRIPTION
The <<strlen>> function works out the length of the string
starting at <<*<[str]>>> by counting chararacters until it
reaches a <<NULL>> character.
 
RETURNS
<<strlen>> returns the character count.
 
PORTABILITY
<<strlen>> is ANSI C.
 
<<strlen>> requires no supporting OS subroutines.
 
QUICKREF
strlen ansi pure
*/
 
#include <_ansi.h>
#include <string.h>
#include <limits.h>
 
#define LBLOCKSIZE (sizeof (long))
#define UNALIGNED(X) ((long)X & (LBLOCKSIZE - 1))
 
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
/* Nonzero if X (a long int) contains a NULL byte. */
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif
 
#ifndef DETECTNULL
#error long int is not a 32bit or 64bit byte
#endif
 
size_t
_DEFUN (strlen, (str),
_CONST char *str)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
_CONST char *start = str;
 
while (*str)
str++;
 
return str - start;
#else
_CONST char *start = str;
unsigned long *aligned_addr;
 
if (!UNALIGNED (str))
{
/* If the string is word-aligned, we can check for the presence of
a null in each word-sized block. */
aligned_addr = (unsigned long*)str;
while (!DETECTNULL (*aligned_addr))
aligned_addr++;
 
/* Once a null is detected, we check each byte in that block for a
precise position of the null. */
str = (char*)aligned_addr;
}
while (*str)
str++;
return str - start;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/strcmp.c
0,0 → 1,106
/*
FUNCTION
<<strcmp>>---character string compare
INDEX
strcmp
 
ANSI_SYNOPSIS
#include <string.h>
int strcmp(const char *<[a]>, const char *<[b]>);
 
TRAD_SYNOPSIS
#include <string.h>
int strcmp(<[a]>, <[b]>)
char *<[a]>;
char *<[b]>;
 
DESCRIPTION
<<strcmp>> compares the string at <[a]> to
the string at <[b]>.
 
RETURNS
If <<*<[a]>>> sorts lexicographically after <<*<[b]>>>,
<<strcmp>> returns a number greater than zero. If the two
strings match, <<strcmp>> returns zero. If <<*<[a]>>>
sorts lexicographically before <<*<[b]>>>, <<strcmp>> returns a
number less than zero.
 
PORTABILITY
<<strcmp>> is ANSI C.
 
<<strcmp>> requires no supporting OS subroutines.
 
QUICKREF
strcmp ansi pure
*/
 
#include <string.h>
#include <limits.h>
 
/* Nonzero if either X or Y is not aligned on a "long" boundary. */
#define UNALIGNED(X, Y) \
(((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))
 
/* DETECTNULL returns nonzero if (long)X contains a NULL byte. */
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif
 
#ifndef DETECTNULL
#error long int is not a 32bit or 64bit byte
#endif
 
int
_DEFUN (strcmp, (s1, s2),
_CONST char *s1 _AND
_CONST char *s2)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
while (*s1 != '\0' && *s1 == *s2)
{
s1++;
s2++;
}
 
return (*(unsigned char *) s1) - (*(unsigned char *) s2);
#else
unsigned long *a1;
unsigned long *a2;
 
/* If s1 or s2 are unaligned, then compare bytes. */
if (!UNALIGNED (s1, s2))
{
/* If s1 and s2 are word-aligned, compare them a word at a time. */
a1 = (unsigned long*)s1;
a2 = (unsigned long*)s2;
while (*a1 == *a2)
{
/* To get here, *a1 == *a2, thus if we find a null in *a1,
then the strings must be equal, so return zero. */
if (DETECTNULL (*a1))
return 0;
 
a1++;
a2++;
}
 
/* A difference was detected in last few bytes of s1, so search bytewise */
s1 = (char*)a1;
s2 = (char*)a2;
}
 
while (*s1 != '\0' && *s1 == *s2)
{
s1++;
s2++;
}
return (*(unsigned char *) s1) - (*(unsigned char *) s2);
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/memcmp.c
0,0 → 1,113
/*
FUNCTION
<<memcmp>>---compare two memory areas
 
INDEX
memcmp
 
ANSI_SYNOPSIS
#include <string.h>
int memcmp(const void *<[s1]>, const void *<[s2]>, size_t <[n]>);
 
TRAD_SYNOPSIS
#include <string.h>
int memcmp(<[s1]>, <[s2]>, <[n]>)
void *<[s1]>;
void *<[s2]>;
size_t <[n]>;
 
DESCRIPTION
This function compares not more than <[n]> characters of the
object pointed to by <[s1]> with the object pointed to by <[s2]>.
 
 
RETURNS
The function returns an integer greater than, equal to or
less than zero according to whether the object pointed to by
<[s1]> is greater than, equal to or less than the object
pointed to by <[s2]>.
 
PORTABILITY
<<memcmp>> is ANSI C.
 
<<memcmp>> requires no supporting OS subroutines.
 
QUICKREF
memcmp ansi pure
*/
 
#include <string.h>
 
 
/* Nonzero if either X or Y is not aligned on a "long" boundary. */
#define UNALIGNED(X, Y) \
(((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))
 
/* How many bytes are copied each iteration of the word copy loop. */
#define LBLOCKSIZE (sizeof (long))
 
/* Threshhold for punting to the byte copier. */
#define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE)
 
int
_DEFUN (memcmp, (m1, m2, n),
_CONST _PTR m1 _AND
_CONST _PTR m2 _AND
size_t n)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
unsigned char *s1 = (unsigned char *) m1;
unsigned char *s2 = (unsigned char *) m2;
 
while (n--)
{
if (*s1 != *s2)
{
return *s1 - *s2;
}
s1++;
s2++;
}
return 0;
#else
unsigned char *s1 = (unsigned char *) m1;
unsigned char *s2 = (unsigned char *) m2;
unsigned long *a1;
unsigned long *a2;
 
/* If the size is too small, or either pointer is unaligned,
then we punt to the byte compare loop. Hopefully this will
not turn up in inner loops. */
if (!TOO_SMALL(n) && !UNALIGNED(s1,s2))
{
/* Otherwise, load and compare the blocks of memory one
word at a time. */
a1 = (unsigned long*) s1;
a2 = (unsigned long*) s2;
while (n >= LBLOCKSIZE)
{
if (*a1 != *a2)
break;
a1++;
a2++;
n -= LBLOCKSIZE;
}
 
/* check m mod LBLOCKSIZE remaining characters */
 
s1 = (char*)a1;
s2 = (char*)a2;
}
 
while (n--)
{
if (*s1 != *s2)
return *s1 - *s2;
s1++;
s2++;
}
 
return 0;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
 
/strncat.c
0,0 → 1,115
/*
FUNCTION
<<strncat>>---concatenate strings
 
INDEX
strncat
 
ANSI_SYNOPSIS
#include <string.h>
char *strncat(char *<[dst]>, const char *<[src]>, size_t <[length]>);
 
TRAD_SYNOPSIS
#include <string.h>
char *strncat(<[dst]>, <[src]>, <[length]>)
char *<[dst]>;
char *<[src]>;
size_t <[length]>;
 
DESCRIPTION
<<strncat>> appends not more than <[length]> characters from
the string pointed to by <[src]> (including the terminating
null character) to the end of the string pointed to by
<[dst]>. The initial character of <[src]> overwrites the null
character at the end of <[dst]>. A terminating null character
is always appended to the result
 
WARNINGS
Note that a null is always appended, so that if the copy is
limited by the <[length]> argument, the number of characters
appended to <[dst]> is <<n + 1>>.
 
RETURNS
This function returns the initial value of <[dst]>
 
PORTABILITY
<<strncat>> is ANSI C.
 
<<strncat>> requires no supporting OS subroutines.
 
QUICKREF
strncat ansi pure
*/
 
#include <string.h>
#include <limits.h>
 
/* Nonzero if X is aligned on a "long" boundary. */
#define ALIGNED(X) \
(((long)X & (sizeof (long) - 1)) == 0)
 
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
/* Nonzero if X (a long int) contains a NULL byte. */
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif
 
#ifndef DETECTNULL
#error long int is not a 32bit or 64bit byte
#endif
 
char *
_DEFUN (strncat, (s1, s2, n),
char *s1 _AND
_CONST char *s2 _AND
size_t n)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
char *s = s1;
 
while (*s1)
s1++;
while (n-- != 0 && (*s1++ = *s2++))
{
if (n == 0)
*s1 = '\0';
}
 
return s;
#else
char *s = s1;
 
/* Skip over the data in s1 as quickly as possible. */
if (ALIGNED (s1))
{
unsigned long *aligned_s1 = (unsigned long *)s1;
while (!DETECTNULL (*aligned_s1))
aligned_s1++;
 
s1 = (char *)aligned_s1;
}
 
while (*s1)
s1++;
 
/* s1 now points to the its trailing null character, now copy
up to N bytes from S2 into S1 stopping if a NULL is encountered
in S2.
 
It is not safe to use strncpy here since it copies EXACTLY N
characters, NULL padding if necessary. */
while (n-- != 0 && (*s1++ = *s2++))
{
if (n == 0)
*s1 = '\0';
}
return s;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/bzero.c
0,0 → 1,42
/*
FUNCTION
<<bzero>>---initialize memory to zero
 
INDEX
bzero
 
ANSI_SYNOPSIS
#include <string.h>
void bzero(char *<[b]>, size_t <[length]>);
 
TRAD_SYNOPSIS
#include <string.h>
void bzero(<[b]>, <[length]>)
char *<[b]>;
size_t <[length]>;
 
DESCRIPTION
<<bzero>> initializes <[length]> bytes of memory, starting at address
<[b]>, to zero.
 
RETURNS
<<bzero>> does not return a result.
 
PORTABILITY
<<bzero>> is in the Berkeley Software Distribution.
Neither ANSI C nor the System V Interface Definition (Issue 2) require
<<bzero>>.
 
<<bzero>> requires no supporting OS subroutines.
*/
 
#include <string.h>
 
_VOID
_DEFUN (bzero, (b, length),
char *b _AND
size_t length)
{
while (length--)
*b++ = 0;
}
/strcoll.c
0,0 → 1,48
/*
FUNCTION
<<strcoll>>---locale specific character string compare
INDEX
strcoll
 
ANSI_SYNOPSIS
#include <string.h>
int strcoll(const char *<[stra]>, const char * <[strb]>);
 
TRAD_SYNOPSIS
#include <string.h>
int strcoll(<[stra]>, <[strb]>)
char *<[stra]>;
char *<[strb]>;
 
DESCRIPTION
<<strcoll>> compares the string pointed to by <[stra]> to
the string pointed to by <[strb]>, using an interpretation
appropriate to the current <<LC_COLLATE>> state.
 
RETURNS
If the first string is greater than the second string,
<<strcoll>> returns a number greater than zero. If the two
strings are equivalent, <<strcoll>> returns zero. If the first
string is less than the second string, <<strcoll>> returns a
number less than zero.
 
PORTABILITY
<<strcoll>> is ANSI C.
 
<<strcoll>> requires no supporting OS subroutines.
 
QUICKREF
strcoll ansi pure
*/
 
#include <string.h>
 
int
_DEFUN (strcoll, (a, b),
_CONST char *a _AND
_CONST char *b)
 
{
return strcmp (a, b);
}
/strnlen.c
0,0 → 1,49
/*
FUNCTION
<<strnlen>>---character string length
INDEX
strnlen
 
ANSI_SYNOPSIS
#include <string.h>
size_t strnlen(const char *<[str]>, size_t <[n]>);
 
TRAD_SYNOPSIS
#include <string.h>
size_t strnlen(<[str]>, <[n]>)
char *<[src]>;
size_t <[n]>;
 
DESCRIPTION
The <<strnlen>> function works out the length of the string
starting at <<*<[str]>>> by counting chararacters until it
reaches a NUL character or the maximum: <[n]> number of
characters have been inspected.
 
RETURNS
<<strnlen>> returns the character count or <[n]>.
 
PORTABILITY
<<strnlen>> is a Gnu extension.
 
<<strnlen>> requires no supporting OS subroutines.
 
*/
 
#undef __STRICT_ANSI__
#include <_ansi.h>
#include <string.h>
 
size_t
_DEFUN (strnlen, (str, n),
_CONST char *str _AND
size_t n)
{
_CONST char *start = str;
 
while (*str && n-- > 0)
str++;
 
return str - start;
}
/strtok.c
0,0 → 1,78
/*
FUNCTION
<<strtok>>---get next token from a string
 
INDEX
strtok
 
INDEX
strtok_r
 
ANSI_SYNOPSIS
#include <string.h>
char *strtok(char *<[source]>, const char *<[delimiters]>)
char *strtok_r(char *<[source]>, const char *<[delimiters]>,
char **<[lasts]>)
 
TRAD_SYNOPSIS
#include <string.h>
char *strtok(<[source]>, <[delimiters]>)
char *<[source]>;
char *<[delimiters]>;
 
char *strtok_r(<[source]>, <[delimiters]>, <[lasts]>)
char *<[source]>;
char *<[delimiters]>;
char **<[lasts]>;
 
DESCRIPTION
The <<strtok>> function is used to isolate sequential tokens in a
null-terminated string, <<*<[source]>>>. These tokens are delimited
in the string by at least one of the characters in <<*<[delimiters]>>>.
The first time that <<strtok>> is called, <<*<[source]>>> should be
specified; subsequent calls, wishing to obtain further tokens from
the same string, should pass a null pointer instead. The separator
string, <<*<[delimiters]>>>, must be supplied each time, and may
change between calls.
 
The <<strtok>> function returns a pointer to the beginning of each
subsequent token in the string, after replacing the separator
character itself with a NUL character. When no more tokens remain,
a null pointer is returned.
 
The <<strtok_r>> function has the same behavior as <<strtok>>, except
a pointer to placeholder <<*[lasts]>> must be supplied by the caller.
 
RETURNS
<<strtok>> returns a pointer to the next token, or <<NULL>> if
no more tokens can be found.
 
NOTES
<<strtok>> is unsafe for multi-thread applications. <<strtok_r>>
is MT-Safe and should be used instead.
 
PORTABILITY
<<strtok>> is ANSI C.
 
<<strtok>> requires no supporting OS subroutines.
 
QUICKREF
strtok ansi impure
*/
 
/* undef STRICT_ANSI so that strtok_r prototype will be defined */
#undef __STRICT_ANSI__
#include <string.h>
#include <_ansi.h>
#include <reent.h>
 
#ifndef _REENT_ONLY
 
char *
_DEFUN (strtok, (s, delim),
register char *s _AND
register const char *delim)
{
return strtok_r (s, delim, &(_REENT->_new._reent._strtok_last));
}
#endif
/strncmp.c
0,0 → 1,122
/*
FUNCTION
<<strncmp>>---character string compare
INDEX
strncmp
 
ANSI_SYNOPSIS
#include <string.h>
int strncmp(const char *<[a]>, const char * <[b]>, size_t <[length]>);
 
TRAD_SYNOPSIS
#include <string.h>
int strncmp(<[a]>, <[b]>, <[length]>)
char *<[a]>;
char *<[b]>;
size_t <[length]>
 
DESCRIPTION
<<strncmp>> compares up to <[length]> characters
from the string at <[a]> to the string at <[b]>.
 
RETURNS
If <<*<[a]>>> sorts lexicographically after <<*<[b]>>>,
<<strncmp>> returns a number greater than zero. If the two
strings are equivalent, <<strncmp>> returns zero. If <<*<[a]>>>
sorts lexicographically before <<*<[b]>>>, <<strncmp>> returns a
number less than zero.
 
PORTABILITY
<<strncmp>> is ANSI C.
 
<<strncmp>> requires no supporting OS subroutines.
 
QUICKREF
strncmp ansi pure
*/
 
#include <string.h>
#include <limits.h>
 
/* Nonzero if either X or Y is not aligned on a "long" boundary. */
#define UNALIGNED(X, Y) \
(((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))
 
/* DETECTNULL returns nonzero if (long)X contains a NULL byte. */
#if LONG_MAX == 2147483647L
#define DETECTNULL(X) (((X) - 0x01010101) & ~(X) & 0x80808080)
#else
#if LONG_MAX == 9223372036854775807L
#define DETECTNULL(X) (((X) - 0x0101010101010101) & ~(X) & 0x8080808080808080)
#else
#error long int is not a 32bit or 64bit type.
#endif
#endif
 
#ifndef DETECTNULL
#error long int is not a 32bit or 64bit byte
#endif
 
int
_DEFUN (strncmp, (s1, s2, n),
_CONST char *s1 _AND
_CONST char *s2 _AND
size_t n)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
if (n == 0)
return 0;
 
while (n-- != 0 && *s1 == *s2)
{
if (n == 0 || *s1 == '\0')
break;
s1++;
s2++;
}
 
return (*(unsigned char *) s1) - (*(unsigned char *) s2);
#else
unsigned long *a1;
unsigned long *a2;
 
if (n == 0)
return 0;
 
/* If s1 or s2 are unaligned, then compare bytes. */
if (!UNALIGNED (s1, s2))
{
/* If s1 and s2 are word-aligned, compare them a word at a time. */
a1 = (unsigned long*)s1;
a2 = (unsigned long*)s2;
while (n >= sizeof (long) && *a1 == *a2)
{
n -= sizeof (long);
 
/* If we've run out of bytes or hit a null, return zero
since we already know *a1 == *a2. */
if (n == 0 || DETECTNULL (*a1))
return 0;
 
a1++;
a2++;
}
 
/* A difference was detected in last few bytes of s1, so search bytewise */
s1 = (char*)a1;
s2 = (char*)a2;
}
 
while (n-- > 0 && *s1 == *s2)
{
/* If we've run out of bytes or hit a null, return zero
since we already know *s1 == *s2. */
if (n == 0 || *s1 == '\0')
return 0;
s1++;
s2++;
}
return (*(unsigned char *) s1) - (*(unsigned char *) s2);
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/Makefile.am
0,0 → 1,80
## Process this file with automake to generate Makefile.in
 
AUTOMAKE_OPTIONS = cygnus
 
INCLUDES = $(NEWLIB_CFLAGS) $(CROSS_CFLAGS) $(TARGET_CFLAGS)
 
LIB_SOURCES = \
bcmp.c \
bcopy.c \
bzero.c \
index.c \
memchr.c \
memcmp.c \
memcpy.c \
memmove.c \
memset.c \
rindex.c \
strcat.c \
strchr.c \
strcmp.c \
strcasecmp.c \
strcoll.c \
strcpy.c \
strcspn.c \
strerror.c \
strlen.c \
strlwr.c \
strncat.c \
strncmp.c \
strncasecmp.c \
strncpy.c \
strnlen.c \
strpbrk.c \
strrchr.c \
strspn.c \
strtok.c \
strtok_r.c \
strupr.c \
strxfrm.c \
strstr.c \
swab.c \
u_strerr.c
 
libstring_la_LDFLAGS = -Xcompiler -nostdlib
 
if USE_LIBTOOL
noinst_LTLIBRARIES = libstring.la
libstring_la_SOURCES = $(LIB_SOURCES)
noinst_DATA = objectlist.awk.in
else
noinst_LIBRARIES = lib.a
lib_a_SOURCES = $(LIB_SOURCES)
noinst_DATA =
endif # USE_LIBTOOL
 
include $(srcdir)/../../Makefile.shared
 
CHEWOUT_FILES=\
bcmp.def memcpy.def strcmp.def strncat.def strstr.def \
bcopy.def memmove.def strcoll.def strncmp.def strtok.def \
bzero.def memset.def strcpy.def strncpy.def strxfrm.def \
index.def rindex.def strcspn.def strpbrk.def swab.def \
memchr.def strcat.def strerror.def strrchr.def \
memcmp.def strchr.def strlen.def strnlen.def strspn.def \
strcasecmp.def strncasecmp.def strlwr.def strupr.def
 
SUFFIXES = .def
 
CHEW = ../../doc/makedoc -f $(srcdir)/../../doc/doc.str
 
.c.def:
$(CHEW) < $< > $*.def 2> $*.ref
touch stmp-def
 
TARGETDOC = ../tmp.texi
 
doc: $(CHEWOUT_FILES)
cat $(srcdir)/strings.tex >> $(TARGETDOC)
 
CLEANFILES = $(CHEWOUT_FILES) *.ref
/rindex.c
0,0 → 1,44
/*
FUNCTION
<<rindex>>---reverse search for character in string
 
INDEX
rindex
 
ANSI_SYNOPSIS
#include <string.h>
char * rindex(const char *<[string]>, int <[c]>);
 
TRAD_SYNOPSIS
#include <string.h>
char * rindex(<[string]>, <[c]>);
char *<[string]>;
int *<[c]>;
 
DESCRIPTION
This function finds the last occurence of <[c]> (converted to
a char) in the string pointed to by <[string]> (including the
terminating null character).
 
This function is identical to <<strrchr>>.
 
RETURNS
Returns a pointer to the located character, or a null pointer
if <[c]> does not occur in <[string]>.
 
PORTABILITY
<<rindex>> requires no supporting OS subroutines.
 
QUICKREF
rindex - pure
*/
 
#include <string.h>
 
char *
_DEFUN (rindex, (s, c),
_CONST char *s _AND
int c)
{
return strrchr (s, c);
}
/memset.c
0,0 → 1,109
/*
FUNCTION
<<memset>>---set an area of memory
 
INDEX
memset
 
ANSI_SYNOPSIS
#include <string.h>
void *memset(const void *<[dst]>, int <[c]>, size_t <[length]>);
 
TRAD_SYNOPSIS
#include <string.h>
void *memset(<[dst]>, <[c]>, <[length]>)
void *<[dst]>;
int <[c]>;
size_t <[length]>;
 
DESCRIPTION
This function converts the argument <[c]> into an unsigned
char and fills the first <[length]> characters of the array
pointed to by <[dst]> to the value.
 
RETURNS
<<memset>> returns the value of <[m]>.
 
PORTABILITY
<<memset>> is ANSI C.
 
<<memset>> requires no supporting OS subroutines.
 
QUICKREF
memset ansi pure
*/
 
#include <string.h>
 
#define LBLOCKSIZE (sizeof(long))
#define UNALIGNED(X) ((long)X & (LBLOCKSIZE - 1))
#define TOO_SMALL(LEN) ((LEN) < LBLOCKSIZE)
 
_PTR
_DEFUN (memset, (m, c, n),
_PTR m _AND
int c _AND
size_t n)
{
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
char *s = (char *) m;
 
while (n-- != 0)
{
*s++ = (char) c;
}
 
return m;
#else
char *s = (char *) m;
int i;
unsigned long buffer;
unsigned long *aligned_addr;
 
if (!TOO_SMALL (n) && !UNALIGNED (m))
{
/* If we get this far, we know that n is large and m is word-aligned. */
 
aligned_addr = (unsigned long*)m;
 
/* Store C into each char sized location in BUFFER so that
we can set large blocks quickly. */
c &= 0xff;
if (LBLOCKSIZE == 4)
{
buffer = (c << 8) | c;
buffer |= (buffer << 16);
}
else
{
buffer = 0;
for (i = 0; i < LBLOCKSIZE; i++)
buffer = (buffer << 8) | c;
}
 
while (n >= LBLOCKSIZE*4)
{
*aligned_addr++ = buffer;
*aligned_addr++ = buffer;
*aligned_addr++ = buffer;
*aligned_addr++ = buffer;
n -= 4*LBLOCKSIZE;
}
 
while (n >= LBLOCKSIZE)
{
*aligned_addr++ = buffer;
n -= LBLOCKSIZE;
}
/* Pick up the remainder with a bytewise loop. */
s = (char*)aligned_addr;
}
 
while (n--)
{
*s++ = (char)c;
}
 
return m;
#endif /* not PREFER_SIZE_OVER_SPEED */
}
/swab.c
0,0 → 1,44
/*
FUNCTION
<<swab>>---swap adjacent bytes
 
ANSI_SYNOPSIS
#include <unistd.h>
void swab(const void *<[in]>, void *<[out]>, ssize_t <[n]>);
 
TRAD_SYNOPSIS
void swab(<[in]>, <[out]>, <[n]>
void *<[in]>;
void *<[out]>;
ssize_t <[n]>;
 
DESCRIPTION
This function copies <[n]> bytes from the memory region
pointed to by <[in]> to the memory region pointed to by
<[out]>, exchanging adjacent even and odd bytes.
 
PORTABILITY
<<swab>> requires no supporting OS subroutines.
*/
 
#include <unistd.h>
 
void
_DEFUN (swab, (b1, b2, length),
_CONST void *b1 _AND
void *b2 _AND
ssize_t length)
{
const char *from = b1;
char *to = b2;
ssize_t ptr;
for (ptr = 1; ptr < length; ptr += 2)
{
char p = from[ptr];
char q = from[ptr-1];
to[ptr-1] = p;
to[ptr ] = q;
}
if (ptr == length) /* I.e., if length is odd, */
to[ptr-1] = 0; /* then pad with a NUL. */
}
/strcspn.c
0,0 → 1,54
/*
FUNCTION
<<strcspn>>---count chars not in string
 
INDEX
strcspn
 
ANSI_SYNOPSIS
size_t strcspn(const char *<[s1]>, const char *<[s2]>);
 
TRAD_SYNOPSIS
size_t strcspn(<[s1]>, <[s2]>)
char *<[s1]>;
char *<[s2]>;
 
DESCRIPTION
This function computes the length of the initial part of
the string pointed to by <[s1]> which consists entirely of
characters <[NOT]> from the string pointed to by <[s2]>
(excluding the terminating null character).
 
RETURNS
<<strcspn>> returns the length of the substring found.
 
PORTABILITY
<<strcspn>> is ANSI C.
 
<<strcspn>> requires no supporting OS subroutines.
*/
 
#include <string.h>
 
size_t
_DEFUN (strcspn, (s1, s2),
_CONST char *s1 _AND
_CONST char *s2)
{
_CONST char *s = s1;
_CONST char *c;
 
while (*s1)
{
for (c = s2; *c; c++)
{
if (*s1 == *c)
break;
}
if (*c)
break;
s1++;
}
 
return s1 - s;
}
/strlwr.c
0,0 → 1,50
/*
FUNCTION
<<strlwr>>---force string to lower case
INDEX
strlwr
 
ANSI_SYNOPSIS
#include <string.h>
char *strlwr(char *<[a]>);
 
TRAD_SYNOPSIS
#include <string.h>
char *strlwr(<[a]>)
char *<[a]>;
 
DESCRIPTION
<<strlwr>> converts each characters in the string at <[a]> to
lower case.
 
RETURNS
<<strlwr>> returns its argument, <[a]>.
 
PORTABILITY
<<strlwr>> is not widely portable.
 
<<strlwr>> requires no supporting OS subroutines.
 
QUICKREF
strlwr
*/
 
#include <string.h>
#include <ctype.h>
 
char *
strlwr (a)
char *a;
{
char *ret = a;
 
while (*a != '\0')
{
if (isupper (*a))
*a = tolower (*a);
++a;
}
 
return ret;
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.