#top Strings¶

#top Makefile¶

#top Makefile (linux)¶

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_BASENAME=1 -DHAVE_MEMMEM=1 -DHAVE_MEMPCPY=1 -DHAVE_MEMRCHR=1 -DHAVE_STRERROR=1 -DHAVE_STRNCASECMP=1 -DHAVE_STRNCASESTR=1 -DHAVE_STRNDUP=1 -DHAVE_STRNLEN=1 -DHAVE_STRSEP=1 -DHAVE_STRSIGNAL=1 -DHAVE_STRVERSCMP=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

BASENAME    = basename
GETCHAR     = getchar
GETS        = gets
MEMCCPY     = memccpy
MEMCHR      = memchr
MEMCMP      = memcmp
MEMCPY      = memcpy
MEMMEM      = memmem
MEMMOVE     = memmove
MEMPCPY     = mempcpy
MEMRCHR     = memrchr
MEMSET      = memset
PRINTF      = printf
PUTCHAR     = putchar
PUTS        = puts
SCANF       = scanf
SNPRINTF    = snprintf
SSCANF      = sscanf
STRCASESTR  = strcasestr
STRCHR      = strchr
STRCOLL     = strcoll
STRCSPN     = strcspn
STRERROR    = strerror
STRNCASECMP = strncasecmp
STRNCAT     = strncat
STRNCMP     = strncmp
STRNCPY     = strncpy
STRNDUP     = strndup
STRNLEN     = strnlen
STRPBRK     = strpbrk
STRRCHR     = strrchr
STRSEP      = strsep
STRSIGNAL   = strsignal
STRSPN      = strspn
STRSTR      = strstr
STRTOK      = strtok
STRVERSCMP  = strverscmp
VPRINTF     = vprintf
VSNPRINTF   = vsnprintf



all: objdir make

objdir:
	$(MKDCMD) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(BASENAME)
#make: $(GETCHAR)
#make: $(GETS)
#make: $(MEMCCPY)
#make: $(MEMCHR)
#make: $(MEMCMP)
#make: $(MEMCPY)
#make: $(MEMMEM)
#make: $(MEMMOVE)
#make: $(MEMPCPY)
#make: $(MEMRCHR)
#make: $(MEMSET)
#make: $(PRINTF)
#make: $(PUTCHAR)
#make: $(PUTS)
#make: $(SCANF)
#make: $(SNPRINTF)
#make: $(SSCANF)
#make: $(STRCASESTR)
#make: $(STRCHR)
#make: $(STRCOLL)
#make: $(STRCSPN)
#make: $(STRERROR)
#make: $(STRNCASECMP)
#make: $(STRNCAT)
#make: $(STRNCMP)
#make: $(STRNCPY)
#make: $(STRNDUP)
#make: $(STRNLEN)
#make: $(STRPBRK)
#make: $(STRRCHR)
#make: $(STRSEP)
#make: $(STRSIGNAL)
#make: $(STRSPN)
#make: $(STRSTR)
#make: $(STRTOK)
#make: $(STRVERSCMP)
#make: $(VPRINTF)
#make: $(VSNPRINTF)
make: $(BASENAME) $(GETCHAR) $(GETS) $(MEMCCPY) $(MEMCHR) $(MEMCMP) $(MEMCPY) $(MEMMEM) $(MEMMOVE) $(MEMPCPY) $(MEMRCHR) $(MEMSET) $(PRINTF) $(PUTCHAR) $(PUTS) $(SCANF) $(SNPRINTF) $(SSCANF) $(STRCASESTR) $(STRCHR) $(STRCOLL) $(STRCSPN) $(STRERROR) $(STRNCASECMP) $(STRNCAT) $(STRNCMP) $(STRNCPY) $(STRNDUP) $(STRNLEN) $(STRPBRK) $(STRRCHR) $(STRSEP) $(STRSIGNAL) $(STRSPN) $(STRSTR) $(STRTOK) $(STRVERSCMP) $(VPRINTF) $(VSNPRINTF)



$(BASENAME): $(BASENAME).o
	$(GCC) -o $(BASENAME) obj/$(BASENAME).o $(LDFLAGS)
$(BASENAME).o:
	$(GCC) -o obj/$(BASENAME).o -c $(BASENAME).c $(CFLAGS)

$(GETCHAR): $(GETCHAR).o
	$(GCC) -o $(GETCHAR) obj/$(GETCHAR).o $(LDFLAGS)
$(GETCHAR).o:
	$(GCC) -o obj/$(GETCHAR).o -c $(GETCHAR).c $(CFLAGS)

$(GETS): $(GETS).o
	$(GCC) -o $(GETS) obj/$(GETS).o $(LDFLAGS)
$(GETS).o:
	$(GCC) -o obj/$(GETS).o -c $(GETS).c $(CFLAGS)

$(MEMCCPY): $(MEMCCPY).o
	$(GCC) -o $(MEMCCPY) obj/$(MEMCCPY).o $(LDFLAGS)
$(MEMCCPY).o:
	$(GCC) -o obj/$(MEMCCPY).o -c $(MEMCCPY).c $(CFLAGS)

$(MEMCHR): $(MEMCHR).o
	$(GCC) -o $(MEMCHR) obj/$(MEMCHR).o $(LDFLAGS)
$(MEMCHR).o:
	$(GCC) -o obj/$(MEMCHR).o -c $(MEMCHR).c $(CFLAGS)

$(MEMCMP): $(MEMCMP).o
	$(GCC) -o $(MEMCMP) obj/$(MEMCMP).o $(LDFLAGS)
$(MEMCMP).o:
	$(GCC) -o obj/$(MEMCMP).o -c $(MEMCMP).c $(CFLAGS)

$(MEMCPY): $(MEMCPY).o
	$(GCC) -o $(MEMCPY) obj/$(MEMCPY).o $(LDFLAGS)
$(MEMCPY).o:
	$(GCC) -o obj/$(MEMCPY).o -c $(MEMCPY).c $(CFLAGS)

$(MEMMEM): $(MEMMEM).o
	$(GCC) -o $(MEMMEM) obj/$(MEMMEM).o $(LDFLAGS)
$(MEMMEM).o:
	$(GCC) -o obj/$(MEMMEM).o -c $(MEMMEM).c $(CFLAGS)

$(MEMMOVE): $(MEMMOVE).o
	$(GCC) -o $(MEMMOVE) obj/$(MEMMOVE).o $(LDFLAGS)
$(MEMMOVE).o:
	$(GCC) -o obj/$(MEMMOVE).o -c $(MEMMOVE).c $(CFLAGS)

$(MEMPCPY): $(MEMPCPY).o
	$(GCC) -o $(MEMPCPY) obj/$(MEMPCPY).o $(LDFLAGS)
$(MEMPCPY).o:
	$(GCC) -o obj/$(MEMPCPY).o -c $(MEMPCPY).c $(CFLAGS)

$(MEMRCHR): $(MEMRCHR).o
	$(GCC) -o $(MEMRCHR) obj/$(MEMRCHR).o $(LDFLAGS)
$(MEMRCHR).o:
	$(GCC) -o obj/$(MEMRCHR).o -c $(MEMRCHR).c $(CFLAGS)

$(MEMSET): $(MEMSET).o
	$(GCC) -o $(MEMSET) obj/$(MEMSET).o $(LDFLAGS)
$(MEMSET).o:
	$(GCC) -o obj/$(MEMSET).o -c $(MEMSET).c $(CFLAGS)

$(PRINTF): $(PRINTF).o
	$(GCC) -o $(PRINTF) obj/$(PRINTF).o $(LDFLAGS)
$(PRINTF).o:
	$(GCC) -o obj/$(PRINTF).o -c $(PRINTF).c $(CFLAGS)

$(PUTCHAR): $(PUTCHAR).o
	$(GCC) -o $(PUTCHAR) obj/$(PUTCHAR).o $(LDFLAGS)
$(PUTCHAR).o:
	$(GCC) -o obj/$(PUTCHAR).o -c $(PUTCHAR).c $(CFLAGS)

$(PUTS): $(PUTS).o
	$(GCC) -o $(PUTS) obj/$(PUTS).o $(LDFLAGS)
$(PUTS).o:
	$(GCC) -o obj/$(PUTS).o -c $(PUTS).c $(CFLAGS)

$(SCANF): $(SCANF).o
	$(GCC) -o $(SCANF) obj/$(SCANF).o $(LDFLAGS)
$(SCANF).o:
	$(GCC) -o obj/$(SCANF).o -c $(SCANF).c $(CFLAGS)

$(SNPRINTF): $(SNPRINTF).o
	$(GCC) -o $(SNPRINTF) obj/$(SNPRINTF).o $(LDFLAGS)
$(SNPRINTF).o:
	$(GCC) -o obj/$(SNPRINTF).o -c $(SNPRINTF).c $(CFLAGS)

$(SSCANF): $(SSCANF).o
	$(GCC) -o $(SSCANF) obj/$(SSCANF).o $(LDFLAGS)
$(SSCANF).o:
	$(GCC) -o obj/$(SSCANF).o -c $(SSCANF).c $(CFLAGS)

$(STRCASESTR): $(STRCASESTR).o
	$(GCC) -o $(STRCASESTR) obj/$(STRCASESTR).o $(LDFLAGS)
$(STRCASESTR).o:
	$(GCC) -o obj/$(STRCASESTR).o -c $(STRCASESTR).c $(CFLAGS)

$(STRCHR): $(STRCHR).o
	$(GCC) -o $(STRCHR) obj/$(STRCHR).o $(LDFLAGS)
$(STRCHR).o:
	$(GCC) -o obj/$(STRCHR).o -c $(STRCHR).c $(CFLAGS)

$(STRCOLL): $(STRCOLL).o
	$(GCC) -o $(STRCOLL) obj/$(STRCOLL).o $(LDFLAGS)
$(STRCOLL).o:
	$(GCC) -o obj/$(STRCOLL).o -c $(STRCOLL).c $(CFLAGS)

$(STRCSPN): $(STRCSPN).o
	$(GCC) -o $(STRCSPN) obj/$(STRCSPN).o $(LDFLAGS)
$(STRCSPN).o:
	$(GCC) -o obj/$(STRCSPN).o -c $(STRCSPN).c $(CFLAGS)

$(STRERROR): $(STRERROR).o
	$(GCC) -o $(STRERROR) obj/$(STRERROR).o $(LDFLAGS)
$(STRERROR).o:
	$(GCC) -o obj/$(STRERROR).o -c $(STRERROR).c $(CFLAGS)

$(STRNCASECMP): $(STRNCASECMP).o
	$(GCC) -o $(STRNCASECMP) obj/$(STRNCASECMP).o $(LDFLAGS)
$(STRNCASECMP).o:
	$(GCC) -o obj/$(STRNCASECMP).o -c $(STRNCASECMP).c $(CFLAGS)

$(STRNCAT): $(STRNCAT).o
	$(GCC) -o $(STRNCAT) obj/$(STRNCAT).o $(LDFLAGS)
$(STRNCAT).o:
	$(GCC) -o obj/$(STRNCAT).o -c $(STRNCAT).c $(CFLAGS)

$(STRNCMP): $(STRNCMP).o
	$(GCC) -o $(STRNCMP) obj/$(STRNCMP).o $(LDFLAGS)
$(STRNCMP).o:
	$(GCC) -o obj/$(STRNCMP).o -c $(STRNCMP).c $(CFLAGS)

$(STRNCPY): $(STRNCPY).o
	$(GCC) -o $(STRNCPY) obj/$(STRNCPY).o $(LDFLAGS)
$(STRNCPY).o:
	$(GCC) -o obj/$(STRNCPY).o -c $(STRNCPY).c $(CFLAGS)

$(STRNDUP): $(STRNDUP).o
	$(GCC) -o $(STRNDUP) obj/$(STRNDUP).o $(LDFLAGS)
$(STRNDUP).o:
	$(GCC) -o obj/$(STRNDUP).o -c $(STRNDUP).c $(CFLAGS)

$(STRNLEN): $(STRNLEN).o
	$(GCC) -o $(STRNLEN) obj/$(STRNLEN).o $(LDFLAGS)
$(STRNLEN).o:
	$(GCC) -o obj/$(STRNLEN).o -c $(STRNLEN).c $(CFLAGS)

$(STRPBRK): $(STRPBRK).o
	$(GCC) -o $(STRPBRK) obj/$(STRPBRK).o $(LDFLAGS)
$(STRPBRK).o:
	$(GCC) -o obj/$(STRPBRK).o -c $(STRPBRK).c $(CFLAGS)

$(STRRCHR): $(STRRCHR).o
	$(GCC) -o $(STRRCHR) obj/$(STRRCHR).o $(LDFLAGS)
$(STRRCHR).o:
	$(GCC) -o obj/$(STRRCHR).o -c $(STRRCHR).c $(CFLAGS)

$(STRSEP): $(STRSEP).o
	$(GCC) -o $(STRSEP) obj/$(STRSEP).o $(LDFLAGS)
$(STRSEP).o:
	$(GCC) -o obj/$(STRSEP).o -c $(STRSEP).c $(CFLAGS)

$(STRSIGNAL): $(STRSIGNAL).o
	$(GCC) -o $(STRSIGNAL) obj/$(STRSIGNAL).o $(LDFLAGS)
$(STRSIGNAL).o:
	$(GCC) -o obj/$(STRSIGNAL).o -c $(STRSIGNAL).c $(CFLAGS)

$(STRSPN): $(STRSPN).o
	$(GCC) -o $(STRSPN) obj/$(STRSPN).o $(LDFLAGS)
$(STRSPN).o:
	$(GCC) -o obj/$(STRSPN).o -c $(STRSPN).c $(CFLAGS)

$(STRSTR): $(STRSTR).o
	$(GCC) -o $(STRSTR) obj/$(STRSTR).o $(LDFLAGS)
$(STRSTR).o:
	$(GCC) -o obj/$(STRSTR).o -c $(STRSTR).c $(CFLAGS)

$(STRTOK): $(STRTOK).o
	$(GCC) -o $(STRTOK) obj/$(STRTOK).o $(LDFLAGS)
$(STRTOK).o:
	$(GCC) -o obj/$(STRTOK).o -c $(STRTOK).c $(CFLAGS)

$(STRVERSCMP): $(STRVERSCMP).o
	$(GCC) -o $(STRVERSCMP) obj/$(STRVERSCMP).o $(LDFLAGS)
$(STRVERSCMP).o:
	$(GCC) -o obj/$(STRVERSCMP).o -c $(STRVERSCMP).c $(CFLAGS)

$(VPRINTF): $(VPRINTF).o
	$(GCC) -o $(VPRINTF) obj/$(VPRINTF).o $(LDFLAGS)
$(VPRINTF).o:
	$(GCC) -o obj/$(VPRINTF).o -c $(VPRINTF).c $(CFLAGS)

$(VSNPRINTF): $(VSNPRINTF).o
	$(GCC) -o $(VSNPRINTF) obj/$(VSNPRINTF).o $(LDFLAGS)
$(VSNPRINTF).o:
	$(GCC) -o obj/$(VSNPRINTF).o -c $(VSNPRINTF).c $(CFLAGS)

#top Makefile.obsd¶

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_STRNCASECMP=1 -DHAVE_STRNCASESTR=1 -DHAVE_STRSEP=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

BASENAME    = basename
GETCHAR     = getchar
GETS        = gets
MEMCCPY     = memccpy
MEMCHR      = memchr
MEMCMP      = memcmp
MEMCPY      = memcpy
MEMMEM      = memmem
MEMMOVE     = memmove
MEMPCPY     = mempcpy
MEMRCHR     = memrchr
MEMSET      = memset
PRINTF      = printf
PUTCHAR     = putchar
PUTS        = puts
SCANF       = scanf
SNPRINTF    = snprintf
SSCANF      = sscanf
STRCASESTR  = strcasestr
STRCHR      = strchr
STRCOLL     = strcoll
STRCSPN     = strcspn
STRERROR    = strerror
STRNCASECMP = strncasecmp
STRNCAT     = strncat
STRNCMP     = strncmp
STRNCPY     = strncpy
STRNDUP     = strndup
STRNLEN     = strnlen
STRPBRK     = strpbrk
STRRCHR     = strrchr
STRSEP      = strsep
STRSIGNAL   = strsignal
STRSPN      = strspn
STRSTR      = strstr
STRTOK      = strtok
STRVERSCMP  = strverscmp
VPRINTF     = vprintf
VSNPRINTF   = vsnprintf



all: objdir make

objdir:
	$(MKDCMD) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(BASENAME)
#make: $(GETCHAR)
#make: $(GETS)
#make: $(MEMCCPY)
#make: $(MEMCHR)
#make: $(MEMCMP)
#make: $(MEMCPY)
#make: $(MEMMEM)
#make: $(MEMMOVE)
#make: $(MEMPCPY)
#make: $(MEMRCHR)
#make: $(MEMSET)
#make: $(PRINTF)
#make: $(PUTCHAR)
#make: $(PUTS)
#make: $(SCANF)
#make: $(SNPRINTF)
#make: $(SSCANF)
#make: $(STRCASESTR)
#make: $(STRCHR)
#make: $(STRCOLL)
#make: $(STRCSPN)
#make: $(STRERROR)
#make: $(STRNCASECMP)
#make: $(STRNCAT)
#make: $(STRNCMP)
#make: $(STRNCPY)
#make: $(STRNDUP)
#make: $(STRNLEN)
#make: $(STRPBRK)
#make: $(STRRCHR)
#make: $(STRSEP)
#make: $(STRSIGNAL)
#make: $(STRSPN)
#make: $(STRSTR)
#make: $(STRTOK)
#make: $(STRVERSCMP)
#make: $(VPRINTF)
#make: $(VSNPRINTF)
make: $(BASENAME) $(GETCHAR) $(GETS) $(MEMCCPY) $(MEMCHR) $(MEMCMP) $(MEMCPY) $(MEMMEM) $(MEMMOVE) $(MEMPCPY) $(MEMRCHR) $(MEMSET) $(PRINTF) $(PUTCHAR) $(PUTS) $(SCANF) $(SNPRINTF) $(SSCANF) $(STRCASESTR) $(STRCHR) $(STRCOLL) $(STRCSPN) $(STRERROR) $(STRNCASECMP) $(STRNCAT) $(STRNCMP) $(STRNCPY) $(STRNDUP) $(STRNLEN) $(STRPBRK) $(STRRCHR) $(STRSEP) $(STRSIGNAL) $(STRSPN) $(STRSTR) $(STRTOK) $(STRVERSCMP) $(VPRINTF) $(VSNPRINTF)



$(BASENAME): $(BASENAME).o
	$(GCC) -o $(BASENAME) obj/$(BASENAME).o $(LDFLAGS)
$(BASENAME).o:
	$(GCC) -o obj/$(BASENAME).o -c $(BASENAME).c $(CFLAGS)

$(GETCHAR): $(GETCHAR).o
	$(GCC) -o $(GETCHAR) obj/$(GETCHAR).o $(LDFLAGS)
$(GETCHAR).o:
	$(GCC) -o obj/$(GETCHAR).o -c $(GETCHAR).c $(CFLAGS)

$(GETS): $(GETS).o
	$(GCC) -o $(GETS) obj/$(GETS).o $(LDFLAGS)
$(GETS).o:
	$(GCC) -o obj/$(GETS).o -c $(GETS).c $(CFLAGS)

$(MEMCCPY): $(MEMCCPY).o
	$(GCC) -o $(MEMCCPY) obj/$(MEMCCPY).o $(LDFLAGS)
$(MEMCCPY).o:
	$(GCC) -o obj/$(MEMCCPY).o -c $(MEMCCPY).c $(CFLAGS)

$(MEMCHR): $(MEMCHR).o
	$(GCC) -o $(MEMCHR) obj/$(MEMCHR).o $(LDFLAGS)
$(MEMCHR).o:
	$(GCC) -o obj/$(MEMCHR).o -c $(MEMCHR).c $(CFLAGS)

$(MEMCMP): $(MEMCMP).o
	$(GCC) -o $(MEMCMP) obj/$(MEMCMP).o $(LDFLAGS)
$(MEMCMP).o:
	$(GCC) -o obj/$(MEMCMP).o -c $(MEMCMP).c $(CFLAGS)

$(MEMCPY): $(MEMCPY).o
	$(GCC) -o $(MEMCPY) obj/$(MEMCPY).o $(LDFLAGS)
$(MEMCPY).o:
	$(GCC) -o obj/$(MEMCPY).o -c $(MEMCPY).c $(CFLAGS)

$(MEMMEM): $(MEMMEM).o
	$(GCC) -o $(MEMMEM) obj/$(MEMMEM).o $(LDFLAGS)
$(MEMMEM).o:
	$(GCC) -o obj/$(MEMMEM).o -c $(MEMMEM).c $(CFLAGS)

$(MEMMOVE): $(MEMMOVE).o
	$(GCC) -o $(MEMMOVE) obj/$(MEMMOVE).o $(LDFLAGS)
$(MEMMOVE).o:
	$(GCC) -o obj/$(MEMMOVE).o -c $(MEMMOVE).c $(CFLAGS)

$(MEMPCPY): $(MEMPCPY).o
	$(GCC) -o $(MEMPCPY) obj/$(MEMPCPY).o $(LDFLAGS)
$(MEMPCPY).o:
	$(GCC) -o obj/$(MEMPCPY).o -c $(MEMPCPY).c $(CFLAGS)

$(MEMRCHR): $(MEMRCHR).o
	$(GCC) -o $(MEMRCHR) obj/$(MEMRCHR).o $(LDFLAGS)
$(MEMRCHR).o:
	$(GCC) -o obj/$(MEMRCHR).o -c $(MEMRCHR).c $(CFLAGS)

$(MEMSET): $(MEMSET).o
	$(GCC) -o $(MEMSET) obj/$(MEMSET).o $(LDFLAGS)
$(MEMSET).o:
	$(GCC) -o obj/$(MEMSET).o -c $(MEMSET).c $(CFLAGS)

$(PRINTF): $(PRINTF).o
	$(GCC) -o $(PRINTF) obj/$(PRINTF).o $(LDFLAGS)
$(PRINTF).o:
	$(GCC) -o obj/$(PRINTF).o -c $(PRINTF).c $(CFLAGS)

$(PUTCHAR): $(PUTCHAR).o
	$(GCC) -o $(PUTCHAR) obj/$(PUTCHAR).o $(LDFLAGS)
$(PUTCHAR).o:
	$(GCC) -o obj/$(PUTCHAR).o -c $(PUTCHAR).c $(CFLAGS)

$(PUTS): $(PUTS).o
	$(GCC) -o $(PUTS) obj/$(PUTS).o $(LDFLAGS)
$(PUTS).o:
	$(GCC) -o obj/$(PUTS).o -c $(PUTS).c $(CFLAGS)

$(SCANF): $(SCANF).o
	$(GCC) -o $(SCANF) obj/$(SCANF).o $(LDFLAGS)
$(SCANF).o:
	$(GCC) -o obj/$(SCANF).o -c $(SCANF).c $(CFLAGS)

$(SNPRINTF): $(SNPRINTF).o
	$(GCC) -o $(SNPRINTF) obj/$(SNPRINTF).o $(LDFLAGS)
$(SNPRINTF).o:
	$(GCC) -o obj/$(SNPRINTF).o -c $(SNPRINTF).c $(CFLAGS)

$(SSCANF): $(SSCANF).o
	$(GCC) -o $(SSCANF) obj/$(SSCANF).o $(LDFLAGS)
$(SSCANF).o:
	$(GCC) -o obj/$(SSCANF).o -c $(SSCANF).c $(CFLAGS)

$(STRCASESTR): $(STRCASESTR).o
	$(GCC) -o $(STRCASESTR) obj/$(STRCASESTR).o $(LDFLAGS)
$(STRCASESTR).o:
	$(GCC) -o obj/$(STRCASESTR).o -c $(STRCASESTR).c $(CFLAGS)

$(STRCHR): $(STRCHR).o
	$(GCC) -o $(STRCHR) obj/$(STRCHR).o $(LDFLAGS)
$(STRCHR).o:
	$(GCC) -o obj/$(STRCHR).o -c $(STRCHR).c $(CFLAGS)

$(STRCOLL): $(STRCOLL).o
	$(GCC) -o $(STRCOLL) obj/$(STRCOLL).o $(LDFLAGS)
$(STRCOLL).o:
	$(GCC) -o obj/$(STRCOLL).o -c $(STRCOLL).c $(CFLAGS)

$(STRCSPN): $(STRCSPN).o
	$(GCC) -o $(STRCSPN) obj/$(STRCSPN).o $(LDFLAGS)
$(STRCSPN).o:
	$(GCC) -o obj/$(STRCSPN).o -c $(STRCSPN).c $(CFLAGS)

$(STRERROR): $(STRERROR).o
	$(GCC) -o $(STRERROR) obj/$(STRERROR).o $(LDFLAGS)
$(STRERROR).o:
	$(GCC) -o obj/$(STRERROR).o -c $(STRERROR).c $(CFLAGS)

$(STRNCASECMP): $(STRNCASECMP).o
	$(GCC) -o $(STRNCASECMP) obj/$(STRNCASECMP).o $(LDFLAGS)
$(STRNCASECMP).o:
	$(GCC) -o obj/$(STRNCASECMP).o -c $(STRNCASECMP).c $(CFLAGS)

$(STRNCAT): $(STRNCAT).o
	$(GCC) -o $(STRNCAT) obj/$(STRNCAT).o $(LDFLAGS)
$(STRNCAT).o:
	$(GCC) -o obj/$(STRNCAT).o -c $(STRNCAT).c $(CFLAGS)

$(STRNCMP): $(STRNCMP).o
	$(GCC) -o $(STRNCMP) obj/$(STRNCMP).o $(LDFLAGS)
$(STRNCMP).o:
	$(GCC) -o obj/$(STRNCMP).o -c $(STRNCMP).c $(CFLAGS)

$(STRNCPY): $(STRNCPY).o
	$(GCC) -o $(STRNCPY) obj/$(STRNCPY).o $(LDFLAGS)
$(STRNCPY).o:
	$(GCC) -o obj/$(STRNCPY).o -c $(STRNCPY).c $(CFLAGS)

$(STRNDUP): $(STRNDUP).o
	$(GCC) -o $(STRNDUP) obj/$(STRNDUP).o $(LDFLAGS)
$(STRNDUP).o:
	$(GCC) -o obj/$(STRNDUP).o -c $(STRNDUP).c $(CFLAGS)

$(STRNLEN): $(STRNLEN).o
	$(GCC) -o $(STRNLEN) obj/$(STRNLEN).o $(LDFLAGS)
$(STRNLEN).o:
	$(GCC) -o obj/$(STRNLEN).o -c $(STRNLEN).c $(CFLAGS)

$(STRPBRK): $(STRPBRK).o
	$(GCC) -o $(STRPBRK) obj/$(STRPBRK).o $(LDFLAGS)
$(STRPBRK).o:
	$(GCC) -o obj/$(STRPBRK).o -c $(STRPBRK).c $(CFLAGS)

$(STRRCHR): $(STRRCHR).o
	$(GCC) -o $(STRRCHR) obj/$(STRRCHR).o $(LDFLAGS)
$(STRRCHR).o:
	$(GCC) -o obj/$(STRRCHR).o -c $(STRRCHR).c $(CFLAGS)

$(STRSEP): $(STRSEP).o
	$(GCC) -o $(STRSEP) obj/$(STRSEP).o $(LDFLAGS)
$(STRSEP).o:
	$(GCC) -o obj/$(STRSEP).o -c $(STRSEP).c $(CFLAGS)

$(STRSIGNAL): $(STRSIGNAL).o
	$(GCC) -o $(STRSIGNAL) obj/$(STRSIGNAL).o $(LDFLAGS)
$(STRSIGNAL).o:
	$(GCC) -o obj/$(STRSIGNAL).o -c $(STRSIGNAL).c $(CFLAGS)

$(STRSPN): $(STRSPN).o
	$(GCC) -o $(STRSPN) obj/$(STRSPN).o $(LDFLAGS)
$(STRSPN).o:
	$(GCC) -o obj/$(STRSPN).o -c $(STRSPN).c $(CFLAGS)

$(STRSTR): $(STRSTR).o
	$(GCC) -o $(STRSTR) obj/$(STRSTR).o $(LDFLAGS)
$(STRSTR).o:
	$(GCC) -o obj/$(STRSTR).o -c $(STRSTR).c $(CFLAGS)

$(STRTOK): $(STRTOK).o
	$(GCC) -o $(STRTOK) obj/$(STRTOK).o $(LDFLAGS)
$(STRTOK).o:
	$(GCC) -o obj/$(STRTOK).o -c $(STRTOK).c $(CFLAGS)

$(STRVERSCMP): $(STRVERSCMP).o
	$(GCC) -o $(STRVERSCMP) obj/$(STRVERSCMP).o $(LDFLAGS)
$(STRVERSCMP).o:
	$(GCC) -o obj/$(STRVERSCMP).o -c $(STRVERSCMP).c $(CFLAGS)

$(VPRINTF): $(VPRINTF).o
	$(GCC) -o $(VPRINTF) obj/$(VPRINTF).o $(LDFLAGS)
$(VPRINTF).o:
	$(GCC) -o obj/$(VPRINTF).o -c $(VPRINTF).c $(CFLAGS)

$(VSNPRINTF): $(VSNPRINTF).o
	$(GCC) -o $(VSNPRINTF) obj/$(VSNPRINTF).o $(LDFLAGS)
$(VSNPRINTF).o:
	$(GCC) -o obj/$(VSNPRINTF).o -c $(VSNPRINTF).c $(CFLAGS)

#top Makefile.fbsd¶

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_MEMMEM=1 -DHAVE_STRNCASECMP=1 -DHAVE_STRNCASESTR=1 -DHAVE_STRSEP=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

BASENAME    = basename
GETCHAR     = getchar
GETS        = gets
MEMCCPY     = memccpy
MEMCHR      = memchr
MEMCMP      = memcmp
MEMCPY      = memcpy
MEMMEM      = memmem
MEMMOVE     = memmove
MEMPCPY     = mempcpy
MEMRCHR     = memrchr
MEMSET      = memset
PRINTF      = printf
PUTCHAR     = putchar
PUTS        = puts
SCANF       = scanf
SNPRINTF    = snprintf
SSCANF      = sscanf
STRCASESTR  = strcasestr
STRCHR      = strchr
STRCOLL     = strcoll
STRCSPN     = strcspn
STRERROR    = strerror
STRNCASECMP = strncasecmp
STRNCAT     = strncat
STRNCMP     = strncmp
STRNCPY     = strncpy
STRNDUP     = strndup
STRNLEN     = strnlen
STRPBRK     = strpbrk
STRRCHR     = strrchr
STRSEP      = strsep
STRSIGNAL   = strsignal
STRSPN      = strspn
STRSTR      = strstr
STRTOK      = strtok
STRVERSCMP  = strverscmp
VPRINTF     = vprintf
VSNPRINTF   = vsnprintf



all: objdir make

objdir:
	$(MKDCMD) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(BASENAME)
#make: $(GETCHAR)
#make: $(GETS)
#make: $(MEMCCPY)
#make: $(MEMCHR)
#make: $(MEMCMP)
#make: $(MEMCPY)
#make: $(MEMMEM)
#make: $(MEMMOVE)
#make: $(MEMPCPY)
#make: $(MEMRCHR)
#make: $(MEMSET)
#make: $(PRINTF)
#make: $(PUTCHAR)
#make: $(PUTS)
#make: $(SCANF)
#make: $(SNPRINTF)
#make: $(SSCANF)
#make: $(STRCASESTR)
#make: $(STRCHR)
#make: $(STRCOLL)
#make: $(STRCSPN)
#make: $(STRERROR)
#make: $(STRNCASECMP)
#make: $(STRNCAT)
#make: $(STRNCMP)
#make: $(STRNCPY)
#make: $(STRNDUP)
#make: $(STRNLEN)
#make: $(STRPBRK)
#make: $(STRRCHR)
#make: $(STRSEP)
#make: $(STRSIGNAL)
#make: $(STRSPN)
#make: $(STRSTR)
#make: $(STRTOK)
#make: $(STRVERSCMP)
#make: $(VPRINTF)
#make: $(VSNPRINTF)
make: $(BASENAME) $(GETCHAR) $(GETS) $(MEMCCPY) $(MEMCHR) $(MEMCMP) $(MEMCPY) $(MEMMEM) $(MEMMOVE) $(MEMPCPY) $(MEMRCHR) $(MEMSET) $(PRINTF) $(PUTCHAR) $(PUTS) $(SCANF) $(SNPRINTF) $(SSCANF) $(STRCASESTR) $(STRCHR) $(STRCOLL) $(STRCSPN) $(STRERROR) $(STRNCASECMP) $(STRNCAT) $(STRNCMP) $(STRNCPY) $(STRNDUP) $(STRNLEN) $(STRPBRK) $(STRRCHR) $(STRSEP) $(STRSIGNAL) $(STRSPN) $(STRSTR) $(STRTOK) $(STRVERSCMP) $(VPRINTF) $(VSNPRINTF)



$(BASENAME): $(BASENAME).o
	$(GCC) -o $(BASENAME) obj/$(BASENAME).o $(LDFLAGS)
$(BASENAME).o:
	$(GCC) -o obj/$(BASENAME).o -c $(BASENAME).c $(CFLAGS)

$(GETCHAR): $(GETCHAR).o
	$(GCC) -o $(GETCHAR) obj/$(GETCHAR).o $(LDFLAGS)
$(GETCHAR).o:
	$(GCC) -o obj/$(GETCHAR).o -c $(GETCHAR).c $(CFLAGS)

$(GETS): $(GETS).o
	$(GCC) -o $(GETS) obj/$(GETS).o $(LDFLAGS)
$(GETS).o:
	$(GCC) -o obj/$(GETS).o -c $(GETS).c $(CFLAGS)

$(MEMCCPY): $(MEMCCPY).o
	$(GCC) -o $(MEMCCPY) obj/$(MEMCCPY).o $(LDFLAGS)
$(MEMCCPY).o:
	$(GCC) -o obj/$(MEMCCPY).o -c $(MEMCCPY).c $(CFLAGS)

$(MEMCHR): $(MEMCHR).o
	$(GCC) -o $(MEMCHR) obj/$(MEMCHR).o $(LDFLAGS)
$(MEMCHR).o:
	$(GCC) -o obj/$(MEMCHR).o -c $(MEMCHR).c $(CFLAGS)

$(MEMCMP): $(MEMCMP).o
	$(GCC) -o $(MEMCMP) obj/$(MEMCMP).o $(LDFLAGS)
$(MEMCMP).o:
	$(GCC) -o obj/$(MEMCMP).o -c $(MEMCMP).c $(CFLAGS)

$(MEMCPY): $(MEMCPY).o
	$(GCC) -o $(MEMCPY) obj/$(MEMCPY).o $(LDFLAGS)
$(MEMCPY).o:
	$(GCC) -o obj/$(MEMCPY).o -c $(MEMCPY).c $(CFLAGS)

$(MEMMEM): $(MEMMEM).o
	$(GCC) -o $(MEMMEM) obj/$(MEMMEM).o $(LDFLAGS)
$(MEMMEM).o:
	$(GCC) -o obj/$(MEMMEM).o -c $(MEMMEM).c $(CFLAGS)

$(MEMMOVE): $(MEMMOVE).o
	$(GCC) -o $(MEMMOVE) obj/$(MEMMOVE).o $(LDFLAGS)
$(MEMMOVE).o:
	$(GCC) -o obj/$(MEMMOVE).o -c $(MEMMOVE).c $(CFLAGS)

$(MEMPCPY): $(MEMPCPY).o
	$(GCC) -o $(MEMPCPY) obj/$(MEMPCPY).o $(LDFLAGS)
$(MEMPCPY).o:
	$(GCC) -o obj/$(MEMPCPY).o -c $(MEMPCPY).c $(CFLAGS)

$(MEMRCHR): $(MEMRCHR).o
	$(GCC) -o $(MEMRCHR) obj/$(MEMRCHR).o $(LDFLAGS)
$(MEMRCHR).o:
	$(GCC) -o obj/$(MEMRCHR).o -c $(MEMRCHR).c $(CFLAGS)

$(MEMSET): $(MEMSET).o
	$(GCC) -o $(MEMSET) obj/$(MEMSET).o $(LDFLAGS)
$(MEMSET).o:
	$(GCC) -o obj/$(MEMSET).o -c $(MEMSET).c $(CFLAGS)

$(PRINTF): $(PRINTF).o
	$(GCC) -o $(PRINTF) obj/$(PRINTF).o $(LDFLAGS)
$(PRINTF).o:
	$(GCC) -o obj/$(PRINTF).o -c $(PRINTF).c $(CFLAGS)

$(PUTCHAR): $(PUTCHAR).o
	$(GCC) -o $(PUTCHAR) obj/$(PUTCHAR).o $(LDFLAGS)
$(PUTCHAR).o:
	$(GCC) -o obj/$(PUTCHAR).o -c $(PUTCHAR).c $(CFLAGS)

$(PUTS): $(PUTS).o
	$(GCC) -o $(PUTS) obj/$(PUTS).o $(LDFLAGS)
$(PUTS).o:
	$(GCC) -o obj/$(PUTS).o -c $(PUTS).c $(CFLAGS)

$(SCANF): $(SCANF).o
	$(GCC) -o $(SCANF) obj/$(SCANF).o $(LDFLAGS)
$(SCANF).o:
	$(GCC) -o obj/$(SCANF).o -c $(SCANF).c $(CFLAGS)

$(SNPRINTF): $(SNPRINTF).o
	$(GCC) -o $(SNPRINTF) obj/$(SNPRINTF).o $(LDFLAGS)
$(SNPRINTF).o:
	$(GCC) -o obj/$(SNPRINTF).o -c $(SNPRINTF).c $(CFLAGS)

$(SSCANF): $(SSCANF).o
	$(GCC) -o $(SSCANF) obj/$(SSCANF).o $(LDFLAGS)
$(SSCANF).o:
	$(GCC) -o obj/$(SSCANF).o -c $(SSCANF).c $(CFLAGS)

$(STRCASESTR): $(STRCASESTR).o
	$(GCC) -o $(STRCASESTR) obj/$(STRCASESTR).o $(LDFLAGS)
$(STRCASESTR).o:
	$(GCC) -o obj/$(STRCASESTR).o -c $(STRCASESTR).c $(CFLAGS)

$(STRCHR): $(STRCHR).o
	$(GCC) -o $(STRCHR) obj/$(STRCHR).o $(LDFLAGS)
$(STRCHR).o:
	$(GCC) -o obj/$(STRCHR).o -c $(STRCHR).c $(CFLAGS)

$(STRCOLL): $(STRCOLL).o
	$(GCC) -o $(STRCOLL) obj/$(STRCOLL).o $(LDFLAGS)
$(STRCOLL).o:
	$(GCC) -o obj/$(STRCOLL).o -c $(STRCOLL).c $(CFLAGS)

$(STRCSPN): $(STRCSPN).o
	$(GCC) -o $(STRCSPN) obj/$(STRCSPN).o $(LDFLAGS)
$(STRCSPN).o:
	$(GCC) -o obj/$(STRCSPN).o -c $(STRCSPN).c $(CFLAGS)

$(STRERROR): $(STRERROR).o
	$(GCC) -o $(STRERROR) obj/$(STRERROR).o $(LDFLAGS)
$(STRERROR).o:
	$(GCC) -o obj/$(STRERROR).o -c $(STRERROR).c $(CFLAGS)

$(STRNCASECMP): $(STRNCASECMP).o
	$(GCC) -o $(STRNCASECMP) obj/$(STRNCASECMP).o $(LDFLAGS)
$(STRNCASECMP).o:
	$(GCC) -o obj/$(STRNCASECMP).o -c $(STRNCASECMP).c $(CFLAGS)

$(STRNCAT): $(STRNCAT).o
	$(GCC) -o $(STRNCAT) obj/$(STRNCAT).o $(LDFLAGS)
$(STRNCAT).o:
	$(GCC) -o obj/$(STRNCAT).o -c $(STRNCAT).c $(CFLAGS)

$(STRNCMP): $(STRNCMP).o
	$(GCC) -o $(STRNCMP) obj/$(STRNCMP).o $(LDFLAGS)
$(STRNCMP).o:
	$(GCC) -o obj/$(STRNCMP).o -c $(STRNCMP).c $(CFLAGS)

$(STRNCPY): $(STRNCPY).o
	$(GCC) -o $(STRNCPY) obj/$(STRNCPY).o $(LDFLAGS)
$(STRNCPY).o:
	$(GCC) -o obj/$(STRNCPY).o -c $(STRNCPY).c $(CFLAGS)

$(STRNDUP): $(STRNDUP).o
	$(GCC) -o $(STRNDUP) obj/$(STRNDUP).o $(LDFLAGS)
$(STRNDUP).o:
	$(GCC) -o obj/$(STRNDUP).o -c $(STRNDUP).c $(CFLAGS)

$(STRNLEN): $(STRNLEN).o
	$(GCC) -o $(STRNLEN) obj/$(STRNLEN).o $(LDFLAGS)
$(STRNLEN).o:
	$(GCC) -o obj/$(STRNLEN).o -c $(STRNLEN).c $(CFLAGS)

$(STRPBRK): $(STRPBRK).o
	$(GCC) -o $(STRPBRK) obj/$(STRPBRK).o $(LDFLAGS)
$(STRPBRK).o:
	$(GCC) -o obj/$(STRPBRK).o -c $(STRPBRK).c $(CFLAGS)

$(STRRCHR): $(STRRCHR).o
	$(GCC) -o $(STRRCHR) obj/$(STRRCHR).o $(LDFLAGS)
$(STRRCHR).o:
	$(GCC) -o obj/$(STRRCHR).o -c $(STRRCHR).c $(CFLAGS)

$(STRSEP): $(STRSEP).o
	$(GCC) -o $(STRSEP) obj/$(STRSEP).o $(LDFLAGS)
$(STRSEP).o:
	$(GCC) -o obj/$(STRSEP).o -c $(STRSEP).c $(CFLAGS)

$(STRSIGNAL): $(STRSIGNAL).o
	$(GCC) -o $(STRSIGNAL) obj/$(STRSIGNAL).o $(LDFLAGS)
$(STRSIGNAL).o:
	$(GCC) -o obj/$(STRSIGNAL).o -c $(STRSIGNAL).c $(CFLAGS)

$(STRSPN): $(STRSPN).o
	$(GCC) -o $(STRSPN) obj/$(STRSPN).o $(LDFLAGS)
$(STRSPN).o:
	$(GCC) -o obj/$(STRSPN).o -c $(STRSPN).c $(CFLAGS)

$(STRSTR): $(STRSTR).o
	$(GCC) -o $(STRSTR) obj/$(STRSTR).o $(LDFLAGS)
$(STRSTR).o:
	$(GCC) -o obj/$(STRSTR).o -c $(STRSTR).c $(CFLAGS)

$(STRTOK): $(STRTOK).o
	$(GCC) -o $(STRTOK) obj/$(STRTOK).o $(LDFLAGS)
$(STRTOK).o:
	$(GCC) -o obj/$(STRTOK).o -c $(STRTOK).c $(CFLAGS)

$(STRVERSCMP): $(STRVERSCMP).o
	$(GCC) -o $(STRVERSCMP) obj/$(STRVERSCMP).o $(LDFLAGS)
$(STRVERSCMP).o:
	$(GCC) -o obj/$(STRVERSCMP).o -c $(STRVERSCMP).c $(CFLAGS)

$(VPRINTF): $(VPRINTF).o
	$(GCC) -o $(VPRINTF) obj/$(VPRINTF).o $(LDFLAGS)
$(VPRINTF).o:
	$(GCC) -o obj/$(VPRINTF).o -c $(VPRINTF).c $(CFLAGS)

$(VSNPRINTF): $(VSNPRINTF).o
	$(GCC) -o $(VSNPRINTF) obj/$(VSNPRINTF).o $(LDFLAGS)
$(VSNPRINTF).o:
	$(GCC) -o obj/$(VSNPRINTF).o -c $(VSNPRINTF).c $(CFLAGS)

#top Makefile.sol¶

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_MEMMEM=1 -DHAVE_STRNCASECMP=1 -DHAVE_STRNCASESTR=1 -DHAVE_STRNDUP=1 -DHAVE_STRNLEN=1 -DHAVE_STRSEP=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

BASENAME    = basename
GETCHAR     = getchar
GETS        = gets
MEMCCPY     = memccpy
MEMCHR      = memchr
MEMCMP      = memcmp
MEMCPY      = memcpy
MEMMEM      = memmem
MEMMOVE     = memmove
MEMPCPY     = mempcpy
MEMRCHR     = memrchr
MEMSET      = memset
PRINTF      = printf
PUTCHAR     = putchar
PUTS        = puts
SCANF       = scanf
SNPRINTF    = snprintf
SSCANF      = sscanf
STRCASESTR  = strcasestr
STRCHR      = strchr
STRCOLL     = strcoll
STRCSPN     = strcspn
STRERROR    = strerror
STRNCASECMP = strncasecmp
STRNCAT     = strncat
STRNCMP     = strncmp
STRNCPY     = strncpy
STRNDUP     = strndup
STRNLEN     = strnlen
STRPBRK     = strpbrk
STRRCHR     = strrchr
STRSEP      = strsep
STRSIGNAL   = strsignal
STRSPN      = strspn
STRSTR      = strstr
STRTOK      = strtok
STRVERSCMP  = strverscmp
VPRINTF     = vprintf
VSNPRINTF   = vsnprintf



all: objdir make

objdir:
	$(MKDCMD) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(BASENAME)
#make: $(GETCHAR)
#make: $(GETS)
#make: $(MEMCCPY)
#make: $(MEMCHR)
#make: $(MEMCMP)
#make: $(MEMCPY)
#make: $(MEMMEM)
#make: $(MEMMOVE)
#make: $(MEMPCPY)
#make: $(MEMRCHR)
#make: $(MEMSET)
#make: $(PRINTF)
#make: $(PUTCHAR)
#make: $(PUTS)
#make: $(SCANF)
#make: $(SNPRINTF)
#make: $(SSCANF)
#make: $(STRCASESTR)
#make: $(STRCHR)
#make: $(STRCOLL)
#make: $(STRCSPN)
#make: $(STRERROR)
#make: $(STRNCASECMP)
#make: $(STRNCAT)
#make: $(STRNCMP)
#make: $(STRNCPY)
#make: $(STRNDUP)
#make: $(STRNLEN)
#make: $(STRPBRK)
#make: $(STRRCHR)
#make: $(STRSEP)
#make: $(STRSIGNAL)
#make: $(STRSPN)
#make: $(STRSTR)
#make: $(STRTOK)
#make: $(STRVERSCMP)
#make: $(VPRINTF)
#make: $(VSNPRINTF)
make: $(BASENAME) $(GETCHAR) $(GETS) $(MEMCCPY) $(MEMCHR) $(MEMCMP) $(MEMCPY) $(MEMMEM) $(MEMMOVE) $(MEMPCPY) $(MEMRCHR) $(MEMSET) $(PRINTF) $(PUTCHAR) $(PUTS) $(SCANF) $(SNPRINTF) $(SSCANF) $(STRCASESTR) $(STRCHR) $(STRCOLL) $(STRCSPN) $(STRERROR) $(STRNCASECMP) $(STRNCAT) $(STRNCMP) $(STRNCPY) $(STRNDUP) $(STRNLEN) $(STRPBRK) $(STRRCHR) $(STRSEP) $(STRSIGNAL) $(STRSPN) $(STRSTR) $(STRTOK) $(STRVERSCMP) $(VPRINTF) $(VSNPRINTF)



$(BASENAME): $(BASENAME).o
	$(GCC) -o $(BASENAME) obj/$(BASENAME).o $(LDFLAGS)
$(BASENAME).o:
	$(GCC) -o obj/$(BASENAME).o -c $(BASENAME).c $(CFLAGS)

$(GETCHAR): $(GETCHAR).o
	$(GCC) -o $(GETCHAR) obj/$(GETCHAR).o $(LDFLAGS)
$(GETCHAR).o:
	$(GCC) -o obj/$(GETCHAR).o -c $(GETCHAR).c $(CFLAGS)

$(GETS): $(GETS).o
	$(GCC) -o $(GETS) obj/$(GETS).o $(LDFLAGS)
$(GETS).o:
	$(GCC) -o obj/$(GETS).o -c $(GETS).c $(CFLAGS)

$(MEMCCPY): $(MEMCCPY).o
	$(GCC) -o $(MEMCCPY) obj/$(MEMCCPY).o $(LDFLAGS)
$(MEMCCPY).o:
	$(GCC) -o obj/$(MEMCCPY).o -c $(MEMCCPY).c $(CFLAGS)

$(MEMCHR): $(MEMCHR).o
	$(GCC) -o $(MEMCHR) obj/$(MEMCHR).o $(LDFLAGS)
$(MEMCHR).o:
	$(GCC) -o obj/$(MEMCHR).o -c $(MEMCHR).c $(CFLAGS)

$(MEMCMP): $(MEMCMP).o
	$(GCC) -o $(MEMCMP) obj/$(MEMCMP).o $(LDFLAGS)
$(MEMCMP).o:
	$(GCC) -o obj/$(MEMCMP).o -c $(MEMCMP).c $(CFLAGS)

$(MEMCPY): $(MEMCPY).o
	$(GCC) -o $(MEMCPY) obj/$(MEMCPY).o $(LDFLAGS)
$(MEMCPY).o:
	$(GCC) -o obj/$(MEMCPY).o -c $(MEMCPY).c $(CFLAGS)

$(MEMMEM): $(MEMMEM).o
	$(GCC) -o $(MEMMEM) obj/$(MEMMEM).o $(LDFLAGS)
$(MEMMEM).o:
	$(GCC) -o obj/$(MEMMEM).o -c $(MEMMEM).c $(CFLAGS)

$(MEMMOVE): $(MEMMOVE).o
	$(GCC) -o $(MEMMOVE) obj/$(MEMMOVE).o $(LDFLAGS)
$(MEMMOVE).o:
	$(GCC) -o obj/$(MEMMOVE).o -c $(MEMMOVE).c $(CFLAGS)

$(MEMPCPY): $(MEMPCPY).o
	$(GCC) -o $(MEMPCPY) obj/$(MEMPCPY).o $(LDFLAGS)
$(MEMPCPY).o:
	$(GCC) -o obj/$(MEMPCPY).o -c $(MEMPCPY).c $(CFLAGS)

$(MEMRCHR): $(MEMRCHR).o
	$(GCC) -o $(MEMRCHR) obj/$(MEMRCHR).o $(LDFLAGS)
$(MEMRCHR).o:
	$(GCC) -o obj/$(MEMRCHR).o -c $(MEMRCHR).c $(CFLAGS)

$(MEMSET): $(MEMSET).o
	$(GCC) -o $(MEMSET) obj/$(MEMSET).o $(LDFLAGS)
$(MEMSET).o:
	$(GCC) -o obj/$(MEMSET).o -c $(MEMSET).c $(CFLAGS)

$(PRINTF): $(PRINTF).o
	$(GCC) -o $(PRINTF) obj/$(PRINTF).o $(LDFLAGS)
$(PRINTF).o:
	$(GCC) -o obj/$(PRINTF).o -c $(PRINTF).c $(CFLAGS)

$(PUTCHAR): $(PUTCHAR).o
	$(GCC) -o $(PUTCHAR) obj/$(PUTCHAR).o $(LDFLAGS)
$(PUTCHAR).o:
	$(GCC) -o obj/$(PUTCHAR).o -c $(PUTCHAR).c $(CFLAGS)

$(PUTS): $(PUTS).o
	$(GCC) -o $(PUTS) obj/$(PUTS).o $(LDFLAGS)
$(PUTS).o:
	$(GCC) -o obj/$(PUTS).o -c $(PUTS).c $(CFLAGS)

$(SCANF): $(SCANF).o
	$(GCC) -o $(SCANF) obj/$(SCANF).o $(LDFLAGS)
$(SCANF).o:
	$(GCC) -o obj/$(SCANF).o -c $(SCANF).c $(CFLAGS)

$(SNPRINTF): $(SNPRINTF).o
	$(GCC) -o $(SNPRINTF) obj/$(SNPRINTF).o $(LDFLAGS)
$(SNPRINTF).o:
	$(GCC) -o obj/$(SNPRINTF).o -c $(SNPRINTF).c $(CFLAGS)

$(SSCANF): $(SSCANF).o
	$(GCC) -o $(SSCANF) obj/$(SSCANF).o $(LDFLAGS)
$(SSCANF).o:
	$(GCC) -o obj/$(SSCANF).o -c $(SSCANF).c $(CFLAGS)

$(STRCASESTR): $(STRCASESTR).o
	$(GCC) -o $(STRCASESTR) obj/$(STRCASESTR).o $(LDFLAGS)
$(STRCASESTR).o:
	$(GCC) -o obj/$(STRCASESTR).o -c $(STRCASESTR).c $(CFLAGS)

$(STRCHR): $(STRCHR).o
	$(GCC) -o $(STRCHR) obj/$(STRCHR).o $(LDFLAGS)
$(STRCHR).o:
	$(GCC) -o obj/$(STRCHR).o -c $(STRCHR).c $(CFLAGS)

$(STRCOLL): $(STRCOLL).o
	$(GCC) -o $(STRCOLL) obj/$(STRCOLL).o $(LDFLAGS)
$(STRCOLL).o:
	$(GCC) -o obj/$(STRCOLL).o -c $(STRCOLL).c $(CFLAGS)

$(STRCSPN): $(STRCSPN).o
	$(GCC) -o $(STRCSPN) obj/$(STRCSPN).o $(LDFLAGS)
$(STRCSPN).o:
	$(GCC) -o obj/$(STRCSPN).o -c $(STRCSPN).c $(CFLAGS)

$(STRERROR): $(STRERROR).o
	$(GCC) -o $(STRERROR) obj/$(STRERROR).o $(LDFLAGS)
$(STRERROR).o:
	$(GCC) -o obj/$(STRERROR).o -c $(STRERROR).c $(CFLAGS)

$(STRNCASECMP): $(STRNCASECMP).o
	$(GCC) -o $(STRNCASECMP) obj/$(STRNCASECMP).o $(LDFLAGS)
$(STRNCASECMP).o:
	$(GCC) -o obj/$(STRNCASECMP).o -c $(STRNCASECMP).c $(CFLAGS)

$(STRNCAT): $(STRNCAT).o
	$(GCC) -o $(STRNCAT) obj/$(STRNCAT).o $(LDFLAGS)
$(STRNCAT).o:
	$(GCC) -o obj/$(STRNCAT).o -c $(STRNCAT).c $(CFLAGS)

$(STRNCMP): $(STRNCMP).o
	$(GCC) -o $(STRNCMP) obj/$(STRNCMP).o $(LDFLAGS)
$(STRNCMP).o:
	$(GCC) -o obj/$(STRNCMP).o -c $(STRNCMP).c $(CFLAGS)

$(STRNCPY): $(STRNCPY).o
	$(GCC) -o $(STRNCPY) obj/$(STRNCPY).o $(LDFLAGS)
$(STRNCPY).o:
	$(GCC) -o obj/$(STRNCPY).o -c $(STRNCPY).c $(CFLAGS)

$(STRNDUP): $(STRNDUP).o
	$(GCC) -o $(STRNDUP) obj/$(STRNDUP).o $(LDFLAGS)
$(STRNDUP).o:
	$(GCC) -o obj/$(STRNDUP).o -c $(STRNDUP).c $(CFLAGS)

$(STRNLEN): $(STRNLEN).o
	$(GCC) -o $(STRNLEN) obj/$(STRNLEN).o $(LDFLAGS)
$(STRNLEN).o:
	$(GCC) -o obj/$(STRNLEN).o -c $(STRNLEN).c $(CFLAGS)

$(STRPBRK): $(STRPBRK).o
	$(GCC) -o $(STRPBRK) obj/$(STRPBRK).o $(LDFLAGS)
$(STRPBRK).o:
	$(GCC) -o obj/$(STRPBRK).o -c $(STRPBRK).c $(CFLAGS)

$(STRRCHR): $(STRRCHR).o
	$(GCC) -o $(STRRCHR) obj/$(STRRCHR).o $(LDFLAGS)
$(STRRCHR).o:
	$(GCC) -o obj/$(STRRCHR).o -c $(STRRCHR).c $(CFLAGS)

$(STRSEP): $(STRSEP).o
	$(GCC) -o $(STRSEP) obj/$(STRSEP).o $(LDFLAGS)
$(STRSEP).o:
	$(GCC) -o obj/$(STRSEP).o -c $(STRSEP).c $(CFLAGS)

$(STRSIGNAL): $(STRSIGNAL).o
	$(GCC) -o $(STRSIGNAL) obj/$(STRSIGNAL).o $(LDFLAGS)
$(STRSIGNAL).o:
	$(GCC) -o obj/$(STRSIGNAL).o -c $(STRSIGNAL).c $(CFLAGS)

$(STRSPN): $(STRSPN).o
	$(GCC) -o $(STRSPN) obj/$(STRSPN).o $(LDFLAGS)
$(STRSPN).o:
	$(GCC) -o obj/$(STRSPN).o -c $(STRSPN).c $(CFLAGS)

$(STRSTR): $(STRSTR).o
	$(GCC) -o $(STRSTR) obj/$(STRSTR).o $(LDFLAGS)
$(STRSTR).o:
	$(GCC) -o obj/$(STRSTR).o -c $(STRSTR).c $(CFLAGS)

$(STRTOK): $(STRTOK).o
	$(GCC) -o $(STRTOK) obj/$(STRTOK).o $(LDFLAGS)
$(STRTOK).o:
	$(GCC) -o obj/$(STRTOK).o -c $(STRTOK).c $(CFLAGS)

$(STRVERSCMP): $(STRVERSCMP).o
	$(GCC) -o $(STRVERSCMP) obj/$(STRVERSCMP).o $(LDFLAGS)
$(STRVERSCMP).o:
	$(GCC) -o obj/$(STRVERSCMP).o -c $(STRVERSCMP).c $(CFLAGS)

$(VPRINTF): $(VPRINTF).o
	$(GCC) -o $(VPRINTF) obj/$(VPRINTF).o $(LDFLAGS)
$(VPRINTF).o:
	$(GCC) -o obj/$(VPRINTF).o -c $(VPRINTF).c $(CFLAGS)

$(VSNPRINTF): $(VSNPRINTF).o
	$(GCC) -o $(VSNPRINTF) obj/$(VSNPRINTF).o $(LDFLAGS)
$(VSNPRINTF).o:
	$(GCC) -o obj/$(VSNPRINTF).o -c $(VSNPRINTF).c $(CFLAGS)

#top Makefile.beos¶

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_STRNCASECMP=1 -DHAVE_STRNCASESTR=1 -DHAVE_STRNDUP=1 -DHAVE_STRNLEN=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

BASENAME    = basename
GETCHAR     = getchar
GETS        = gets
MEMCCPY     = memccpy
MEMCHR      = memchr
MEMCMP      = memcmp
MEMCPY      = memcpy
MEMMEM      = memmem
MEMMOVE     = memmove
MEMPCPY     = mempcpy
MEMRCHR     = memrchr
MEMSET      = memset
PRINTF      = printf
PUTCHAR     = putchar
PUTS        = puts
SCANF       = scanf
SNPRINTF    = snprintf
SSCANF      = sscanf
STRCASESTR  = strcasestr
STRCHR      = strchr
STRCOLL     = strcoll
STRCSPN     = strcspn
STRERROR    = strerror
STRNCASECMP = strncasecmp
STRNCAT     = strncat
STRNCMP     = strncmp
STRNCPY     = strncpy
STRNDUP     = strndup
STRNLEN     = strnlen
STRPBRK     = strpbrk
STRRCHR     = strrchr
STRSEP      = strsep
STRSIGNAL   = strsignal
STRSPN      = strspn
STRSTR      = strstr
STRTOK      = strtok
STRVERSCMP  = strverscmp
VPRINTF     = vprintf
VSNPRINTF   = vsnprintf



all: objdir make

objdir:
	$(MKDCMD) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(BASENAME)
#make: $(GETCHAR)
#make: $(GETS)
#make: $(MEMCCPY)
#make: $(MEMCHR)
#make: $(MEMCMP)
#make: $(MEMCPY)
#make: $(MEMMEM)
#make: $(MEMMOVE)
#make: $(MEMPCPY)
#make: $(MEMRCHR)
#make: $(MEMSET)
#make: $(PRINTF)
#make: $(PUTCHAR)
#make: $(PUTS)
#make: $(SCANF)
#make: $(SNPRINTF)
#make: $(SSCANF)
#make: $(STRCASESTR)
#make: $(STRCHR)
#make: $(STRCOLL)
#make: $(STRCSPN)
#make: $(STRERROR)
#make: $(STRNCASECMP)
#make: $(STRNCAT)
#make: $(STRNCMP)
#make: $(STRNCPY)
#make: $(STRNDUP)
#make: $(STRNLEN)
#make: $(STRPBRK)
#make: $(STRRCHR)
#make: $(STRSEP)
#make: $(STRSIGNAL)
#make: $(STRSPN)
#make: $(STRSTR)
#make: $(STRTOK)
#make: $(STRVERSCMP)
#make: $(VPRINTF)
#make: $(VSNPRINTF)
make: $(BASENAME) $(GETCHAR) $(GETS) $(MEMCCPY) $(MEMCHR) $(MEMCMP) $(MEMCPY) $(MEMMEM) $(MEMMOVE) $(MEMPCPY) $(MEMRCHR) $(MEMSET) $(PRINTF) $(PUTCHAR) $(PUTS) $(SCANF) $(SNPRINTF) $(SSCANF) $(STRCASESTR) $(STRCHR) $(STRCOLL) $(STRCSPN) $(STRERROR) $(STRNCASECMP) $(STRNCAT) $(STRNCMP) $(STRNCPY) $(STRNDUP) $(STRNLEN) $(STRPBRK) $(STRRCHR) $(STRSEP) $(STRSIGNAL) $(STRSPN) $(STRSTR) $(STRTOK) $(STRVERSCMP) $(VPRINTF) $(VSNPRINTF)



$(BASENAME): $(BASENAME).o
	$(GCC) -o $(BASENAME) obj/$(BASENAME).o $(LDFLAGS)
$(BASENAME).o:
	$(GCC) -o obj/$(BASENAME).o -c $(BASENAME).c $(CFLAGS)

$(GETCHAR): $(GETCHAR).o
	$(GCC) -o $(GETCHAR) obj/$(GETCHAR).o $(LDFLAGS)
$(GETCHAR).o:
	$(GCC) -o obj/$(GETCHAR).o -c $(GETCHAR).c $(CFLAGS)

$(GETS): $(GETS).o
	$(GCC) -o $(GETS) obj/$(GETS).o $(LDFLAGS)
$(GETS).o:
	$(GCC) -o obj/$(GETS).o -c $(GETS).c $(CFLAGS)

$(MEMCCPY): $(MEMCCPY).o
	$(GCC) -o $(MEMCCPY) obj/$(MEMCCPY).o $(LDFLAGS)
$(MEMCCPY).o:
	$(GCC) -o obj/$(MEMCCPY).o -c $(MEMCCPY).c $(CFLAGS)

$(MEMCHR): $(MEMCHR).o
	$(GCC) -o $(MEMCHR) obj/$(MEMCHR).o $(LDFLAGS)
$(MEMCHR).o:
	$(GCC) -o obj/$(MEMCHR).o -c $(MEMCHR).c $(CFLAGS)

$(MEMCMP): $(MEMCMP).o
	$(GCC) -o $(MEMCMP) obj/$(MEMCMP).o $(LDFLAGS)
$(MEMCMP).o:
	$(GCC) -o obj/$(MEMCMP).o -c $(MEMCMP).c $(CFLAGS)

$(MEMCPY): $(MEMCPY).o
	$(GCC) -o $(MEMCPY) obj/$(MEMCPY).o $(LDFLAGS)
$(MEMCPY).o:
	$(GCC) -o obj/$(MEMCPY).o -c $(MEMCPY).c $(CFLAGS)

$(MEMMEM): $(MEMMEM).o
	$(GCC) -o $(MEMMEM) obj/$(MEMMEM).o $(LDFLAGS)
$(MEMMEM).o:
	$(GCC) -o obj/$(MEMMEM).o -c $(MEMMEM).c $(CFLAGS)

$(MEMMOVE): $(MEMMOVE).o
	$(GCC) -o $(MEMMOVE) obj/$(MEMMOVE).o $(LDFLAGS)
$(MEMMOVE).o:
	$(GCC) -o obj/$(MEMMOVE).o -c $(MEMMOVE).c $(CFLAGS)

$(MEMPCPY): $(MEMPCPY).o
	$(GCC) -o $(MEMPCPY) obj/$(MEMPCPY).o $(LDFLAGS)
$(MEMPCPY).o:
	$(GCC) -o obj/$(MEMPCPY).o -c $(MEMPCPY).c $(CFLAGS)

$(MEMRCHR): $(MEMRCHR).o
	$(GCC) -o $(MEMRCHR) obj/$(MEMRCHR).o $(LDFLAGS)
$(MEMRCHR).o:
	$(GCC) -o obj/$(MEMRCHR).o -c $(MEMRCHR).c $(CFLAGS)

$(MEMSET): $(MEMSET).o
	$(GCC) -o $(MEMSET) obj/$(MEMSET).o $(LDFLAGS)
$(MEMSET).o:
	$(GCC) -o obj/$(MEMSET).o -c $(MEMSET).c $(CFLAGS)

$(PRINTF): $(PRINTF).o
	$(GCC) -o $(PRINTF) obj/$(PRINTF).o $(LDFLAGS)
$(PRINTF).o:
	$(GCC) -o obj/$(PRINTF).o -c $(PRINTF).c $(CFLAGS)

$(PUTCHAR): $(PUTCHAR).o
	$(GCC) -o $(PUTCHAR) obj/$(PUTCHAR).o $(LDFLAGS)
$(PUTCHAR).o:
	$(GCC) -o obj/$(PUTCHAR).o -c $(PUTCHAR).c $(CFLAGS)

$(PUTS): $(PUTS).o
	$(GCC) -o $(PUTS) obj/$(PUTS).o $(LDFLAGS)
$(PUTS).o:
	$(GCC) -o obj/$(PUTS).o -c $(PUTS).c $(CFLAGS)

$(SCANF): $(SCANF).o
	$(GCC) -o $(SCANF) obj/$(SCANF).o $(LDFLAGS)
$(SCANF).o:
	$(GCC) -o obj/$(SCANF).o -c $(SCANF).c $(CFLAGS)

$(SNPRINTF): $(SNPRINTF).o
	$(GCC) -o $(SNPRINTF) obj/$(SNPRINTF).o $(LDFLAGS)
$(SNPRINTF).o:
	$(GCC) -o obj/$(SNPRINTF).o -c $(SNPRINTF).c $(CFLAGS)

$(SSCANF): $(SSCANF).o
	$(GCC) -o $(SSCANF) obj/$(SSCANF).o $(LDFLAGS)
$(SSCANF).o:
	$(GCC) -o obj/$(SSCANF).o -c $(SSCANF).c $(CFLAGS)

$(STRCASESTR): $(STRCASESTR).o
	$(GCC) -o $(STRCASESTR) obj/$(STRCASESTR).o $(LDFLAGS)
$(STRCASESTR).o:
	$(GCC) -o obj/$(STRCASESTR).o -c $(STRCASESTR).c $(CFLAGS)

$(STRCHR): $(STRCHR).o
	$(GCC) -o $(STRCHR) obj/$(STRCHR).o $(LDFLAGS)
$(STRCHR).o:
	$(GCC) -o obj/$(STRCHR).o -c $(STRCHR).c $(CFLAGS)

$(STRCOLL): $(STRCOLL).o
	$(GCC) -o $(STRCOLL) obj/$(STRCOLL).o $(LDFLAGS)
$(STRCOLL).o:
	$(GCC) -o obj/$(STRCOLL).o -c $(STRCOLL).c $(CFLAGS)

$(STRCSPN): $(STRCSPN).o
	$(GCC) -o $(STRCSPN) obj/$(STRCSPN).o $(LDFLAGS)
$(STRCSPN).o:
	$(GCC) -o obj/$(STRCSPN).o -c $(STRCSPN).c $(CFLAGS)

$(STRERROR): $(STRERROR).o
	$(GCC) -o $(STRERROR) obj/$(STRERROR).o $(LDFLAGS)
$(STRERROR).o:
	$(GCC) -o obj/$(STRERROR).o -c $(STRERROR).c $(CFLAGS)

$(STRNCASECMP): $(STRNCASECMP).o
	$(GCC) -o $(STRNCASECMP) obj/$(STRNCASECMP).o $(LDFLAGS)
$(STRNCASECMP).o:
	$(GCC) -o obj/$(STRNCASECMP).o -c $(STRNCASECMP).c $(CFLAGS)

$(STRNCAT): $(STRNCAT).o
	$(GCC) -o $(STRNCAT) obj/$(STRNCAT).o $(LDFLAGS)
$(STRNCAT).o:
	$(GCC) -o obj/$(STRNCAT).o -c $(STRNCAT).c $(CFLAGS)

$(STRNCMP): $(STRNCMP).o
	$(GCC) -o $(STRNCMP) obj/$(STRNCMP).o $(LDFLAGS)
$(STRNCMP).o:
	$(GCC) -o obj/$(STRNCMP).o -c $(STRNCMP).c $(CFLAGS)

$(STRNCPY): $(STRNCPY).o
	$(GCC) -o $(STRNCPY) obj/$(STRNCPY).o $(LDFLAGS)
$(STRNCPY).o:
	$(GCC) -o obj/$(STRNCPY).o -c $(STRNCPY).c $(CFLAGS)

$(STRNDUP): $(STRNDUP).o
	$(GCC) -o $(STRNDUP) obj/$(STRNDUP).o $(LDFLAGS)
$(STRNDUP).o:
	$(GCC) -o obj/$(STRNDUP).o -c $(STRNDUP).c $(CFLAGS)

$(STRNLEN): $(STRNLEN).o
	$(GCC) -o $(STRNLEN) obj/$(STRNLEN).o $(LDFLAGS)
$(STRNLEN).o:
	$(GCC) -o obj/$(STRNLEN).o -c $(STRNLEN).c $(CFLAGS)

$(STRPBRK): $(STRPBRK).o
	$(GCC) -o $(STRPBRK) obj/$(STRPBRK).o $(LDFLAGS)
$(STRPBRK).o:
	$(GCC) -o obj/$(STRPBRK).o -c $(STRPBRK).c $(CFLAGS)

$(STRRCHR): $(STRRCHR).o
	$(GCC) -o $(STRRCHR) obj/$(STRRCHR).o $(LDFLAGS)
$(STRRCHR).o:
	$(GCC) -o obj/$(STRRCHR).o -c $(STRRCHR).c $(CFLAGS)

$(STRSEP): $(STRSEP).o
	$(GCC) -o $(STRSEP) obj/$(STRSEP).o $(LDFLAGS)
$(STRSEP).o:
	$(GCC) -o obj/$(STRSEP).o -c $(STRSEP).c $(CFLAGS)

$(STRSIGNAL): $(STRSIGNAL).o
	$(GCC) -o $(STRSIGNAL) obj/$(STRSIGNAL).o $(LDFLAGS)
$(STRSIGNAL).o:
	$(GCC) -o obj/$(STRSIGNAL).o -c $(STRSIGNAL).c $(CFLAGS)

$(STRSPN): $(STRSPN).o
	$(GCC) -o $(STRSPN) obj/$(STRSPN).o $(LDFLAGS)
$(STRSPN).o:
	$(GCC) -o obj/$(STRSPN).o -c $(STRSPN).c $(CFLAGS)

$(STRSTR): $(STRSTR).o
	$(GCC) -o $(STRSTR) obj/$(STRSTR).o $(LDFLAGS)
$(STRSTR).o:
	$(GCC) -o obj/$(STRSTR).o -c $(STRSTR).c $(CFLAGS)

$(STRTOK): $(STRTOK).o
	$(GCC) -o $(STRTOK) obj/$(STRTOK).o $(LDFLAGS)
$(STRTOK).o:
	$(GCC) -o obj/$(STRTOK).o -c $(STRTOK).c $(CFLAGS)

$(STRVERSCMP): $(STRVERSCMP).o
	$(GCC) -o $(STRVERSCMP) obj/$(STRVERSCMP).o $(LDFLAGS)
$(STRVERSCMP).o:
	$(GCC) -o obj/$(STRVERSCMP).o -c $(STRVERSCMP).c $(CFLAGS)

$(VPRINTF): $(VPRINTF).o
	$(GCC) -o $(VPRINTF) obj/$(VPRINTF).o $(LDFLAGS)
$(VPRINTF).o:
	$(GCC) -o obj/$(VPRINTF).o -c $(VPRINTF).c $(CFLAGS)

$(VSNPRINTF): $(VSNPRINTF).o
	$(GCC) -o $(VSNPRINTF) obj/$(VSNPRINTF).o $(LDFLAGS)
$(VSNPRINTF).o:
	$(GCC) -o obj/$(VSNPRINTF).o -c $(VSNPRINTF).c $(CFLAGS)

#top Makefile.win¶

# Project: Project
# Makefile created

GCC         = gcc
INCS        =
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = del /q /s
MKDCMD      = mkdir

BASENAME    = basename
GETCHAR     = getchar
GETS        = gets
MEMCCPY     = memccpy
MEMCHR      = memchr
MEMCMP      = memcmp
MEMCPY      = memcpy
MEMMEM      = memmem
MEMMOVE     = memmove
MEMPCPY     = mempcpy
MEMRCHR     = memrchr
MEMSET      = memset
PRINTF      = printf
PUTCHAR     = putchar
PUTS        = puts
SCANF       = scanf
SNPRINTF    = snprintf
SSCANF      = sscanf
STRCASESTR  = strcasestr
STRCHR      = strchr
STRCOLL     = strcoll
STRCSPN     = strcspn
STRERROR    = strerror
STRNCASECMP = strncasecmp
STRNCAT     = strncat
STRNCMP     = strncmp
STRNCPY     = strncpy
STRNDUP     = strndup
STRNLEN     = strnlen
STRPBRK     = strpbrk
STRRCHR     = strrchr
STRSEP      = strsep
STRSIGNAL   = strsignal
STRSPN      = strspn
STRSTR      = strstr
STRTOK      = strtok
STRVERSCMP  = strverscmp
VPRINTF     = vprintf
VSNPRINTF   = vsnprintf



all: make

objdir:
	$(MKDCMD) obj\

clean:
	$(RM) obj\*.o *.o *~

#make: $(BASENAME)
#make: $(GETCHAR)
#make: $(GETS)
#make: $(MEMCCPY)
#make: $(MEMCHR)
#make: $(MEMCMP)
#make: $(MEMCPY)
#make: $(MEMMEM)
#make: $(MEMMOVE)
#make: $(MEMPCPY)
#make: $(MEMRCHR)
#make: $(MEMSET)
#make: $(PRINTF)
#make: $(PUTCHAR)
#make: $(PUTS)
#make: $(SCANF)
#make: $(SNPRINTF)
#make: $(SSCANF)
#make: $(STRCASESTR)
#make: $(STRCHR)
#make: $(STRCOLL)
#make: $(STRCSPN)
#make: $(STRERROR)
#make: $(STRNCASECMP)
#make: $(STRNCAT)
#make: $(STRNCMP)
#make: $(STRNCPY)
#make: $(STRNDUP)
#make: $(STRNLEN)
#make: $(STRPBRK)
#make: $(STRRCHR)
#make: $(STRSEP)
#make: $(STRSIGNAL)
#make: $(STRSPN)
#make: $(STRSTR)
#make: $(STRTOK)
#make: $(STRVERSCMP)
#make: $(VPRINTF)
#make: $(VSNPRINTF)
make: $(BASENAME) $(GETCHAR) $(GETS) $(MEMCCPY) $(MEMCHR) $(MEMCMP) $(MEMCPY) $(MEMMEM) $(MEMMOVE) $(MEMPCPY) $(MEMRCHR) $(MEMSET) $(PRINTF) $(PUTCHAR) $(PUTS) $(SCANF) $(SNPRINTF) $(SSCANF) $(STRCASESTR) $(STRCHR) $(STRCOLL) $(STRCSPN) $(STRERROR) $(STRNCASECMP) $(STRNCAT) $(STRNCMP) $(STRNCPY) $(STRNDUP) $(STRNLEN) $(STRPBRK) $(STRRCHR) $(STRSEP) $(STRSIGNAL) $(STRSPN) $(STRSTR) $(STRTOK) $(STRVERSCMP) $(VPRINTF) $(VSNPRINTF)



$(BASENAME): $(BASENAME).o
	$(GCC) -o $(BASENAME) obj/$(BASENAME).o $(LDFLAGS)
$(BASENAME).o:
	$(GCC) -o obj/$(BASENAME).o -c $(BASENAME).c $(CFLAGS)

$(GETCHAR): $(GETCHAR).o
	$(GCC) -o $(GETCHAR) obj/$(GETCHAR).o $(LDFLAGS)
$(GETCHAR).o:
	$(GCC) -o obj/$(GETCHAR).o -c $(GETCHAR).c $(CFLAGS)

$(GETS): $(GETS).o
	$(GCC) -o $(GETS) obj/$(GETS).o $(LDFLAGS)
$(GETS).o:
	$(GCC) -o obj/$(GETS).o -c $(GETS).c $(CFLAGS)

$(MEMCCPY): $(MEMCCPY).o
	$(GCC) -o $(MEMCCPY) obj/$(MEMCCPY).o $(LDFLAGS)
$(MEMCCPY).o:
	$(GCC) -o obj/$(MEMCCPY).o -c $(MEMCCPY).c $(CFLAGS)

$(MEMCHR): $(MEMCHR).o
	$(GCC) -o $(MEMCHR) obj/$(MEMCHR).o $(LDFLAGS)
$(MEMCHR).o:
	$(GCC) -o obj/$(MEMCHR).o -c $(MEMCHR).c $(CFLAGS)

$(MEMCMP): $(MEMCMP).o
	$(GCC) -o $(MEMCMP) obj/$(MEMCMP).o $(LDFLAGS)
$(MEMCMP).o:
	$(GCC) -o obj/$(MEMCMP).o -c $(MEMCMP).c $(CFLAGS)

$(MEMCPY): $(MEMCPY).o
	$(GCC) -o $(MEMCPY) obj/$(MEMCPY).o $(LDFLAGS)
$(MEMCPY).o:
	$(GCC) -o obj/$(MEMCPY).o -c $(MEMCPY).c $(CFLAGS)

$(MEMMEM): $(MEMMEM).o
	$(GCC) -o $(MEMMEM) obj/$(MEMMEM).o $(LDFLAGS)
$(MEMMEM).o:
	$(GCC) -o obj/$(MEMMEM).o -c $(MEMMEM).c $(CFLAGS)

$(MEMMOVE): $(MEMMOVE).o
	$(GCC) -o $(MEMMOVE) obj/$(MEMMOVE).o $(LDFLAGS)
$(MEMMOVE).o:
	$(GCC) -o obj/$(MEMMOVE).o -c $(MEMMOVE).c $(CFLAGS)

$(MEMPCPY): $(MEMPCPY).o
	$(GCC) -o $(MEMPCPY) obj/$(MEMPCPY).o $(LDFLAGS)
$(MEMPCPY).o:
	$(GCC) -o obj/$(MEMPCPY).o -c $(MEMPCPY).c $(CFLAGS)

$(MEMRCHR): $(MEMRCHR).o
	$(GCC) -o $(MEMRCHR) obj/$(MEMRCHR).o $(LDFLAGS)
$(MEMRCHR).o:
	$(GCC) -o obj/$(MEMRCHR).o -c $(MEMRCHR).c $(CFLAGS)

$(MEMSET): $(MEMSET).o
	$(GCC) -o $(MEMSET) obj/$(MEMSET).o $(LDFLAGS)
$(MEMSET).o:
	$(GCC) -o obj/$(MEMSET).o -c $(MEMSET).c $(CFLAGS)

$(PRINTF): $(PRINTF).o
	$(GCC) -o $(PRINTF) obj/$(PRINTF).o $(LDFLAGS)
$(PRINTF).o:
	$(GCC) -o obj/$(PRINTF).o -c $(PRINTF).c $(CFLAGS)

$(PUTCHAR): $(PUTCHAR).o
	$(GCC) -o $(PUTCHAR) obj/$(PUTCHAR).o $(LDFLAGS)
$(PUTCHAR).o:
	$(GCC) -o obj/$(PUTCHAR).o -c $(PUTCHAR).c $(CFLAGS)

$(PUTS): $(PUTS).o
	$(GCC) -o $(PUTS) obj/$(PUTS).o $(LDFLAGS)
$(PUTS).o:
	$(GCC) -o obj/$(PUTS).o -c $(PUTS).c $(CFLAGS)

$(SCANF): $(SCANF).o
	$(GCC) -o $(SCANF) obj/$(SCANF).o $(LDFLAGS)
$(SCANF).o:
	$(GCC) -o obj/$(SCANF).o -c $(SCANF).c $(CFLAGS)

$(SNPRINTF): $(SNPRINTF).o
	$(GCC) -o $(SNPRINTF) obj/$(SNPRINTF).o $(LDFLAGS)
$(SNPRINTF).o:
	$(GCC) -o obj/$(SNPRINTF).o -c $(SNPRINTF).c $(CFLAGS)

$(SSCANF): $(SSCANF).o
	$(GCC) -o $(SSCANF) obj/$(SSCANF).o $(LDFLAGS)
$(SSCANF).o:
	$(GCC) -o obj/$(SSCANF).o -c $(SSCANF).c $(CFLAGS)

$(STRCASESTR): $(STRCASESTR).o
	$(GCC) -o $(STRCASESTR) obj/$(STRCASESTR).o $(LDFLAGS)
$(STRCASESTR).o:
	$(GCC) -o obj/$(STRCASESTR).o -c $(STRCASESTR).c $(CFLAGS)

$(STRCHR): $(STRCHR).o
	$(GCC) -o $(STRCHR) obj/$(STRCHR).o $(LDFLAGS)
$(STRCHR).o:
	$(GCC) -o obj/$(STRCHR).o -c $(STRCHR).c $(CFLAGS)

$(STRCOLL): $(STRCOLL).o
	$(GCC) -o $(STRCOLL) obj/$(STRCOLL).o $(LDFLAGS)
$(STRCOLL).o:
	$(GCC) -o obj/$(STRCOLL).o -c $(STRCOLL).c $(CFLAGS)

$(STRCSPN): $(STRCSPN).o
	$(GCC) -o $(STRCSPN) obj/$(STRCSPN).o $(LDFLAGS)
$(STRCSPN).o:
	$(GCC) -o obj/$(STRCSPN).o -c $(STRCSPN).c $(CFLAGS)

$(STRERROR): $(STRERROR).o
	$(GCC) -o $(STRERROR) obj/$(STRERROR).o $(LDFLAGS)
$(STRERROR).o:
	$(GCC) -o obj/$(STRERROR).o -c $(STRERROR).c $(CFLAGS)

$(STRNCASECMP): $(STRNCASECMP).o
	$(GCC) -o $(STRNCASECMP) obj/$(STRNCASECMP).o $(LDFLAGS)
$(STRNCASECMP).o:
	$(GCC) -o obj/$(STRNCASECMP).o -c $(STRNCASECMP).c $(CFLAGS)

$(STRNCAT): $(STRNCAT).o
	$(GCC) -o $(STRNCAT) obj/$(STRNCAT).o $(LDFLAGS)
$(STRNCAT).o:
	$(GCC) -o obj/$(STRNCAT).o -c $(STRNCAT).c $(CFLAGS)

$(STRNCMP): $(STRNCMP).o
	$(GCC) -o $(STRNCMP) obj/$(STRNCMP).o $(LDFLAGS)
$(STRNCMP).o:
	$(GCC) -o obj/$(STRNCMP).o -c $(STRNCMP).c $(CFLAGS)

$(STRNCPY): $(STRNCPY).o
	$(GCC) -o $(STRNCPY) obj/$(STRNCPY).o $(LDFLAGS)
$(STRNCPY).o:
	$(GCC) -o obj/$(STRNCPY).o -c $(STRNCPY).c $(CFLAGS)

$(STRNDUP): $(STRNDUP).o
	$(GCC) -o $(STRNDUP) obj/$(STRNDUP).o $(LDFLAGS)
$(STRNDUP).o:
	$(GCC) -o obj/$(STRNDUP).o -c $(STRNDUP).c $(CFLAGS)

$(STRNLEN): $(STRNLEN).o
	$(GCC) -o $(STRNLEN) obj/$(STRNLEN).o $(LDFLAGS)
$(STRNLEN).o:
	$(GCC) -o obj/$(STRNLEN).o -c $(STRNLEN).c $(CFLAGS)

$(STRPBRK): $(STRPBRK).o
	$(GCC) -o $(STRPBRK) obj/$(STRPBRK).o $(LDFLAGS)
$(STRPBRK).o:
	$(GCC) -o obj/$(STRPBRK).o -c $(STRPBRK).c $(CFLAGS)

$(STRRCHR): $(STRRCHR).o
	$(GCC) -o $(STRRCHR) obj/$(STRRCHR).o $(LDFLAGS)
$(STRRCHR).o:
	$(GCC) -o obj/$(STRRCHR).o -c $(STRRCHR).c $(CFLAGS)

$(STRSEP): $(STRSEP).o
	$(GCC) -o $(STRSEP) obj/$(STRSEP).o $(LDFLAGS)
$(STRSEP).o:
	$(GCC) -o obj/$(STRSEP).o -c $(STRSEP).c $(CFLAGS)

$(STRSIGNAL): $(STRSIGNAL).o
	$(GCC) -o $(STRSIGNAL) obj/$(STRSIGNAL).o $(LDFLAGS)
$(STRSIGNAL).o:
	$(GCC) -o obj/$(STRSIGNAL).o -c $(STRSIGNAL).c $(CFLAGS)

$(STRSPN): $(STRSPN).o
	$(GCC) -o $(STRSPN) obj/$(STRSPN).o $(LDFLAGS)
$(STRSPN).o:
	$(GCC) -o obj/$(STRSPN).o -c $(STRSPN).c $(CFLAGS)

$(STRSTR): $(STRSTR).o
	$(GCC) -o $(STRSTR) obj/$(STRSTR).o $(LDFLAGS)
$(STRSTR).o:
	$(GCC) -o obj/$(STRSTR).o -c $(STRSTR).c $(CFLAGS)

$(STRTOK): $(STRTOK).o
	$(GCC) -o $(STRTOK) obj/$(STRTOK).o $(LDFLAGS)
$(STRTOK).o:
	$(GCC) -o obj/$(STRTOK).o -c $(STRTOK).c $(CFLAGS)

$(STRVERSCMP): $(STRVERSCMP).o
	$(GCC) -o $(STRVERSCMP) obj/$(STRVERSCMP).o $(LDFLAGS)
$(STRVERSCMP).o:
	$(GCC) -o obj/$(STRVERSCMP).o -c $(STRVERSCMP).c $(CFLAGS)

$(VPRINTF): $(VPRINTF).o
	$(GCC) -o $(VPRINTF) obj/$(VPRINTF).o $(LDFLAGS)
$(VPRINTF).o:
	$(GCC) -o obj/$(VPRINTF).o -c $(VPRINTF).c $(CFLAGS)

$(VSNPRINTF): $(VSNPRINTF).o
	$(GCC) -o $(VSNPRINTF) obj/$(VSNPRINTF).o $(LDFLAGS)
$(VSNPRINTF).o:
	$(GCC) -o obj/$(VSNPRINTF).o -c $(VSNPRINTF).c $(CFLAGS)

#top Predefined Constants¶

#top CONST¶

CONST

#top Datatypes / MACROS¶

#top __ctype_b_loc¶

extern __const unsigned short int **__ctype_b_loc (void)
     __attribute__ ((__const));

#top __gnuc_va_list¶

__gnuc_va_list

#top _ISbit¶

# if __BYTE_ORDER == __BIG_ENDIAN
#  define _ISbit(bit)   (1 << (bit))
# else /* __BYTE_ORDER == __LITTLE_ENDIAN */
#  define _ISbit(bit)   ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))
# endif

#top _IS*¶

enum
{
  _ISupper = _ISbit (0),	:* UPPERCASE.  */
  _ISlower = _ISbit (1),	:* lowercase.  */
  _ISalpha = _ISbit (2),	:* Alphabetic.  */
  _ISdigit = _ISbit (3),	:* Numeric.  */
  _ISxdigit = _ISbit (4),	:* Hexadecimal numeric.  */
  _ISspace = _ISbit (5),	:* Whitespace.  */
  _ISprint = _ISbit (6),	:* Printing.  */
  _ISgraph = _ISbit (7),	:* Graphical.  */
  _ISblank = _ISbit (8),	:* Blank (usually SPC and TAB).  */
  _IScntrl = _ISbit (9),	:* Control character.  */
  _ISpunct = _ISbit (10),	:* Punctuation.  */
  _ISalnum = _ISbit (11)	:* Alphanumeric.  */
};

#top __isctype¶

#define __isctype(c, type) \
  ((*__ctype_b_loc ())[(int) (c)] & (unsigned short int) type)

#top _G_va_list¶

#define _G_va_list __gnuc_va_list

#top size_t¶

/* Unsigned type of `sizeof' something.  */

/* Define this type if we are doing the whole job,
   or if we want this type in particular.  */
#if defined (_STDDEF_H) || defined (__need_size_t)
#ifndef __size_t__	/* BeOS */
#ifndef __SIZE_T__	/* Cray Unicos/Mk */
#ifndef _SIZE_T	/* in case <sys/types.h> has defined it. */
#ifndef _SYS_SIZE_T_H
#ifndef _T_SIZE_
#ifndef _T_SIZE
#ifndef __SIZE_T
#ifndef _SIZE_T_
#ifndef _BSD_SIZE_T_
#ifndef _SIZE_T_DEFINED_
#ifndef _SIZE_T_DEFINED
#ifndef _BSD_SIZE_T_DEFINED_	/* Darwin */
#ifndef _SIZE_T_DECLARED	/* FreeBSD 5 */
#ifndef ___int_size_t_h
#ifndef _GCC_SIZE_T
#ifndef _SIZET_
#ifndef __size_t
#define __size_t__	/* BeOS */
#define __SIZE_T__	/* Cray Unicos/Mk */
#define _SIZE_T
#define _SYS_SIZE_T_H
#define _T_SIZE_
#define _T_SIZE
#define __SIZE_T
#define _SIZE_T_
#define _BSD_SIZE_T_
#define _SIZE_T_DEFINED_
#define _SIZE_T_DEFINED
#define _BSD_SIZE_T_DEFINED_	/* Darwin */
#define _SIZE_T_DECLARED	/* FreeBSD 5 */
#define ___int_size_t_h
#define _GCC_SIZE_T
#define _SIZET_
#if defined (__FreeBSD__) && (__FreeBSD__ >= 5)
/* __size_t is a typedef on FreeBSD 5!, must not trash it. */
#else
#define __size_t
#endif
#ifndef __SIZE_TYPE__
#define __SIZE_TYPE__ long unsigned int
#endif
#if !(defined (__GNUG__) && defined (size_t))
typedef __SIZE_TYPE__ size_t;
#ifdef __BEOS__
typedef long ssize_t;
#endif /* __BEOS__ */
#endif /* !(defined (__GNUG__) && defined (size_t)) */
#endif /* __size_t */
#endif /* _SIZET_ */
#endif /* _GCC_SIZE_T */
#endif /* ___int_size_t_h */
#endif /* _SIZE_T_DECLARED */
#endif /* _BSD_SIZE_T_DEFINED_ */
#endif /* _SIZE_T_DEFINED */
#endif /* _SIZE_T_DEFINED_ */
#endif /* _BSD_SIZE_T_ */
#endif /* _SIZE_T_ */
#endif /* __SIZE_T */
#endif /* _T_SIZE */
#endif /* _T_SIZE_ */
#endif /* _SYS_SIZE_T_H */
#endif /* _SIZE_T */
#endif /* __SIZE_T__ */
#endif /* __size_t__ */
#undef	__need_size_t
#endif /* _STDDEF_H or __need_size_t.  */

#top struct lconv¶

/* Structure giving information about numeric and monetary notation.  */
struct lconv
{
  /* Numeric (non-monetary) information.  */

  char *decimal_point;          /* Decimal point character.  */
  char *thousands_sep;          /* Thousands separator.  */
  /* Each element is the number of digits in each group;
     elements with higher indices are farther left.
     An element with value CHAR_MAX means that no further grouping is done.
     An element with value 0 means that the previous element is used
     for all groups farther left.  */
  char *grouping;

  /* Monetary information.  */

  /* First three chars are a currency symbol from ISO 4217.
     Fourth char is the separator.  Fifth char is '\0'.  */
  char *int_curr_symbol;
  char *currency_symbol;        /* Local currency symbol.  */
  char *mon_decimal_point;      /* Decimal point character.  */
  char *mon_thousands_sep;      /* Thousands separator.  */
  char *mon_grouping;           /* Like `grouping' element (above).  */
  char *positive_sign;          /* Sign for positive values.  */
  char *negative_sign;          /* Sign for negative values.  */
  char int_frac_digits;         /* Int'l fractional digits.  */
  char frac_digits;             /* Local fractional digits.  */
  /* 1 if currency_symbol precedes a positive value, 0 if succeeds.  */
  char p_cs_precedes;
  /* 1 iff a space separates currency_symbol from a positive value.  */
  char p_sep_by_space;
  /* 1 if currency_symbol precedes a negative value, 0 if succeeds.  */
  char n_cs_precedes;
  /* 1 iff a space separates currency_symbol from a negative value.  */
  char n_sep_by_space;
  /* Positive and negative sign positions:
     0 Parentheses surround the quantity and currency_symbol.
     1 The sign string precedes the quantity and currency_symbol.
     2 The sign string follows the quantity and currency_symbol.
     3 The sign string immediately precedes the currency_symbol.
     4 The sign string immediately follows the currency_symbol.  */
  char p_sign_posn;
  char n_sign_posn;
#ifdef __USE_ISOC99
  /* 1 if int_curr_symbol precedes a positive value, 0 if succeeds.  */
  char int_p_cs_precedes;
  /* 1 iff a space separates int_curr_symbol from a positive value.  */
  char int_p_sep_by_space;
  /* 1 if int_curr_symbol precedes a negative value, 0 if succeeds.  */
  char int_n_cs_precedes;
  /* 1 iff a space separates int_curr_symbol from a negative value.  */
  char int_n_sep_by_space;
  /* Positive and negative sign positions:
     0 Parentheses surround the quantity and int_curr_symbol.
     1 The sign string precedes the quantity and int_curr_symbol.
     2 The sign string follows the quantity and int_curr_symbol.
     3 The sign string immediately precedes the int_curr_symbol.
     4 The sign string immediately follows the int_curr_symbol.  */
  char int_p_sign_posn;
  char int_n_sign_posn;
#else
  char __int_p_cs_precedes;
  char __int_p_sep_by_space;
  char __int_n_cs_precedes;
  char __int_n_sep_by_space;
  char __int_p_sign_posn;
  char __int_n_sign_posn;
#endif
};

#top Strings Functions¶

#top basename¶

/* Return the file name within directory of FILENAME.  We don't
   declare the function if the `basename' macro is available (defined
   in <libgen.h>) which makes the XPG version of this function
   available.  */
extern char *basename (__const char *__filename) __THROW __nonnull ((1));

/* Return final component of PATH.

   This is the weird XPG version of this function.  It sometimes will
   modify its argument.  Therefore we normally use the GNU version (in
   <string.h>) and only if this header is included make the XPG
   version available under the real name.  */
extern char *__xpg_basename (char *__path) __THROW;
#define basename    __xpg_basename

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#if defined(HAVE_LIBGEN_H)
#include <libgen.h>        /* for dirname(), basename(), */
#endif
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_BASENAME)
	char *appname;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s </path/to/app-name>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s /home/local/code/ansiccode/strings/basename\n", argv[0]);
		printf("       %s .\n", argv[0]);
		printf("       %s .basename\n", argv[0]);
		printf("       %s ./\n", argv[0]);
		printf("       %s ./basename\n", argv[0]);
		printf("       %s ../\n", argv[0]);
		printf("       %s ../basename\n", argv[0]);
		printf("       %s basename\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_BASENAME)
	printf("%s: appname=basename(argv[0]=|%s|):\n", self, argv[0]);
	appname=basename(argv[0]);
	printf("%s: appname=basename(argv[0]=|%s|): appname=(%p)|%s|\n", self, argv[0], appname, appname);
	
	printf("%s: appname=basename(argv[1]=|%s|):\n", self, argv[1]);
	appname=basename(argv[1]);
	printf("%s: appname=basename(argv[1]=|%s|): appname=(%p)|%s|\n", self, argv[1], appname, appname);
#endif
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/basename

Usage: /home/local/code/ansiccode/strings/basename </path/to/app-name>
Examples:
       /home/local/code/ansiccode/strings/basename /home/local/code/ansiccode/strings/basename
       /home/local/code/ansiccode/strings/basename .
       /home/local/code/ansiccode/strings/basename .basename
       /home/local/code/ansiccode/strings/basename ./
       /home/local/code/ansiccode/strings/basename ./basename
       /home/local/code/ansiccode/strings/basename ../
       /home/local/code/ansiccode/strings/basename ../basename
       /home/local/code/ansiccode/strings/basename basename

/home/local/code/ansiccode/strings/basename /home/local/code/ansiccode/strings/basename
/home/local/code/ansiccode/strings/basename .
/home/local/code/ansiccode/strings/basename .basename
/home/local/code/ansiccode/strings/basename ./
/home/local/code/ansiccode/strings/basename ./basename
/home/local/code/ansiccode/strings/basename ../
/home/local/code/ansiccode/strings/basename ../basename
/home/local/code/ansiccode/strings/basename basename

basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|):
basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|): appname=(0xbfaaf8ab)|basename|
basename: appname=basename(argv[1]=|/home/local/code/ansiccode/strings/basename|):
basename: appname=basename(argv[1]=|/home/local/code/ansiccode/strings/basename|): appname=(0xbfaaf8d7)|basename|

basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|):
basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|): appname=(0xbfe148d5)|basename|
basename: appname=basename(argv[1]=|.|):
basename: appname=basename(argv[1]=|.|): appname=(0xbfe148de)|.|

basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|):
basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|): appname=(0xbf9b78cd)|basename|
basename: appname=basename(argv[1]=|.basename|):
basename: appname=basename(argv[1]=|.basename|): appname=(0xbf9b78d6)|.basename|

basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|):
basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|): appname=(0xbf9b98d4)|basename|
basename: appname=basename(argv[1]=|./|):
basename: appname=basename(argv[1]=|.|): appname=(0xbf9b98dd)|.|

basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|):
basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|): appname=(0xbfcfd8cc)|basename|
basename: appname=basename(argv[1]=|./basename|):
basename: appname=basename(argv[1]=|./basename|): appname=(0xbfcfd8d7)|basename|

basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|):
basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|): appname=(0xbf9f98d3)|basename|
basename: appname=basename(argv[1]=|../|):
basename: appname=basename(argv[1]=|..|): appname=(0xbf9f98dc)|..|

basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|):
basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|): appname=(0xbfae28cb)|basename|
basename: appname=basename(argv[1]=|../basename|):
basename: appname=basename(argv[1]=|../basename|): appname=(0xbfae28d7)|basename|

basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|):
basename: appname=basename(argv[0]=|/home/local/code/ansiccode/strings/basename|): appname=(0xbfeb38ce)|basename|
basename: appname=basename(argv[1]=|basename|):
basename: appname=basename(argv[1]=|basename|): appname=(0xbfeb38d7)|basename|

#top dirname¶

/* Return directory part of PATH or "." if none is available.  */
extern char *dirname (char *__path) __THROW;

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#if defined(HAVE_LIBGEN_H)
#include <libgen.h>        /* for dirname(), basename(), */
#endif
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_DIRNAME)
	char *appname;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s </path/to/app-name>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s /home/local/code/ansiccode/strings/dirname\n", argv[0]);
		printf("       %s .\n", argv[0]);
		printf("       %s .dirname\n", argv[0]);
		printf("       %s ./\n", argv[0]);
		printf("       %s ./dirname\n", argv[0]);
		printf("       %s ../\n", argv[0]);
		printf("       %s ../dirname\n", argv[0]);
		printf("       %s dirname\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_DIRNAME)
	printf("%s: appname=dirname(argv[0]=|%s|):\n", self, argv[0]);
	appname=dirname(argv[0]);
	printf("%s: appname=dirname(argv[0]=|%s|): appname=(%p)|%s|\n", self, argv[0], appname, appname);
	
	printf("%s: appname=dirname(argv[1]=|%s|):\n", self, argv[1]);
	appname=dirname(argv[1]);
	printf("%s: appname=dirname(argv[1]=|%s|): appname=(%p)|%s|\n", self, argv[1], appname, appname);
#endif
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/dirname

Usage: /home/local/code/ansiccode/strings/dirname </path/to/app-name>
Examples:
       /home/local/code/ansiccode/strings/dirname /home/local/code/ansiccode/strings/dirname
       /home/local/code/ansiccode/strings/dirname .
       /home/local/code/ansiccode/strings/dirname .dirname
       /home/local/code/ansiccode/strings/dirname ./
       /home/local/code/ansiccode/strings/dirname ./dirname
       /home/local/code/ansiccode/strings/dirname ../
       /home/local/code/ansiccode/strings/dirname ../dirname
       /home/local/code/ansiccode/strings/dirname dirname

/home/local/code/ansiccode/strings/dirname /home/local/code/ansiccode/strings/dirname
/home/local/code/ansiccode/strings/dirname .
/home/local/code/ansiccode/strings/dirname .dirname
/home/local/code/ansiccode/strings/dirname ./
/home/local/code/ansiccode/strings/dirname ./dirname
/home/local/code/ansiccode/strings/dirname ../
/home/local/code/ansiccode/strings/dirname ../dirname
/home/local/code/ansiccode/strings/dirname dirname

dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings/dirname|):
dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings|): appname=(0xbfbcb88c)|/home/local/code/ansiccode/strings|
dirname: appname=dirname(argv[1]=|/home/local/code/ansiccode/strings/dirname|):
dirname: appname=dirname(argv[1]=|/home/local/code/ansiccode/strings|): appname=(0xbfbcb8b7)|/home/local/code/ansiccode/strings|

dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings/dirname|):
dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings|): appname=(0xbfac08b5)|/home/local/code/ansiccode/strings|
dirname: appname=dirname(argv[1]=|.|):
dirname: appname=dirname(argv[1]=|.|): appname=(0x22714e)|.|

dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings/dirname|):
dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings|): appname=(0xbff628ae)|/home/local/code/ansiccode/strings|
dirname: appname=dirname(argv[1]=|.dirname|):
dirname: appname=dirname(argv[1]=|.dirname|): appname=(0x22714e)|.|

dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings/dirname|):
dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings|): appname=(0xbfa6e8b4)|/home/local/code/ansiccode/strings|
dirname: appname=dirname(argv[1]=|./|):
dirname: appname=dirname(argv[1]=|./|): appname=(0x46514e)|.|

dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings/dirname|):
dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings|): appname=(0xbfd618ad)|/home/local/code/ansiccode/strings|
dirname: appname=dirname(argv[1]=|./dirname|):
dirname: appname=dirname(argv[1]=|.|): appname=(0xbfd618d8)|.|

dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings/dirname|):
dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings|): appname=(0xbfbc98b3)|/home/local/code/ansiccode/strings|
dirname: appname=dirname(argv[1]=|../|):
dirname: appname=dirname(argv[1]=|../|): appname=(0x22714e)|.|

dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings/dirname|):
dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings|): appname=(0xbfeaa8ac)|/home/local/code/ansiccode/strings|
dirname: appname=dirname(argv[1]=|../dirname|):
dirname: appname=dirname(argv[1]=|..|): appname=(0xbfeaa8d7)|..|

dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings/dirname|):
dirname: appname=dirname(argv[0]=|/home/local/code/ansiccode/strings|): appname=(0xbff808af)|/home/local/code/ansiccode/strings|
dirname: appname=dirname(argv[1]=|dirname|):
dirname: appname=dirname(argv[1]=|dirname|): appname=(0x22714e)|.|

#top getchar¶

/* Read a character from stdin.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern int getchar (void);

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset memcmp memchr str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	int result;
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 1;
	}
	
	printf("%s: getchar(): ", argv[0]);
	fflush(stdout);
	result=getchar();
	printf("%s: getchar(): result(%%d)=%d result(0x%%02X)=0x%02X result(%%c)=|%c|\n", argv[0], result, result, result);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/getchar

a

/home/local/code/ansiccode/strings/getchar: getchar(): a
/home/local/code/ansiccode/strings/getchar: getchar(): result(%d)=97 result(0x%02X)=0x61 result(%c)=|a|

#top gets¶

/* 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.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern char *gets (char *__s) __wur;

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset memcmp memchr str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	char buffer[1024];
	char *strptr;
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 1;
	}
	
	printf("%s: strptr=gets(buffer): ", argv[0]);
	fflush(stdout);
	strptr=gets(buffer);
	printf("%s: strptr=gets(buffer): buffer=|%s| strptr=|%s|\n", argv[0], buffer, strptr);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/gets

dowolny ciąg znaków

/home/local/code/ansiccode/strings/gets: strptr=gets(buffer): dowolny ciąg znaków
/home/local/code/ansiccode/strings/gets: strptr=gets(buffer): buffer=|dowolny ciąg znaków| strptr=|dowolny ciąg znaków|

#top index¶

/* Find the first occurrence of C in S (same as strchr).  */
extern char *index (__const char *__s, int __c)
     __THROW __attribute_pure__ __nonnull ((1));

#top isalnum¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define isalnum(c) __isctype((c), _ISalnum)
[...]
#endif /* Not __NO_CTYPE.  */

#top isalpha¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define isalpha(c) __isctype((c), _ISalpha)
[...]
#endif /* Not __NO_CTYPE.  */

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <ctype.h>



int main(int argc, char **argv) {
	char *self;
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <some-char>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s '0a cdglp. UX'\n", argv[0]);
		printf("       %s 'A@ ^VcdgL^V^V'$'\\t''ux'\n", argv[0]);
		return 0;
	}
	
	if (strlen(argv[1])<12) {
		printf("%s: To short argument '%s', require minimum 12 characters.\n", self, argv[1]);
		return 1;
	}
	
	result=isalnum(argv[1][0]);
	printf("%s: result=isalnum(argv[1][0]='%c'(0x%02X)): result=%d\n", self, argv[1][0], argv[1][0], result);
	
	result=isalpha(argv[1][1]);
	printf("%s: result=isalpha(argv[1][1]='%c'(0x%02X)): result=%d\n", self, argv[1][1], argv[1][1], result);
	
	result=isblank(argv[1][2]);
	printf("%s: result=isblank(argv[1][2]='%c'(0x%02X)): result=%d\n", self, argv[1][2], argv[1][2], result);
	
	result=iscntrl(argv[1][3]);
	printf("%s: result=iscntrl(argv[1][3]='%c'(0x%02X)): result=%d\n", self, argv[1][3], argv[1][3], result);
	
	result=isdigit(argv[1][4]);
	printf("%s: result=isdigit(argv[1][4]='%c'(0x%02X)): result=%d\n", self, argv[1][4], argv[1][4], result);
	
	result=isgraph(argv[1][5]);
	printf("%s: result=isgraph(argv[1][5]='%c'(0x%02X)): result=%d\n", self, argv[1][5], argv[1][5], result);
	
	result=islower(argv[1][6]);
	printf("%s: result=islower(argv[1][6]='%c'(0x%02X)): result=%d\n", self, argv[1][6], argv[1][6], result);
	
	result=isprint(argv[1][7]);
	printf("%s: result=isprint(argv[1][7]='%c'(0x%02X)): result=%d\n", self, argv[1][7], argv[1][7], result);
	
	result=ispunct(argv[1][8]);
	printf("%s: result=ispunct(argv[1][8]='%c'(0x%02X)): result=%d\n", self, argv[1][8], argv[1][8], result);
	
	result=isspace(argv[1][9]);
	printf("%s: result=isspace(argv[1][9]='%c'(0x%02X)): result=%d\n", self, argv[1][8], argv[1][9], result);
	
	result=isupper(argv[1][10]);
	printf("%s: result=isupper(argv[1][10]='%c'(0x%02X)): result=%d\n", self, argv[1][10], argv[1][10], result);
	
	result=isxdigit(argv[1][11]);
	printf("%s: result=isxdigit(argv[1][11]='%c'(0x%02X)): result=%d\n", self, argv[1][11], argv[1][11], result);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/isalpha

Usage: /home/local/code/ansiccode/strings/isalpha <some-char>
Examples:
       /home/local/code/ansiccode/strings/isalpha '0acglp. U'
       /home/local/code/ansiccode/strings/isalpha 'A@^VgL^V^V'$'\t''u'

/home/local/code/ansiccode/strings/isalpha '0acglp. U'
/home/local/code/ansiccode/strings/isalpha 'A@^VgL^V^V'$'\t''u'

isalpha: result=isalnum(argv[1][0]='0'(0x30)): result=8
isalpha: result=isalpha(argv[1][1]='a'(0x61)): result=1024
isalpha: result=isblank(argv[1][2]=' '(0x20)): result=1
isalpha: result=iscntrl(argv[1][3]='c'(0x63)): result=0
isalpha: result=isdigit(argv[1][4]='d'(0x64)): result=0
isalpha: result=isgraph(argv[1][5]='g'(0x67)): result=32768
isalpha: result=islower(argv[1][6]='l'(0x6C)): result=512
isalpha: result=isprint(argv[1][7]='p'(0x70)): result=16384
isalpha: result=ispunct(argv[1][8]='.'(0x2E)): result=4
isalpha: result=isspace(argv[1][9]='.'(0x20)): result=8192
isalpha: result=isupper(argv[1][10]='U'(0x55)): result=256
isalpha: result=isxdigit(argv[1][11]='X'(0x58)): result=0

isalpha: result=isalnum(argv[1][0]='A'(0x41)): result=8
isalpha: result=isalpha(argv[1][1]='@'(0x40)): result=0
isalpha: result=isblank(argv[1][2]=' '(0x20)): result=1
isalpha: result=iscntrl(argv[1][3]=''(0x16)): result=2
isalpha: result=isdigit(argv[1][4]='c'(0x63)): result=0
isalpha: result=isgraph(argv[1][5]='d'(0x64)): result=32768
isalpha: result=islower(argv[1][6]='g'(0x67)): result=512
isalpha: result=isprint(argv[1][7]='L'(0x4C)): result=16384
isalpha: result=ispunct(argv[1][8]=''(0x16)): result=0
isalpha: result=isspace(argv[1][9]=''(0x16)): result=0
isalpha: result=isupper(argv[1][10]='   '(0x09)): result=0
isalpha: result=isxdigit(argv[1][11]='u'(0x75)): result=0

#top isblank¶

# ifdef __USE_ISOC99
# define isblank(c) __isctype((c), _ISblank)
#endif

#top iscntrl¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define iscntrl(c) __isctype((c), _IScntrl)
[...]
#endif /* Not __NO_CTYPE.  */

#top isdigit¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define isdigit(c) __isctype((c), _ISdigit)
[...]
#endif /* Not __NO_CTYPE.  */

#top isgraph¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define isgraph(c) __isctype((c), _ISgraph)
[...]
#endif /* Not __NO_CTYPE.  */

#top islower¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define islower(c) __isctype((c), _ISlower)
[...]
#endif /* Not __NO_CTYPE.  */

#top isprint¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define isprint(c) __isctype((c), _ISprint)
[...]
#endif /* Not __NO_CTYPE.  */

#top ispunct¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define ispunct(c) __isctype((c), _ISpunct)
[...]
#endif /* Not __NO_CTYPE.  */

#top isspace¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define isspace(c) __isctype((c), _ISspace)
[...]
#endif /* Not __NO_CTYPE.  */

#top isupper¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define isupper(c) __isctype((c), _ISupper)
[...]
#endif /* Not __NO_CTYPE.  */

#top isxdigit¶

#if !defined __NO_CTYPE && !defined __cplusplus
[...]
# define isxdigit(c)    __isctype((c), _ISxdigit)
[...]
#endif /* Not __NO_CTYPE.  */

#top localeconv¶

/* Return the numeric/monetary information for the current locale.  */
extern struct lconv *localeconv (void) __THROW;

#top memccpy¶

/* Copy no more than N bytes of SRC to DEST, stopping when C is found.
   Return the position in DEST one byte past where C was copied,
   or NULL if C was not found in the first N bytes of SRC.  */
#if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN
extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
              int __c, size_t __n)
     __THROW __nonnull ((1, 2));
#endif /* SVID.  */

#top memchr¶

/* Search N bytes of S for C.  */
extern void *memchr (__const void *__s, int __c, size_t __n)
      __THROW __attribute_pure__ __nonnull ((1));

#top memcmp¶

/* Compare N bytes of S1 and S2.  */
extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int hex2bin(char *buffdata, const int buffsize) {
	char hexchar[256];
	int ihex, ibin;
	
	memset(hexchar, 0x00, sizeof(hexchar));
	
	hexchar[0x30]=0x00;
	hexchar[0x31]=0x01;
	hexchar[0x32]=0x02;
	hexchar[0x33]=0x03;
	hexchar[0x34]=0x04;
	hexchar[0x35]=0x05;
	hexchar[0x36]=0x06;
	hexchar[0x37]=0x07;
	hexchar[0x38]=0x08;
	hexchar[0x39]=0x09;
	
	hexchar[0x41]=0x0A;
	hexchar[0x42]=0x0B;
	hexchar[0x43]=0x0C;
	hexchar[0x44]=0x0D;
	hexchar[0x45]=0x0E;
	hexchar[0x46]=0x0F;
	
	hexchar[0x61]=0x0A;
	hexchar[0x62]=0x0B;
	hexchar[0x63]=0x0C;
	hexchar[0x64]=0x0D;
	hexchar[0x65]=0x0E;
	hexchar[0x66]=0x0F;
	
	ibin=0;
	for (ihex=0;ihex<buffsize;ihex++) {
		if (buffdata[ihex]==0x5C && ihex+3<buffsize && (buffdata[ihex+1]==0x58||buffdata[ihex+1]==0x78)
			&& ((0x30<=buffdata[ihex+2]&&buffdata[ihex+2]<=0x39) || (0x41<=buffdata[ihex+2]&&buffdata[ihex+2]<=0x46) || (0x61<=buffdata[ihex+2]&&buffdata[ihex+2]<=0x66))
			&& ((0x30<=buffdata[ihex+3]&&buffdata[ihex+3]<=0x39) || (0x41<=buffdata[ihex+3]&&buffdata[ihex+3]<=0x46) || (0x61<=buffdata[ihex+3]&&buffdata[ihex+3]<=0x66))
			) {
			buffdata[ibin]= (hexchar[ (unsigned char)buffdata[ihex+2] ]<<4) + (hexchar[ (unsigned char)buffdata[ihex+3] ]);
			ihex=ihex+3;
			ibin++;
			continue;
		}
		if (ihex!=ibin) buffdata[ibin]=buffdata[ihex];
		ibin++;
	}
	for (ihex=ibin;ihex<buffsize;ihex++) buffdata[ihex]=0x00;
	
	return ibin;
}



int main(int argc, char **argv) {
	char *self;
	char contbuff1[1024];
	char contbuff2[64];
	int  sizebuff1;
	int  sizebuff2;
	int result;
	int i;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <some-data>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s \"\\x00\\x01\\x02\\x03\" \"\\x00\\x01\\x02\\x03\"\n", argv[0]);
		printf("       %s \"\\x00\\x01\\x02\\x03\" \"\\x01\\x02\\x03\\x00\"\n", argv[0]);
		printf("       %s \"\\x01\\x02\\x03\\x00\" \"\\x00\\x01\\x02\\x03\"\n", argv[0]);
		printf("       %s \"\\x00\\x01\\x02\\x03\" \"\\x02\\x03\\x00\\x01\"\n", argv[0]);
		printf("       %s \"\\x02\\x03\\x00\\x01\" \"\\x00\\x01\\x02\\x03\"\n", argv[0]);
		return 0;
	}
	
	memset(contbuff1, 0x00, sizeof(contbuff1));
	memset(contbuff2, 0x00, sizeof(contbuff2));
	strncpy(contbuff1, argv[1], sizeof(contbuff1));
	strncpy(contbuff2, argv[2], sizeof(contbuff2));
	sizebuff1=hex2bin(contbuff1, strlen(contbuff1));
	sizebuff2=hex2bin(contbuff2, strlen(contbuff2));
	
	
	
	printf("%s: contbuff1=", self); for (i=0;i<sizebuff1;i++) { printf("%02X ", contbuff1[i]); } printf("\n");
	printf("%s: contbuff2=", self); for (i=0;i<sizebuff2;i++) { printf("%02X ", contbuff2[i]); } printf("\n");
	
	
	
	printf("%s: memptr=memcmp(contbuff1=%p, contbuff2=%p, sizebuff1<sizebuff2?sizebuff1=%d:sizebuff2=%d):\n", self, (void*)contbuff1, (void*)contbuff2, sizebuff1, sizebuff2);
	result=memcmp(contbuff1, contbuff2, sizebuff1<sizebuff2?sizebuff1:sizebuff2);
	printf("%s: memptr=memcmp(contbuff1=%p, contbuff2=%p, sizebuff1<sizebuff2?sizebuff1=%d:sizebuff2=%d): result=%d\n", self, (void*)contbuff1, (void*)contbuff2, sizebuff1, sizebuff2, result);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/memcmp

Usage: /home/local/code/ansiccode/strings/memcmp <some-data>
Examples:
       /home/local/code/ansiccode/strings/memcmp "\x00\x01\x02\x03" "\x00\x01\x02\x03"
       /home/local/code/ansiccode/strings/memcmp "\x00\x01\x02\x03" "\x01\x02\x03\x00"
       /home/local/code/ansiccode/strings/memcmp "\x01\x02\x03\x00" "\x00\x01\x02\x03"
       /home/local/code/ansiccode/strings/memcmp "\x00\x01\x02\x03" "\x02\x03\x00\x01"
       /home/local/code/ansiccode/strings/memcmp "\x02\x03\x00\x01" "\x00\x01\x02\x03"

/home/local/code/ansiccode/strings/memcmp "\x00\x01\x02\x03" "\x00\x01\x02\x03"
/home/local/code/ansiccode/strings/memcmp "\x00\x01\x02\x03" "\x01\x02\x03\x00"
/home/local/code/ansiccode/strings/memcmp "\x01\x02\x03\x00" "\x00\x01\x02\x03"
/home/local/code/ansiccode/strings/memcmp "\x00\x01\x02\x03" "\x02\x03\x00\x01"
/home/local/code/ansiccode/strings/memcmp "\x02\x03\x00\x01" "\x00\x01\x02\x03"

memcmp: contbuff1=00 01 02 03
memcmp: contbuff2=00 01 02 03
memcmp: memptr=memcmp(contbuff1=0xbf94aa88, contbuff2=0xbf94ae88, sizebuff1<sizebuff2?sizebuff1=4:sizebuff2=4):
memcmp: memptr=memcmp(contbuff1=0xbf94aa88, contbuff2=0xbf94ae88, sizebuff1<sizebuff2?sizebuff1=4:sizebuff2=4): result=0

memcmp: contbuff1=00 01 02 03
memcmp: contbuff2=01 02 03 00
memcmp: memptr=memcmp(contbuff1=0xbf878d08, contbuff2=0xbf879108, sizebuff1<sizebuff2?sizebuff1=4:sizebuff2=4):
memcmp: memptr=memcmp(contbuff1=0xbf878d08, contbuff2=0xbf879108, sizebuff1<sizebuff2?sizebuff1=4:sizebuff2=4): result=-1

memcmp: contbuff1=01 02 03 00
memcmp: contbuff2=00 01 02 03
memcmp: memptr=memcmp(contbuff1=0xbfb72db8, contbuff2=0xbfb731b8, sizebuff1<sizebuff2?sizebuff1=4:sizebuff2=4):
memcmp: memptr=memcmp(contbuff1=0xbfb72db8, contbuff2=0xbfb731b8, sizebuff1<sizebuff2?sizebuff1=4:sizebuff2=4): result=1

memcmp: contbuff1=00 01 02 03
memcmp: contbuff2=02 03 00 01
memcmp: memptr=memcmp(contbuff1=0xbf85ca98, contbuff2=0xbf85ce98, sizebuff1<sizebuff2?sizebuff1=4:sizebuff2=4):
memcmp: memptr=memcmp(contbuff1=0xbf85ca98, contbuff2=0xbf85ce98, sizebuff1<sizebuff2?sizebuff1=4:sizebuff2=4): result=-1

memcmp: contbuff1=02 03 00 01
memcmp: contbuff2=00 01 02 03
memcmp: memptr=memcmp(contbuff1=0xbfb550b8, contbuff2=0xbfb554b8, sizebuff1<sizebuff2?sizebuff1=4:sizebuff2=4):
memcmp: memptr=memcmp(contbuff1=0xbfb550b8, contbuff2=0xbfb554b8, sizebuff1<sizebuff2?sizebuff1=4:sizebuff2=4): result=1

#top memcpy¶

/* Copy N bytes of SRC to DEST.  */
extern void *memcpy (void *__restrict __dest,
             __const void *__restrict __src, size_t __n)
     __THROW __nonnull ((1, 2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int hex2bin(char *buffdata, const int buffsize) {
	char hexchar[256];
	int ihex, ibin;
	
	memset(hexchar, 0x00, sizeof(hexchar));
	
	hexchar[0x30]=0x00;
	hexchar[0x31]=0x01;
	hexchar[0x32]=0x02;
	hexchar[0x33]=0x03;
	hexchar[0x34]=0x04;
	hexchar[0x35]=0x05;
	hexchar[0x36]=0x06;
	hexchar[0x37]=0x07;
	hexchar[0x38]=0x08;
	hexchar[0x39]=0x09;
	
	hexchar[0x41]=0x0A;
	hexchar[0x42]=0x0B;
	hexchar[0x43]=0x0C;
	hexchar[0x44]=0x0D;
	hexchar[0x45]=0x0E;
	hexchar[0x46]=0x0F;
	
	hexchar[0x61]=0x0A;
	hexchar[0x62]=0x0B;
	hexchar[0x63]=0x0C;
	hexchar[0x64]=0x0D;
	hexchar[0x65]=0x0E;
	hexchar[0x66]=0x0F;
	
	ibin=0;
	for (ihex=0;ihex<buffsize;ihex++) {
		if (buffdata[ihex]==0x5C && ihex+3<buffsize && (buffdata[ihex+1]==0x58||buffdata[ihex+1]==0x78)
			&& ((0x30<=buffdata[ihex+2]&&buffdata[ihex+2]<=0x39) || (0x41<=buffdata[ihex+2]&&buffdata[ihex+2]<=0x46) || (0x61<=buffdata[ihex+2]&&buffdata[ihex+2]<=0x66))
			&& ((0x30<=buffdata[ihex+3]&&buffdata[ihex+3]<=0x39) || (0x41<=buffdata[ihex+3]&&buffdata[ihex+3]<=0x46) || (0x61<=buffdata[ihex+3]&&buffdata[ihex+3]<=0x66))
			) {
			buffdata[ibin]= (hexchar[ (unsigned char)buffdata[ihex+2] ]<<4) + (hexchar[ (unsigned char)buffdata[ihex+3] ]);
			ihex=ihex+3;
			ibin++;
			continue;
		}
		if (ihex!=ibin) buffdata[ibin]=buffdata[ihex];
		ibin++;
	}
	for (ihex=ibin;ihex<buffsize;ihex++) buffdata[ihex]=0x00;
	
	return ibin;
}



int main(int argc, char **argv) {
	char *self;
	char contdest[1024];
	char contsrcs[64];
	int  destsize;
	int  srcssize;
	void *memptr;
	int i;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <some-data>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s \"\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\\x0F\" \"\\x00\\x01\\x02\\x03\"\n", argv[0]);
		printf("       %s \"\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\\x0F\" \"\\x00\\x01\\x02\\x03\"\n", argv[0]);
		return 0;
	}
	
	
	
	memset(contdest, 0x00, sizeof(contdest));
	memset(contsrcs, 0x00, sizeof(contsrcs));
	strncpy(contdest, argv[1], sizeof(contdest));
	strncpy(contsrcs, argv[2], sizeof(contsrcs));
	destsize=hex2bin(contdest, strlen(contdest));
	srcssize=hex2bin(contsrcs, strlen(contsrcs));
	
	printf("%s: contdest=", self); for (i=0;i<destsize;i++) { printf("%02X ", contdest[i]); } printf("\n");
	printf("%s: contsrcs=", self); for (i=0;i<srcssize;i++) { printf("%02X ", contsrcs[i]); } printf("\n");
	
	
	
	memset(contdest, 0x00, sizeof(contdest));
	memset(contsrcs, 0x00, sizeof(contsrcs));
	strncpy(contdest, argv[1], sizeof(contdest));
	strncpy(contsrcs, argv[2], sizeof(contsrcs));
	destsize=hex2bin(contdest, strlen(contdest));
	srcssize=hex2bin(contsrcs, strlen(contsrcs));
	
	printf("%s: memptr=memcpy(contdest(%p)+destsize(%d)=%p, contsrcs=%p, srcssize=%d):\n", self, contdest, destsize, (void*)(contdest+destsize), (void*)contsrcs, srcssize);
	memptr=memcpy(contdest+destsize, contsrcs, srcssize);
	destsize=destsize+srcssize;
	printf("%s: memptr=memcpy(contdest(%p)+destsize(%d)=%p, contsrcs=%p, srcssize=%d): memptr=%p (char*)memptr-contdest=%d\n", self, contdest, destsize, (void*)(contdest+destsize), (void*)contsrcs, srcssize, memptr, (int)((char*)memptr-contdest));
	
	printf("%s: contdest=", self); for (i=0;i<destsize;i++) { printf("%02X ", contdest[i]); } printf("\n");
	printf("%s: contsrcs=", self); for (i=0;i<srcssize;i++) { printf("%02X ", contsrcs[i]); } printf("\n");
	printf("%s: memptr  =", self); for (i=0;i<destsize;i++) { printf("%02X ", ((char*)memptr)[i]); } printf("\n");
	
	
	
	memset(contdest, 0x00, sizeof(contdest));
	memset(contsrcs, 0x00, sizeof(contsrcs));
	strncpy(contdest, argv[1], sizeof(contdest));
	strncpy(contsrcs, argv[2], sizeof(contsrcs));
	destsize=hex2bin(contdest, strlen(contdest));
	srcssize=hex2bin(contsrcs, strlen(contsrcs));
	
	printf("%s: memptr=memcpy(contdest(%p)+destsize(%d)=%p, contsrcs=%p, srcssize=%d):\n", self, contdest, destsize, (void*)(contdest+destsize), (void*)contsrcs, srcssize);
	memptr=memcpy(contdest+destsize, contsrcs, srcssize);
	destsize=destsize+srcssize;
	printf("%s: memptr=memcpy(contdest(%p)+destsize(%d)=%p, contsrcs=%p, srcssize=%d): memptr=%p (char*)memptr-contdest=%d\n", self, contdest, destsize, (void*)(contdest+destsize), (void*)contsrcs, srcssize, memptr, (int)((char*)memptr-contdest));
	
	printf("%s: contdest=", self); for (i=0;i<destsize;i++) { printf("%02X ", contdest[i]); } printf("\n");
	printf("%s: contsrcs=", self); for (i=0;i<srcssize;i++) { printf("%02X ", contsrcs[i]); } printf("\n");
	printf("%s: memptr  =", self); for (i=0;i<destsize;i++) { printf("%02X ", ((char*)memptr)[i]); } printf("\n");
	
	
	
	memset(contdest, 0x00, sizeof(contdest));
	memset(contsrcs, 0x00, sizeof(contsrcs));
	strncpy(contdest, argv[1], sizeof(contdest));
	strncpy(contsrcs, argv[2], sizeof(contsrcs));
	destsize=hex2bin(contdest, strlen(contdest));
	srcssize=hex2bin(contsrcs, strlen(contsrcs));
	
#if defined(HAVE_MEMPCPY)
	printf("%s: memptr=mempcpy(contdest(%p)+destsize(%d)=%p, contsrcs=%p, srcssize=%d):\n", self, contdest, destsize, (void*)(contdest+destsize), (void*)contsrcs, srcssize);
	memptr=mempcpy(contdest+destsize, contsrcs, srcssize);
	destsize=destsize+srcssize;
	printf("%s: memptr=mempcpy(contdest(%p)+destsize(%d)=%p, contsrcs=%p, srcssize=%d): memptr=%p (char*)memptr-contdest=%d\n", self, contdest, destsize, (void*)(contdest+destsize), (void*)contsrcs, srcssize, memptr, (int)((char*)memptr-contdest));
	
	printf("%s: contdest=", self); for (i=0;i<destsize;i++) { printf("%02X ", contdest[i]); } printf("\n");
	printf("%s: contsrcs=", self); for (i=0;i<srcssize;i++) { printf("%02X ", contsrcs[i]); } printf("\n");
	printf("%s: memptr  =", self); for (i=0;i<destsize;i++) { printf("%02X ", ((char*)memptr)[i]); } printf("\n");
#else
	/* mempcpy() is not available on this OS platform !!! */
	printf("%s: mempcpy() is not available on this OS platform !!!\n", self);
#endif
	
	
	
	memset(contdest, 0x00, sizeof(contdest));
	memset(contsrcs, 0x00, sizeof(contsrcs));
	strncpy(contdest, argv[1], sizeof(contdest));
	strncpy(contsrcs, argv[2], sizeof(contsrcs));
	destsize=hex2bin(contdest, strlen(contdest));
	srcssize=hex2bin(contsrcs, strlen(contsrcs));
	
	printf("%s: memptr=memmove(contdest=%p, contsrcs=%p, srcssize=%d):\n", self, (void*)contdest, (void*)contsrcs, srcssize);
	memptr=memmove(contdest+8, contdest+4, 4);
	destsize=destsize+4;
	printf("%s: memptr=memmove(contdest=%p, contsrcs=%p, srcssize=%d): memptr=%p (char*)memptr-contdest=%d\n", self, (void*)contdest, (void*)contsrcs, srcssize, memptr, (int)((char*)memptr-contdest));
	
	printf("%s: contdest=", self); for (i=0;i<destsize;i++) { printf("%02X ", contdest[i]); } printf("\n");
	printf("%s: contsrcs=", self); for (i=0;i<srcssize;i++) { printf("%02X ", contsrcs[i]); } printf("\n");
	printf("%s: memptr  =", self); for (i=0;i<destsize;i++) { printf("%02X ", ((char*)memptr)[i]); } printf("\n");
	
	
	
	memset(contdest, 0x00, sizeof(contdest));
	memset(contsrcs, 0x00, sizeof(contsrcs));
	strncpy(contdest, argv[1], sizeof(contdest));
	strncpy(contsrcs, argv[2], sizeof(contsrcs));
	destsize=hex2bin(contdest, strlen(contdest));
	srcssize=hex2bin(contsrcs, strlen(contsrcs));
	
	printf("%s: memptr=memmove(contdest=%p, contsrcs=%p, srcssize=%d):\n", self, (void*)contdest, (void*)contsrcs, srcssize);
	memptr=memmove(contdest+8, contdest+4, 4);
	destsize=destsize+4;
	printf("%s: memptr=memmove(contdest=%p, contsrcs=%p, srcssize=%d): memptr=%p (char*)memptr-contdest=%d\n", self, (void*)contdest, (void*)contsrcs, srcssize, memptr, (int)((char*)memptr-contdest));
	
	printf("%s: contdest=", self); for (i=0;i<destsize;i++) { printf("%02X ", contdest[i]); } printf("\n");
	printf("%s: contsrcs=", self); for (i=0;i<srcssize;i++) { printf("%02X ", contsrcs[i]); } printf("\n");
	printf("%s: memptr  =", self); for (i=0;i<destsize;i++) { printf("%02X ", ((char*)memptr)[i]); } printf("\n");
	
	
	
	memset(contdest, 0x00, sizeof(contdest));
	memset(contsrcs, 0x00, sizeof(contsrcs));
	strncpy(contdest, argv[1], sizeof(contdest));
	strncpy(contsrcs, argv[2], sizeof(contsrcs));
	destsize=hex2bin(contdest, strlen(contdest));
	srcssize=hex2bin(contsrcs, strlen(contsrcs));
	
	memset(contdest, 0x00, sizeof(contdest));
	memptr=memcpy(contdest, "memmove can be very useful......", strlen("memmove can be very useful......"));
	printf("%s: memptr=memmove(contdest+20, contsrcs+15, 11): contdest=|%s|\n", self, contdest);
	memmove(contdest+20, contdest+15, 11);
	printf("%s: memptr=memmove(contdest+20, contsrcs+15, 11): contdest=|%s|\n", self, contdest);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/memcpy

Usage: /home/local/code/ansiccode/strings/memcpy <some-data>
Examples:
       /home/local/code/ansiccode/strings/memcpy "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" "\x00\x01\x02\x03"
       /home/local/code/ansiccode/strings/memcpy "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" "\x00\x01\x02\x03"

/home/local/code/ansiccode/strings/memcpy "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" "\x00\x01\x02\x03"
/home/local/code/ansiccode/strings/memcpy "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" "\x00\x01\x02\x03"

memcpy: contdest=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
memcpy: contsrcs=00 01 02 03
memcpy: memptr=memcpy(contdest(0xbfc35648)+destsize(16)=0xbfc35658, contsrcs=0xbfc35a48, srcssize=4):
memcpy: memptr=memcpy(contdest(0xbfc35648)+destsize(20)=0xbfc3565c, contsrcs=0xbfc35a48, srcssize=4): memptr=0xbfc35658 (char*)memptr-contdest=16
memcpy: contdest=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03
memcpy: contsrcs=00 01 02 03
memcpy: memptr  =00 01 02 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
memcpy: memptr=memcpy(contdest(0xbfc35648)+destsize(16)=0xbfc35658, contsrcs=0xbfc35a48, srcssize=4):
memcpy: memptr=memcpy(contdest(0xbfc35648)+destsize(20)=0xbfc3565c, contsrcs=0xbfc35a48, srcssize=4): memptr=0xbfc35658 (char*)memptr-contdest=16
memcpy: contdest=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03
memcpy: contsrcs=00 01 02 03
memcpy: memptr  =00 01 02 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
memcpy: memptr=mempcpy(contdest(0xbfc35648)+destsize(16)=0xbfc35658, contsrcs=0xbfc35a48, srcssize=4):
memcpy: memptr=mempcpy(contdest(0xbfc35648)+destsize(20)=0xbfc3565c, contsrcs=0xbfc35a48, srcssize=4): memptr=0xbfc3565c (char*)memptr-contdest=20
memcpy: contdest=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03
memcpy: contsrcs=00 01 02 03
memcpy: memptr  =00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
memcpy: memptr=memmove(contdest=0xbfc35648, contsrcs=0xbfc35a48, srcssize=4):
memcpy: memptr=memmove(contdest=0xbfc35648, contsrcs=0xbfc35a48, srcssize=4): memptr=0xbfc35650 (char*)memptr-contdest=8
memcpy: contdest=00 01 02 03 04 05 06 07 04 05 06 07 0C 0D 0E 0F 00 00 00 00
memcpy: contsrcs=00 01 02 03
memcpy: memptr  =04 05 06 07 0C 0D 0E 0F 00 00 00 00 00 00 00 00 00 00 00 00
memcpy: memptr=memmove(contdest=0xbfc35648, contsrcs=0xbfc35a48, srcssize=4):
memcpy: memptr=memmove(contdest=0xbfc35648, contsrcs=0xbfc35a48, srcssize=4): memptr=0xbfc35650 (char*)memptr-contdest=8
memcpy: contdest=00 01 02 03 04 05 06 07 04 05 06 07 0C 0D 0E 0F 00 00 00 00
memcpy: contsrcs=00 01 02 03
memcpy: memptr  =04 05 06 07 0C 0D 0E 0F 00 00 00 00 00 00 00 00 00 00 00 00
memcpy: memptr=memmove(contdest+20, contsrcs+15, 11): contdest=|memmove can be very useful......|
memcpy: memptr=memmove(contdest+20, contsrcs+15, 11): contdest=|memmove can be very very useful.|

memcpy: contdest=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
memcpy: contsrcs=00 01 02 03
memcpy: memptr=memcpy(contdest(0xbfac44d8)+destsize(16)=0xbfac44e8, contsrcs=0xbfac48d8, srcssize=4):
memcpy: memptr=memcpy(contdest(0xbfac44d8)+destsize(20)=0xbfac44ec, contsrcs=0xbfac48d8, srcssize=4): memptr=0xbfac44e8 (char*)memptr-contdest=16
memcpy: contdest=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03
memcpy: contsrcs=00 01 02 03
memcpy: memptr  =00 01 02 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
memcpy: memptr=memcpy(contdest(0xbfac44d8)+destsize(16)=0xbfac44e8, contsrcs=0xbfac48d8, srcssize=4):
memcpy: memptr=memcpy(contdest(0xbfac44d8)+destsize(20)=0xbfac44ec, contsrcs=0xbfac48d8, srcssize=4): memptr=0xbfac44e8 (char*)memptr-contdest=16
memcpy: contdest=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03
memcpy: contsrcs=00 01 02 03
memcpy: memptr  =00 01 02 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
memcpy: memptr=mempcpy(contdest(0xbfac44d8)+destsize(16)=0xbfac44e8, contsrcs=0xbfac48d8, srcssize=4):
memcpy: memptr=mempcpy(contdest(0xbfac44d8)+destsize(20)=0xbfac44ec, contsrcs=0xbfac48d8, srcssize=4): memptr=0xbfac44ec (char*)memptr-contdest=20
memcpy: contdest=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03
memcpy: contsrcs=00 01 02 03
memcpy: memptr  =00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
memcpy: memptr=memmove(contdest=0xbfac44d8, contsrcs=0xbfac48d8, srcssize=4):
memcpy: memptr=memmove(contdest=0xbfac44d8, contsrcs=0xbfac48d8, srcssize=4): memptr=0xbfac44e0 (char*)memptr-contdest=8
memcpy: contdest=00 01 02 03 04 05 06 07 04 05 06 07 0C 0D 0E 0F 00 00 00 00
memcpy: contsrcs=00 01 02 03
memcpy: memptr  =04 05 06 07 0C 0D 0E 0F 00 00 00 00 00 00 00 00 00 00 00 00
memcpy: memptr=memmove(contdest=0xbfac44d8, contsrcs=0xbfac48d8, srcssize=4):
memcpy: memptr=memmove(contdest=0xbfac44d8, contsrcs=0xbfac48d8, srcssize=4): memptr=0xbfac44e0 (char*)memptr-contdest=8
memcpy: contdest=00 01 02 03 04 05 06 07 04 05 06 07 0C 0D 0E 0F 00 00 00 00
memcpy: contsrcs=00 01 02 03
memcpy: memptr  =04 05 06 07 0C 0D 0E 0F 00 00 00 00 00 00 00 00 00 00 00 00
memcpy: memptr=memmove(contdest+20, contsrcs+15, 11): contdest=|memmove can be very useful......|
memcpy: memptr=memmove(contdest+20, contsrcs+15, 11): contdest=|memmove can be very very useful.|

#top memmem¶

/* Find the first occurrence of NEEDLE in HAYSTACK.
   NEEDLE is NEEDLELEN bytes long;
   HAYSTACK is HAYSTACKLEN bytes long.  */
extern void *memmem (__const void *__haystack, size_t __haystacklen,
             __const void *__needle, size_t __needlelen)
     __THROW __attribute_pure__ __nonnull ((1, 3));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int hex2bin(char *buffdata, const int buffsize) {
	char hexchar[256];
	int ihex, ibin;
	
	memset(hexchar, 0x00, sizeof(hexchar));
	
	hexchar[0x30]=0x00;
	hexchar[0x31]=0x01;
	hexchar[0x32]=0x02;
	hexchar[0x33]=0x03;
	hexchar[0x34]=0x04;
	hexchar[0x35]=0x05;
	hexchar[0x36]=0x06;
	hexchar[0x37]=0x07;
	hexchar[0x38]=0x08;
	hexchar[0x39]=0x09;
	
	hexchar[0x41]=0x0A;
	hexchar[0x42]=0x0B;
	hexchar[0x43]=0x0C;
	hexchar[0x44]=0x0D;
	hexchar[0x45]=0x0E;
	hexchar[0x46]=0x0F;
	
	hexchar[0x61]=0x0A;
	hexchar[0x62]=0x0B;
	hexchar[0x63]=0x0C;
	hexchar[0x64]=0x0D;
	hexchar[0x65]=0x0E;
	hexchar[0x66]=0x0F;
	
	ibin=0;
	for (ihex=0;ihex<buffsize;ihex++) {
		if (buffdata[ihex]==0x5C && ihex+3<buffsize && (buffdata[ihex+1]==0x58||buffdata[ihex+1]==0x78)
			&& ((0x30<=buffdata[ihex+2]&&buffdata[ihex+2]<=0x39) || (0x41<=buffdata[ihex+2]&&buffdata[ihex+2]<=0x46) || (0x61<=buffdata[ihex+2]&&buffdata[ihex+2]<=0x66))
			&& ((0x30<=buffdata[ihex+3]&&buffdata[ihex+3]<=0x39) || (0x41<=buffdata[ihex+3]&&buffdata[ihex+3]<=0x46) || (0x61<=buffdata[ihex+3]&&buffdata[ihex+3]<=0x66))
			) {
			buffdata[ibin]= (hexchar[ (unsigned char)buffdata[ihex+2] ]<<4) + (hexchar[ (unsigned char)buffdata[ihex+3] ]);
			ihex=ihex+3;
			ibin++;
			continue;
		}
		if (ihex!=ibin) buffdata[ibin]=buffdata[ihex];
		ibin++;
	}
	for (ihex=ibin;ihex<buffsize;ihex++) buffdata[ihex]=0x00;
	
	return ibin;
}



void *memrmem(const void *haystack, size_t haystacklen, const void *needle, size_t needlelen) {
	void *memptr1;
	void *memptr2;
	
	memptr1=memptr2=memmem(haystack, haystacklen, needle, needlelen);
	while (memptr2!=NULL) {
		memptr1=memptr2;
		memptr2=memmem((char*)memptr1+1, haystacklen-((char*)memptr1-(char*)haystack), needle, needlelen);
	}
	return memptr1;
}



int main(int argc, char **argv) {
	char contdata[1024];
	char searched[64];
	int  contsize;
	int  srchsize;
	
	char chfirst[16];
	char chlasts[16];
	int  ifirst;
	int  ilasts;
	
	char *memptr;
	int i;
	
	if (argc<5) {
		printf("Usage: %s <contdata> <searched> <chfirst> <chlasts>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s \"\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\\x0F\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\\x0F\" \"\\x0A\\x0B\\x0C\" \"x08\" \"x08\"\n", argv[0]);
		printf("       %s \"\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\\x0F\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\\x0F\" \"\\x00\\x01\\x02\" \"x00\" \"x0F\"\n", argv[0]);
		printf("       %s \"\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\\x0F\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\\x0F\" \"\\x01\\x01\\x01\" \"x88\" \"xFF\"\n", argv[0]);
		return 0;
	}
	
	memset(contdata, 0x00, sizeof(contdata));
	memset(searched, 0x00, sizeof(searched));
	strncpy(contdata, argv[1], sizeof(contdata));
	strncpy(searched, argv[2], sizeof(searched));
	contsize=hex2bin(contdata, strlen(contdata));
	srchsize=hex2bin(searched, strlen(searched));
	
	memset(chfirst, 0x00, sizeof(chfirst));
	memset(chlasts, 0x00, sizeof(chlasts));
	strncpy(chfirst, argv[3], sizeof(chfirst));
	strncpy(chlasts, argv[4], sizeof(chlasts));
	hex2bin(chfirst, strlen(chfirst));
	hex2bin(chlasts, strlen(chlasts));
	
	printf("%s: contdata=", argv[0]); for (i=0;i<contsize;i++) { printf("%02X ", contdata[i]); } printf("\n");
	printf("%s: searched=", argv[0]); for (i=0;i<srchsize;i++) { printf("%02X ", searched[i]); } printf("\n");
	
	memptr=memmem(contdata, contsize, searched, srchsize);
	if (memptr!=NULL) printf("%s: memptr=memmem(contdata=%p, contsize=%d, searched=%p, srchsize=%d): memptr=%p memptr-contdata=%d\n", argv[0], contdata, contsize, searched, srchsize, memptr, memptr-contdata);
	else              printf("%s: memptr=memmem(contdata=%p, contsize=%d, searched=%p, srchsize=%d): memptr=%p\n", argv[0], contdata, contsize, searched, srchsize, memptr);
	if (memptr!=NULL) {
		printf("%s: contdata=", argv[0]); for (i=0;i<contsize;i++) { printf("%02X ", contdata[i]); } printf("\n");
		printf("%s: searched=", argv[0]); for (i=0;i<3*(memptr-contdata);i++) printf(" "); for (i=0;i<srchsize;i++) { printf("%02X ", searched[i]); } printf("\n");
	}
	
	memptr=memrmem(contdata, contsize, searched, srchsize);
	if (memptr!=NULL) printf("%s: memptr=memrmem(contdata=%p, contsize=%d, searched=%p, srchsize=%d): memptr=%p memptr-contdata=%d\n", argv[0], contdata, contsize, searched, srchsize, memptr, memptr-contdata);
	else              printf("%s: memptr=memrmem(contdata=%p, contsize=%d, searched=%p, srchsize=%d): memptr=%p\n", argv[0], contdata, contsize, searched, srchsize, memptr);
	if (memptr!=NULL) {
		printf("%s: contdata=", argv[0]); for (i=0;i<contsize;i++) { printf("%02X ", contdata[i]); } printf("\n");
		printf("%s: searched=", argv[0]); for (i=0;i<3*(memptr-contdata);i++) printf(" "); for (i=0;i<srchsize;i++) { printf("%02X ", searched[i]); } printf("\n");
	}
	
	ifirst=chfirst[0];
	memptr=memchr(contdata, ifirst, contsize);
	if (memptr!=NULL) printf("%s: memptr=memchr (contdata=%p, ifirst=%02X, contsize=%d): memptr=%p memptr-contdata=%d\n", argv[0], contdata, ifirst, contsize, memptr, memptr-contdata);
	else              printf("%s: memptr=memchr (contdata=%p, ifirst=%02X, contsize=%d): memptr=%p\n", argv[0], contdata, ifirst, contsize, memptr);
	if (memptr!=NULL) {
		printf("%s: contdata=", argv[0]); for (i=0;i<contsize;i++) { printf("%02X ", contdata[i]); } printf("\n");
		printf("%s: searched=", argv[0]); for (i=0;i<3*(memptr-contdata);i++) printf(" "); printf("%02X ", chfirst[0]); printf("\n");
	}
	
	ilasts=chlasts[0];
	memptr=memrchr(contdata, ilasts, contsize);
	if (memptr!=NULL) printf("%s: memptr=memrchr(contdata=%p, ilasts=%02X, contsize=%d): memptr=%p memptr-contdata=%d\n", argv[0], contdata, ilasts, contsize, memptr, memptr-contdata);
	else              printf("%s: memptr=memrchr(contdata=%p, ilasts=%02X, contsize=%d): memptr=%p\n", argv[0], contdata, ilasts, contsize, memptr);
	if (memptr!=NULL) {
		printf("%s: contdata=", argv[0]); for (i=0;i<contsize;i++) { printf("%02X ", contdata[i]); } printf("\n");
		printf("%s: searched=", argv[0]); for (i=0;i<3*(memptr-contdata);i++) printf(" "); printf("%02X ", chlasts[0]); printf("\n");
	}
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/memmem

Usage: /home/local/code/ansiccode/strings/memmem <contdata> <searched> <chfirst> <chlasts>
Examples:
       /home/local/code/ansiccode/strings/memmem "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" "\x0A\x0B\x0C" "x08" "x08"
       /home/local/code/ansiccode/strings/memmem "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" "\x00\x01\x02" "x00" "x0F"
       /home/local/code/ansiccode/strings/memmem "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" "\x01\x01\x01" "x88" "xFF"

/home/local/code/ansiccode/strings/memmem "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" "\x0A\x0B\x0C" "x08" "x08"
/home/local/code/ansiccode/strings/memmem "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" "\x00\x01\x02" "x00" "x0F"
/home/local/code/ansiccode/strings/memmem "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F" "\x01\x01\x01" "x88" "xFF"

/home/local/code/ansiccode/strings/memmem: contdata=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
/home/local/code/ansiccode/strings/memmem: searched=0A 0B 0C
/home/local/code/ansiccode/strings/memmem: memptr=memmem(contdata=0xbfe44848, contsize=32, searched=0xbfe44c48, srchsize=3): memptr=0xbfe44852 memptr-contdata=10
/home/local/code/ansiccode/strings/memmem: contdata=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
/home/local/code/ansiccode/strings/memmem: searched=                              0A 0B 0C
/home/local/code/ansiccode/strings/memmem: memptr=memrmem(contdata=0xbfe44848, contsize=32, searched=0xbfe44c48, srchsize=3): memptr=0xbfe44862 memptr-contdata=26
/home/local/code/ansiccode/strings/memmem: contdata=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
/home/local/code/ansiccode/strings/memmem: searched=                                                                              0A 0B 0C
/home/local/code/ansiccode/strings/memmem: memptr=memchr (contdata=0xbfe44848, ifirst=78, contsize=32): memptr=(nil)
/home/local/code/ansiccode/strings/memmem: memptr=memrchr(contdata=0xbfe44848, ilasts=78, contsize=32): memptr=(nil)

/home/local/code/ansiccode/strings/memmem: contdata=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
/home/local/code/ansiccode/strings/memmem: searched=00 01 02
/home/local/code/ansiccode/strings/memmem: memptr=memmem(contdata=0xbff42148, contsize=32, searched=0xbff42548, srchsize=3): memptr=0xbff42148 memptr-contdata=0
/home/local/code/ansiccode/strings/memmem: contdata=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
/home/local/code/ansiccode/strings/memmem: searched=00 01 02
/home/local/code/ansiccode/strings/memmem: memptr=memrmem(contdata=0xbff42148, contsize=32, searched=0xbff42548, srchsize=3): memptr=0xbff42158 memptr-contdata=16
/home/local/code/ansiccode/strings/memmem: contdata=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
/home/local/code/ansiccode/strings/memmem: searched=                                                00 01 02
/home/local/code/ansiccode/strings/memmem: memptr=memchr (contdata=0xbff42148, ifirst=78, contsize=32): memptr=(nil)
/home/local/code/ansiccode/strings/memmem: memptr=memrchr(contdata=0xbff42148, ilasts=78, contsize=32): memptr=(nil)

/home/local/code/ansiccode/strings/memmem: contdata=00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
/home/local/code/ansiccode/strings/memmem: searched=01 01 01
/home/local/code/ansiccode/strings/memmem: memptr=memmem(contdata=0xbfd65768, contsize=32, searched=0xbfd65b68, srchsize=3): memptr=(nil)
/home/local/code/ansiccode/strings/memmem: memptr=memrmem(contdata=0xbfd65768, contsize=32, searched=0xbfd65b68, srchsize=3): memptr=(nil)
/home/local/code/ansiccode/strings/memmem: memptr=memchr (contdata=0xbfd65768, ifirst=78, contsize=32): memptr=(nil)
/home/local/code/ansiccode/strings/memmem: memptr=memrchr(contdata=0xbfd65768, ilasts=78, contsize=32): memptr=(nil)

#top memmove¶

/* Copy N bytes of SRC to DEST, guaranteeing
   correct behavior for overlapping strings.  */
extern void *memmove (void *__dest, __const void *__src, size_t __n)
     __THROW __nonnull ((1, 2));

#top mempcpy¶

/* Copy N bytes of SRC to DEST, return pointer to bytes after the
   last written byte.  */
extern void *mempcpy (void *__restrict __dest,
              __const void *__restrict __src, size_t __n)
     __THROW __nonnull ((1, 2));

#top memrchr¶

/* Search N bytes of S for the final occurrence of C.  */
extern void *memrchr (__const void *__s, int __c, size_t __n)
      __THROW __attribute_pure__ __nonnull ((1));

#top memset¶

/* Set N bytes of S to C.  */
extern void *memset (void *__s, int __c, size_t __n) __THROW __nonnull ((1));

char buffdata[8192];
memset(buffdata, 0x00, sizeof(buffdata));

struct sockaddr_in inet4addr;
memset(&inet4addr, 0x00, sizeof(struct sockaddr_in));

#top printf¶

/* Write formatted output to stdout.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern int printf (__const char *__restrict __format, ...);

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset memcmp memchr str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	
	if (argc<1) {
		printf("Usage: %s <arg>\n", argv[0]);
		return 1;
	}
	
	printf("%s: printf formatted string into stdout, main(int argc, char **argv): argc=%d argv[0]=%s)\n", argv[0], argc, argv[0]);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/printf

/home/local/code/ansiccode/strings/printf: printf formatted string into stdout, main(int argc, char **argv): argc=1 argv[0]=/home/local/code/ansiccode/strings/printf)

#top putchar¶

/* Write a character to stdout.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern int putchar (int __c);

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset memcmp memchr str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	int result;
	int onechar;
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 1;
	}
	
	onechar='A';
	printf("%s: putchar(onechar): ", argv[0]);
	fflush(stdout);
	result=putchar(onechar);
	putc('\n', stdout);
	printf("%s: putchar(onechar): result=%d\n", argv[0], result);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/putchar

/home/local/code/ansiccode/strings/putchar: putchar(onechar): A
/home/local/code/ansiccode/strings/putchar: putchar(onechar): result=65

#top puts¶

/* Write a string, followed by a newline, to stdout.

   This function is a possible cancellation points and therefore not
   marked with __THROW.  */
extern int puts (__const char *__s);

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset memcmp memchr str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 1;
	}
	
	puts("puts:line1");
	puts("puts:line2");
	puts("puts:line3");
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/puts

puts:line1
puts:line2
puts:line3

#top rawmemchr¶

/* Search in S for C.  This is similar to `memchr' but there is no
   length limit.  */
extern void *rawmemchr (__const void *__s, int __c)
     __THROW __attribute_pure__ __nonnull ((1));

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

#top rindex¶

/* Find the last occurrence of C in S (same as strrchr).  *:
extern char *rindex (__const char *__s, int __c)
     __THROW __attribute_pure__ __nonnull ((1));

#top scanf¶

/* Read formatted input from stdin.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern int scanf (__const char *__restrict __format, ...) __wur;

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset memcmp memchr str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	int result;
	int argint;
	double argdouble;
	char argchar;
	char argstr[1024];
	
	if (argc<1) {
		printf("Usage: %s <arg>\n", argv[0]);
		return 1;
	}
	
	printf("%s: scanf(%%d, &argint): ", argv[0]);
	fflush(stdout);
	result=scanf("%d", &argint);
	printf("%s: scanf(%%d, &argint): argint=%d result=%d\n", argv[0], argint, result);
	
	printf("%s: scanf(%%f, &argdouble): ", argv[0]);
	fflush(stdout);
	result=scanf("%lf", &argdouble);
	printf("%s: scanf(%%f, &argdouble): argdouble=%f result=%d\n", argv[0], argdouble, result);
	
	printf("%s: scanf(%%c, &argchar): ", argv[0]);
	fflush(stdout);
	result=scanf("%c", &argchar);
	printf("%s: scanf(%%c, &argchar): argchar=%c result=%d\n", argv[0], argchar, result);
	
	printf("%s: scanf(%%c, &argchar): ", argv[0]);
	fflush(stdout);
	result=scanf("%c", &argchar);
	printf("%s: scanf(%%c, &argchar): argchar=%c result=%d\n", argv[0], argchar, result);
	
	printf("%s: scanf(%%s, &argstr): ", argv[0]);
	fflush(stdout);
	result=scanf("%s", argstr);
	printf("%s: scanf(%%s, &argstr): argstr=%s result=%d\n", argv[0], argstr, result);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/snprintf

1
2.5
123asd

/home/local/code/ansiccode/strings/scanf: scanf(%d, &argint): 1
/home/local/code/ansiccode/strings/scanf: scanf(%d, &argint): argint=1 result=1
/home/local/code/ansiccode/strings/scanf: scanf(%f, &argdouble): 2.5
/home/local/code/ansiccode/strings/scanf: scanf(%f, &argdouble): argdouble=2.500000 result=1
/home/local/code/ansiccode/strings/scanf: scanf(%c, &argchar): /home/local/code/ansiccode/strings/scanf: scanf(%c, &argchar): argchar=
 result=1
/home/local/code/ansiccode/strings/scanf: scanf(%c, &argchar): 123asd
/home/local/code/ansiccode/strings/scanf: scanf(%c, &argchar): argchar=1 result=1
/home/local/code/ansiccode/strings/scanf: scanf(%s, &argstr): /home/local/code/ansiccode/strings/scanf: scanf(%s, &argstr): argstr=23asd result=1

#top snprintf¶

* Maximum chars of output to write in MAXLEN.  */
extern int snprintf (char *__restrict __s, size_t __maxlen,
             __const char *__restrict __format, ...)
     __THROW __attribute__ ((__format__ (__printf__, 3, 4)));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset memcmp memchr str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	char buffer[1024];
	
	if (argc<1) {
		printf("Usage: %s <arg>\n", argv[0]);
		return 1;
	}
	
	snprintf(buffer, sizeof(buffer), "%s: printf formatted string into buffer, main(int argc, char **argv): argc=%d argv[0]=%s)", argv[0], argc, argv[0]);
	printf("%s: buffer=|%s|\n", argv[0], buffer);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/snprintf

/home/local/code/ansiccode/strings/snprintf: buffer=|/home/local/code/ansiccode/strings/snprintf: printf formatted string into buffer, main(int argc, char **argv): argc=1 argv[0]=/home/local/code/ansiccode/strings/snprintf)|

#top sprintf¶

/* Write formatted output to S.  */
extern int sprintf (char *__restrict __s,
            __const char *__restrict __format, ...) __THROW;

#top sscanf¶

/* Read formatted input from S.  */
extern int sscanf (__const char *__restrict __s,
           __const char *__restrict __format, ...) __THROW;

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset memcmp memchr str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	int result;
	char line[1024];
	int argint;
	double argdouble;
	char argchar;
	char argstr[1024];
	
	if (argc<1) {
		printf("Usage: %s <arg>\n", argv[0]);
		return 1;
	}
	
	printf("%s: scanf(%%d, &argint): ", argv[0]);
	fflush(stdout);
	if (gets(line)) {
	result=sscanf(line, "%d", &argint);
	printf("%s: result=scanf(%%d, &argint): result=%d argint=%d\n", argv[0], result, argint);
	}
	
	printf("%s: scanf(%%f, &argdouble): ", argv[0]);
	fflush(stdout);
	if (gets(line)) {
	result=sscanf(line, "%lf", &argdouble);
	printf("%s: scanf(%%f, &argdouble): argdouble=%f result=%d\n", argv[0], argdouble, result);
	}
	
	printf("%s: scanf(%%c, &argchar): ", argv[0]);
	fflush(stdout);
	if (gets(line)) {
	result=sscanf(line, "%c", &argchar);
	printf("%s: scanf(%%c, &argchar): argchar=%c result=%d\n", argv[0], argchar, result);
	}
	
	printf("%s: scanf(%%c, &argchar): ", argv[0]);
	fflush(stdout);
	if (gets(line)) {
	result=sscanf(line, "%c", &argchar);
	printf("%s: scanf(%%c, &argchar): argchar=%c result=%d\n", argv[0], argchar, result);
	}
	
	printf("%s: scanf(%%s, &argstr): ", argv[0]);
	fflush(stdout);
	if (gets(line)) {
	result=sscanf(line, "%s", argstr);
	printf("%s: scanf(%%s, &argstr): argstr=%s result=%d\n", argv[0], argstr, result);
	}
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/sscanf

1
2.5
a
@
123asd

/home/local/code/ansiccode/strings/sscanf: scanf(%d, &argint): 1
/home/local/code/ansiccode/strings/sscanf: result=scanf(%d, &argint): result=1 argint=1
/home/local/code/ansiccode/strings/sscanf: scanf(%f, &argdouble): 2.5
/home/local/code/ansiccode/strings/sscanf: scanf(%f, &argdouble): argdouble=2.500000 result=1
/home/local/code/ansiccode/strings/sscanf: scanf(%c, &argchar): a
/home/local/code/ansiccode/strings/sscanf: scanf(%c, &argchar): argchar=a result=1
/home/local/code/ansiccode/strings/sscanf: scanf(%c, &argchar): @
/home/local/code/ansiccode/strings/sscanf: scanf(%c, &argchar): argchar=@ result=1
/home/local/code/ansiccode/strings/sscanf: scanf(%s, &argstr): 123asd
/home/local/code/ansiccode/strings/sscanf: scanf(%s, &argstr): argstr=123asd result=1

#top strcasestr¶

/* Similar to `strstr' but this function ignores the case of both strings.  *:
extern char *strcasestr (__const char *__haystack, __const char *__needle)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#top strcat¶

/* Append SRC onto DEST.  */
extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
     __THROW __nonnull ((1, 2));

#top strchr¶

/* Find the first occurrence of C in S.  */
extern char *strchr (__const char *__s, int __c)
     __THROW __attribute_pure__ __nonnull ((1));

#top strcmp¶

/* Compare S1 and S2.  */
extern int strcmp (__const char *__s1, __const char *__s2)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#top strcoll¶

/* Compare the collated forms of S1 and S2.  */
extern int strcoll (__const char *__s1, __const char *__s2)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <locale.h>



int main(int argc, char **argv) {
	char *self;
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       LC_COLLATE=pl_PL.UTF-8 %s texta textd\n", argv[0]);
		printf("       LC_COLLATE=pl_PL.UTF-8 %s textą textd\n", argv[0]);
		printf("       LC_COLLATE=pl_PL.UTF-8 %s textb textd\n", argv[0]);
		printf("       LC_COLLATE=pl_PL.UTF-8 %s textc textd\n", argv[0]);
		printf("       LC_COLLATE=pl_PL.UTF-8 %s textć textd\n", argv[0]);
		printf("       LC_COLLATE=pl_PL.UTF-8 %s textd textd\n", argv[0]);
		printf("       LC_COLLATE=pl_PL.UTF-8 %s texte textd\n", argv[0]);
		printf("       LC_COLLATE=pl_PL.UTF-8 %s textę textd\n", argv[0]);
		printf("       LC_COLLATE=pl_PL.UTF-8 %s textf textd\n", argv[0]);
		return 0;
	}
	
	printf("setlocale(LC_COLLATE,\"\")=%s\n", setlocale(LC_COLLATE,""));
	printf("%s: result=strncmp(argv[1]=|%s|, argv[2]=|%s|):\n", self, argv[1], argv[2]);
	result=strcoll(argv[1], argv[2]);
	printf("%s: result=strncmp(argv[1]=|%s|, argv[2]=|%s|): result=%d\n", self, argv[1], argv[2], result);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strcoll

Usage: /home/local/code/ansiccode/strings/strcoll <some-text>
Examples:
       LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll texta textd
       LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textą textd
       LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textb textd
       LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textc textd
       LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textć textd
       LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textd textd
       LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll texte textd
       LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textę textd
       LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textf textd
       LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll texth textd

LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll texta textd
LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textą textd
LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textb textd
LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textc textd
LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textć textd
LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textd textd
LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll texte textd
LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textę textd
LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll textf textd
LC_COLLATE=pl_PL.UTF-8 /home/local/code/ansiccode/strings/strcoll texth textd

setlocale(LC_COLLATE,"")=pl_PL.UTF-8
strcoll: result=strncmp(argv[1]=|texta|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|texta|, argv[2]=|textd|): result=-5

setlocale(LC_COLLATE,"")=pl_PL.UTF-8
strcoll: result=strncmp(argv[1]=|textą|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textą|, argv[2]=|textd|): result=-4

setlocale(LC_COLLATE,"")=pl_PL.UTF-8
strcoll: result=strncmp(argv[1]=|textb|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textb|, argv[2]=|textd|): result=-3

setlocale(LC_COLLATE,"")=pl_PL.UTF-8
strcoll: result=strncmp(argv[1]=|textc|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textc|, argv[2]=|textd|): result=-2

setlocale(LC_COLLATE,"")=pl_PL.UTF-8
strcoll: result=strncmp(argv[1]=|textć|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textć|, argv[2]=|textd|): result=-1

setlocale(LC_COLLATE,"")=pl_PL.UTF-8
strcoll: result=strncmp(argv[1]=|textd|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textd|, argv[2]=|textd|): result=0

setlocale(LC_COLLATE,"")=pl_PL.UTF-8
strcoll: result=strncmp(argv[1]=|texte|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|texte|, argv[2]=|textd|): result=1

setlocale(LC_COLLATE,"")=pl_PL.UTF-8
strcoll: result=strncmp(argv[1]=|textę|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textę|, argv[2]=|textd|): result=2

setlocale(LC_COLLATE,"")=pl_PL.UTF-8
strcoll: result=strncmp(argv[1]=|textf|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textf|, argv[2]=|textd|): result=3

setlocale(LC_COLLATE,"")=pl_PL.UTF-8
strcoll: result=strncmp(argv[1]=|texth|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|texth|, argv[2]=|textd|): result=5

LC_COLLATE=en_US.UTF-8 /home/local/code/ansiccode/strings/strcoll texta textd
LC_COLLATE=en_US.UTF-8 /home/local/code/ansiccode/strings/strcoll textą textd
LC_COLLATE=en_US.UTF-8 /home/local/code/ansiccode/strings/strcoll textb textd
LC_COLLATE=en_US.UTF-8 /home/local/code/ansiccode/strings/strcoll textc textd
LC_COLLATE=en_US.UTF-8 /home/local/code/ansiccode/strings/strcoll textć textd
LC_COLLATE=en_US.UTF-8 /home/local/code/ansiccode/strings/strcoll textd textd
LC_COLLATE=en_US.UTF-8 /home/local/code/ansiccode/strings/strcoll texte textd
LC_COLLATE=en_US.UTF-8 /home/local/code/ansiccode/strings/strcoll textę textd
LC_COLLATE=en_US.UTF-8 /home/local/code/ansiccode/strings/strcoll textf textd
LC_COLLATE=en_US.UTF-8 /home/local/code/ansiccode/strings/strcoll texth textd

setlocale(LC_COLLATE,"")=en_US.UTF-8
strcoll: result=strncmp(argv[1]=|texta|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|texta|, argv[2]=|textd|): result=-3

setlocale(LC_COLLATE,"")=en_US.UTF-8
strcoll: result=strncmp(argv[1]=|textą|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textą|, argv[2]=|textd|): result=-3

setlocale(LC_COLLATE,"")=en_US.UTF-8
strcoll: result=strncmp(argv[1]=|textb|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textb|, argv[2]=|textd|): result=-2

setlocale(LC_COLLATE,"")=en_US.UTF-8
strcoll: result=strncmp(argv[1]=|textc|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textc|, argv[2]=|textd|): result=-1

setlocale(LC_COLLATE,"")=en_US.UTF-8
strcoll: result=strncmp(argv[1]=|textć|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textć|, argv[2]=|textd|): result=-1

setlocale(LC_COLLATE,"")=en_US.UTF-8
strcoll: result=strncmp(argv[1]=|textd|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textd|, argv[2]=|textd|): result=0

setlocale(LC_COLLATE,"")=en_US.UTF-8
strcoll: result=strncmp(argv[1]=|texte|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|texte|, argv[2]=|textd|): result=1

setlocale(LC_COLLATE,"")=en_US.UTF-8
strcoll: result=strncmp(argv[1]=|textę|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textę|, argv[2]=|textd|): result=1

setlocale(LC_COLLATE,"")=en_US.UTF-8
strcoll: result=strncmp(argv[1]=|textf|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textf|, argv[2]=|textd|): result=2

setlocale(LC_COLLATE,"")=en_US.UTF-8
strcoll: result=strncmp(argv[1]=|texth|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|texth|, argv[2]=|textd|): result=4

LC_COLLATE=C /home/local/code/ansiccode/strings/strcoll texta textd
LC_COLLATE=C /home/local/code/ansiccode/strings/strcoll textą textd
LC_COLLATE=C /home/local/code/ansiccode/strings/strcoll textb textd
LC_COLLATE=C /home/local/code/ansiccode/strings/strcoll textc textd
LC_COLLATE=C /home/local/code/ansiccode/strings/strcoll textć textd
LC_COLLATE=C /home/local/code/ansiccode/strings/strcoll textd textd
LC_COLLATE=C /home/local/code/ansiccode/strings/strcoll texte textd
LC_COLLATE=C /home/local/code/ansiccode/strings/strcoll textę textd
LC_COLLATE=C /home/local/code/ansiccode/strings/strcoll textf textd
LC_COLLATE=C /home/local/code/ansiccode/strings/strcoll texth textd

setlocale(LC_COLLATE,"")=C
strcoll: result=strncmp(argv[1]=|texta|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|texta|, argv[2]=|textd|): result=-1

setlocale(LC_COLLATE,"")=C
strcoll: result=strncmp(argv[1]=|textą|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textą|, argv[2]=|textd|): result=1

setlocale(LC_COLLATE,"")=C
strcoll: result=strncmp(argv[1]=|textb|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textb|, argv[2]=|textd|): result=-1

setlocale(LC_COLLATE,"")=C
strcoll: result=strncmp(argv[1]=|textc|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textc|, argv[2]=|textd|): result=-1

setlocale(LC_COLLATE,"")=C
strcoll: result=strncmp(argv[1]=|textć|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textć|, argv[2]=|textd|): result=1

setlocale(LC_COLLATE,"")=C
strcoll: result=strncmp(argv[1]=|textd|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textd|, argv[2]=|textd|): result=0

setlocale(LC_COLLATE,"")=C
strcoll: result=strncmp(argv[1]=|texte|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|texte|, argv[2]=|textd|): result=1

setlocale(LC_COLLATE,"")=C
strcoll: result=strncmp(argv[1]=|textę|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textę|, argv[2]=|textd|): result=1

setlocale(LC_COLLATE,"")=C
strcoll: result=strncmp(argv[1]=|textf|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|textf|, argv[2]=|textd|): result=1

setlocale(LC_COLLATE,"")=C
strcoll: result=strncmp(argv[1]=|texth|, argv[2]=|textd|):
strcoll: result=strncmp(argv[1]=|texth|, argv[2]=|textd|): result=1

#top strcpy¶

/* Copy SRC to DEST.  */
extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     __THROW __nonnull ((1, 2));

#top strcspn¶

/* Return the length of the initial segment of S which
   consists entirely of characters not in REJECT.  */
extern size_t strcspn (__const char *__s, __const char *__reject)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#top strdup¶

#if defined __USE_SVID || defined __USE_BSD || defined __USE_XOPEN_EXTENDED
/* Duplicate S, returning an identical malloc'd string.  */
extern char *strdup (__const char *__s)
     __THROW __attribute_malloc__ __nonnull ((1));
#endif

#top strerror¶

/* Return a string describing the meaning of the `errno' code in ERRNUM.  */
extern char *strerror (int __errnum) __THROW;

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkstemp(), mkdtemp(), system(), realpath(), abs(), labs(), llabs(), getloadavg(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_STRERROR)
	int  ierr;
	char *serr;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s\n", argv[0]);
		printf("Examples:\n");
		printf("       %s 0\n", argv[0]);
		printf("       %s 1\n", argv[0]);
		printf("       %s 2\n", argv[0]);
		printf("       %s 3\n", argv[0]);
		printf("       %s 5\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_STRERROR)
	ierr=atoi(argv[1]);
	serr=strerror(ierr);
	printf("serr=strerror(%d): SystemCall result: ierr:serr=%d:%s\n", ierr, ierr, serr);
#endif
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strerror

Usage: /home/local/code/ansiccode/strings/strerror
Examples:
       /home/local/code/ansiccode/strings/strerror 0
       /home/local/code/ansiccode/strings/strerror 1
       /home/local/code/ansiccode/strings/strerror 2
       /home/local/code/ansiccode/strings/strerror 3
       /home/local/code/ansiccode/strings/strerror 5

/home/local/code/ansiccode/strings/strerror 0
/home/local/code/ansiccode/strings/strerror 1
/home/local/code/ansiccode/strings/strerror 2
/home/local/code/ansiccode/strings/strerror 3
/home/local/code/ansiccode/strings/strerror 5

serr=strerror(0): SystemCall result: ierr:serr=0:Success

serr=strerror(1): SystemCall result: ierr:serr=1:Operation not permitted

serr=strerror(2): SystemCall result: ierr:serr=2:No such file or directory

serr=strerror(3): SystemCall result: ierr:serr=3:No such process

serr=strerror(5): SystemCall result: ierr:serr=5:Input/output error

#top strfmon¶

/* Formatting a monetary value according to the current locale.  */
extern ssize_t strfmon (char *__restrict __s, size_t __maxsize,
            __const char *__restrict __format, ...)
     __THROW __attribute_format_strfmon__ (3, 4);

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

#top strlen¶

/* Return the length of S.  */
extern size_t strlen (__const char *__s)
     __THROW __attribute_pure__ __nonnull ((1));

#top strncasecmp¶

/* Compare no more than N chars of S1 and S2, ignoring case.  */
extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#top strncat¶

/* Append no more than N characters from SRC onto DEST.  */
extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
              size_t __n) __THROW __nonnull ((1, 2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	char line1[16];
	char line2[16];
	char line3[16];
	char line4[16];
	char line5[16];
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s 0123456789\n", argv[0]);
		return 0;
	}
	
	memset(line1, 0x00, sizeof(line1));
	memset(line2, 0x00, sizeof(line2));
	memset(line3, 0x00, sizeof(line3));
	memset(line4, 0x00, sizeof(line4));
	memset(line5, 0x00, sizeof(line5));
	
	strncat(line3, argv[1], sizeof(line3));
	printf("%s: line1=|%s| line2=|%s| line3=|%s| line4=|%s| line5=|%s|\n", self, line1, line2, line3, line4, line5);
	
	strncat(line3, argv[1], sizeof(line3));
	printf("%s: line1=|%s| line2=|%s| line3=|%s| line4=|%s| line5=|%s|\n", self, line1, line2, line3, line4, line5);
	
	strncat(line3, argv[1], sizeof(line3));
	printf("%s: line1=|%s| line2=|%s| line3=|%s| line4=|%s| line5=|%s|\n", self, line1, line2, line3, line4, line5);
	
	strncat(line2, argv[1], sizeof(line2));
	printf("%s: line1=|%s| line2=|%s| line3=|%s| line4=|%s| line5=|%s|\n", self, line1, line2, line3, line4, line5);
	
	strncat(line4, argv[1], sizeof(line4));
	printf("%s: line1=|%s| line2=|%s| line3=|%s| line4=|%s| line5=|%s|\n", self, line1, line2, line3, line4, line5);
	
	
	
	printf("\n");
	
	
	
	memset(line1, 0x00, sizeof(line1));
	memset(line2, 0x00, sizeof(line2));
	memset(line3, 0x00, sizeof(line3));
	memset(line4, 0x00, sizeof(line4));
	memset(line5, 0x00, sizeof(line5));
	
	strncat(line3, argv[1], sizeof(line3)-strlen(line3)-1);
	printf("%s: line1=|%s| line2=|%s| line3=|%s| line4=|%s| line5=|%s|\n", self, line1, line2, line3, line4, line5);
	
	strncat(line3, argv[1], sizeof(line3)-strlen(line3)-1);
	printf("%s: line1=|%s| line2=|%s| line3=|%s| line4=|%s| line5=|%s|\n", self, line1, line2, line3, line4, line5);
	
	strncat(line3, argv[1], sizeof(line3)-strlen(line3)-1);
	printf("%s: line1=|%s| line2=|%s| line3=|%s| line4=|%s| line5=|%s|\n", self, line1, line2, line3, line4, line5);
	
	strncat(line4, argv[1], sizeof(line4)-strlen(line4)-1);
	printf("%s: line1=|%s| line2=|%s| line3=|%s| line4=|%s| line5=|%s|\n", self, line1, line2, line3, line4, line5);
	
	strncat(line2, argv[1], sizeof(line2)-strlen(line2)-1);
	printf("%s: line1=|%s| line2=|%s| line3=|%s| line4=|%s| line5=|%s|\n", self, line1, line2, line3, line4, line5);
	
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strncpy

Usage: /home/local/code/ansiccode/strings/strncat <some-text>
Examples:
       /home/local/code/ansiccode/strings/strncat 0123456789

/home/local/code/ansiccode/strings/strncat 0123456789

strncat: line1=|| line2=|| line3=|0123456789| line4=|| line5=||
strncat: line1=|| line2=|6789| line3=|01234567890123456789| line4=|| line5=||
strncat: line1=|| line2=|67890123456789| line3=|012345678901234567890123456789| line4=|| line5=||
strncat: line1=|23456789| line2=|678901234567890123456789| line3=|0123456789012345678901234567890123456789| line4=|| line5=||
strncat: line1=|23456789| line2=|678901234567890123456789| line3=|0123456789012345678901234567890123456789| line4=|0123456789| line5=||

strncat: line1=|| line2=|| line3=|0123456789| line4=|| line5=||
strncat: line1=|| line2=|| line3=|012345678901234| line4=|| line5=||
strncat: line1=|| line2=|| line3=|012345678901234| line4=|| line5=||
strncat: line1=|| line2=|| line3=|012345678901234| line4=|0123456789| line5=||
strncat: line1=|| line2=|0123456789| line3=|012345678901234| line4=|0123456789| line5=||

#top strncmp¶

/* Compare N characters of S1 and S2.  */
extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s text0 text0\n", argv[0]);
		printf("       %s text1 text2\n", argv[0]);
		printf("       %s text2 text1\n", argv[0]);
		printf("       %s text1 text222\n", argv[0]);
		printf("       %s text111 text2\n", argv[0]);
		printf("       %s text222 text1\n", argv[0]);
		printf("       %s text2 text111\n", argv[0]);
		printf("       %s text-v.0.0.1 text-v.0.0.2\n", argv[0]);
		printf("       %s text-v.0.1 text-v.0.0.2\n", argv[0]);
		printf("       %s text-v.1 text-v.0.0.2\n", argv[0]);
		printf("       %s text-v.0.15.1 text-v.0.1.15\n", argv[0]);
		printf("       %s text-v.0.15.1 text-v.0.2.15\n", argv[0]);
		printf("       %s text-v.0.15.1 text-v.0.3.15\n", argv[0]);
		return 0;
	}
	
	printf("%s: result=strncmp(argv[1]=|%s|, argv[2]=|%s|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=%d:strlen(argv[2])=%d):\n", self, argv[1], argv[2], (unsigned int)strlen(argv[1]), (unsigned int)strlen(argv[2]));
	result=strncmp(argv[1], argv[2], strlen(argv[1])<strlen(argv[2])?strlen(argv[1]):strlen(argv[2]));
	printf("%s: result=strncmp(argv[1]=|%s|, argv[2]=|%s|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=%d:strlen(argv[2])=%d): result=%d\n", self, argv[1], argv[2], (unsigned int)strlen(argv[1]), (unsigned int)strlen(argv[2]), result);
	
#if defined(HAVE_STRNCASECMP)
	printf("%s: result=strncasecmp(argv[1]=|%s|, argv[2]=|%s|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=%d:strlen(argv[2])=%d):\n", self, argv[1], argv[2], (unsigned int)strlen(argv[1]), (unsigned int)strlen(argv[2]));
	result=strncasecmp(argv[1], argv[2], strlen(argv[1])<strlen(argv[2])?strlen(argv[1]):strlen(argv[2]));
	printf("%s: result=strncasecmp(argv[1]=|%s|, argv[2]=|%s|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=%d:strlen(argv[2])=%d): result=%d\n", self, argv[1], argv[2], (unsigned int)strlen(argv[1]), (unsigned int)strlen(argv[2]), result);
#else
	/* strncasecmp() is not available on this OS platform !!! */
	printf("%s: strncasecmp() is not available on this OS platform !!!\n", self);
#endif
	
#if defined(HAVE_STRVERSCMP)
	printf("%s: result=strncasecmp(argv[1]=|%s|, argv[2]=|%s|):\n", self, argv[1], argv[2]);
	result=strverscmp(argv[1], argv[2]);
	printf("%s: result=strncasecmp(argv[1]=|%s|, argv[2]=|%s|): result=%d\n", self, argv[1], argv[2], result);
#else
	/* strverscmp() is not available on this OS platform !!! */
	printf("%s: strverscmp() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strncmp

Usage: /home/local/code/ansiccode/strings/strncmp <some-text>
Examples:
       /home/local/code/ansiccode/strings/strncmp text0 text0
       /home/local/code/ansiccode/strings/strncmp text1 text2
       /home/local/code/ansiccode/strings/strncmp text2 text1
       /home/local/code/ansiccode/strings/strncmp text1 text222
       /home/local/code/ansiccode/strings/strncmp text111 text2
       /home/local/code/ansiccode/strings/strncmp text222 text1
       /home/local/code/ansiccode/strings/strncmp text2 text111
       /home/local/code/ansiccode/strings/strncmp text-v.0.0.1 text-v.0.0.2
       /home/local/code/ansiccode/strings/strncmp text-v.0.1 text-v.0.0.2
       /home/local/code/ansiccode/strings/strncmp text-v.1 text-v.0.0.2
       /home/local/code/ansiccode/strings/strncmp text-v.0.15.1 text-v.0.1.15
       /home/local/code/ansiccode/strings/strncmp text-v.0.15.1 text-v.0.2.15
       /home/local/code/ansiccode/strings/strncmp text-v.0.15.1 text-v.0.3.15

/home/local/code/ansiccode/strings/strncmp text0 text0
/home/local/code/ansiccode/strings/strncmp text1 text2
/home/local/code/ansiccode/strings/strncmp text2 text1
/home/local/code/ansiccode/strings/strncmp text1 text222
/home/local/code/ansiccode/strings/strncmp text111 text2
/home/local/code/ansiccode/strings/strncmp text222 text1
/home/local/code/ansiccode/strings/strncmp text2 text111
/home/local/code/ansiccode/strings/strncmp text-v.0.0.1 text-v.0.0.2
/home/local/code/ansiccode/strings/strncmp text-v.0.1 text-v.0.0.2
/home/local/code/ansiccode/strings/strncmp text-v.1 text-v.0.0.2
/home/local/code/ansiccode/strings/strncmp text-v.0.15.1 text-v.0.1.15
/home/local/code/ansiccode/strings/strncmp text-v.0.15.1 text-v.0.2.15
/home/local/code/ansiccode/strings/strncmp text-v.0.15.1 text-v.0.3.15

strncmp: result=strncmp(argv[1]=|text0|, argv[2]=|text0|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5):
strncmp: result=strncmp(argv[1]=|text0|, argv[2]=|text0|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5): result=0
strncmp: result=strncasecmp(argv[1]=|text0|, argv[2]=|text0|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5):
strncmp: result=strncasecmp(argv[1]=|text0|, argv[2]=|text0|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5): result=0
strncmp: result=strncasecmp(argv[1]=|text0|, argv[2]=|text0|):
strncmp: result=strncasecmp(argv[1]=|text0|, argv[2]=|text0|): result=0

strncmp: result=strncmp(argv[1]=|text1|, argv[2]=|text2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5):
strncmp: result=strncmp(argv[1]=|text1|, argv[2]=|text2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5): result=-1
strncmp: result=strncasecmp(argv[1]=|text1|, argv[2]=|text2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5):
strncmp: result=strncasecmp(argv[1]=|text1|, argv[2]=|text2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5): result=-1
strncmp: result=strncasecmp(argv[1]=|text1|, argv[2]=|text2|):
strncmp: result=strncasecmp(argv[1]=|text1|, argv[2]=|text2|): result=-1

strncmp: result=strncmp(argv[1]=|text2|, argv[2]=|text1|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5):
strncmp: result=strncmp(argv[1]=|text2|, argv[2]=|text1|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5): result=1
strncmp: result=strncasecmp(argv[1]=|text2|, argv[2]=|text1|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5):
strncmp: result=strncasecmp(argv[1]=|text2|, argv[2]=|text1|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=5): result=1
strncmp: result=strncasecmp(argv[1]=|text2|, argv[2]=|text1|):
strncmp: result=strncasecmp(argv[1]=|text2|, argv[2]=|text1|): result=1

strncmp: result=strncmp(argv[1]=|text1|, argv[2]=|text222|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=7):
strncmp: result=strncmp(argv[1]=|text1|, argv[2]=|text222|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=7): result=-1
strncmp: result=strncasecmp(argv[1]=|text1|, argv[2]=|text222|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=7):
strncmp: result=strncasecmp(argv[1]=|text1|, argv[2]=|text222|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=7): result=-1
strncmp: result=strncasecmp(argv[1]=|text1|, argv[2]=|text222|):
strncmp: result=strncasecmp(argv[1]=|text1|, argv[2]=|text222|): result=-1

strncmp: result=strncmp(argv[1]=|text111|, argv[2]=|text2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=7:strlen(argv[2])=5):
strncmp: result=strncmp(argv[1]=|text111|, argv[2]=|text2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=7:strlen(argv[2])=5): result=-1
strncmp: result=strncasecmp(argv[1]=|text111|, argv[2]=|text2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=7:strlen(argv[2])=5):
strncmp: result=strncasecmp(argv[1]=|text111|, argv[2]=|text2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=7:strlen(argv[2])=5): result=-1
strncmp: result=strncasecmp(argv[1]=|text111|, argv[2]=|text2|):
strncmp: result=strncasecmp(argv[1]=|text111|, argv[2]=|text2|): result=1

strncmp: result=strncmp(argv[1]=|text222|, argv[2]=|text1|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=7:strlen(argv[2])=5):
strncmp: result=strncmp(argv[1]=|text222|, argv[2]=|text1|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=7:strlen(argv[2])=5): result=1
strncmp: result=strncasecmp(argv[1]=|text222|, argv[2]=|text1|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=7:strlen(argv[2])=5):
strncmp: result=strncasecmp(argv[1]=|text222|, argv[2]=|text1|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=7:strlen(argv[2])=5): result=1
strncmp: result=strncasecmp(argv[1]=|text222|, argv[2]=|text1|):
strncmp: result=strncasecmp(argv[1]=|text222|, argv[2]=|text1|): result=1

strncmp: result=strncmp(argv[1]=|text2|, argv[2]=|text111|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=7):
strncmp: result=strncmp(argv[1]=|text2|, argv[2]=|text111|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=7): result=1
strncmp: result=strncasecmp(argv[1]=|text2|, argv[2]=|text111|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=7):
strncmp: result=strncasecmp(argv[1]=|text2|, argv[2]=|text111|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=5:strlen(argv[2])=7): result=1
strncmp: result=strncasecmp(argv[1]=|text2|, argv[2]=|text111|):
strncmp: result=strncasecmp(argv[1]=|text2|, argv[2]=|text111|): result=-1

strncmp: result=strncmp(argv[1]=|text-v.0.0.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=12:strlen(argv[2])=12):
strncmp: result=strncmp(argv[1]=|text-v.0.0.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=12:strlen(argv[2])=12): result=-1
strncmp: result=strncasecmp(argv[1]=|text-v.0.0.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=12:strlen(argv[2])=12):
strncmp: result=strncasecmp(argv[1]=|text-v.0.0.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=12:strlen(argv[2])=12): result=-1
strncmp: result=strncasecmp(argv[1]=|text-v.0.0.1|, argv[2]=|text-v.0.0.2|):
strncmp: result=strncasecmp(argv[1]=|text-v.0.0.1|, argv[2]=|text-v.0.0.2|): result=-1

strncmp: result=strncmp(argv[1]=|text-v.0.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=10:strlen(argv[2])=12):
strncmp: result=strncmp(argv[1]=|text-v.0.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=10:strlen(argv[2])=12): result=1
strncmp: result=strncasecmp(argv[1]=|text-v.0.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=10:strlen(argv[2])=12):
strncmp: result=strncasecmp(argv[1]=|text-v.0.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=10:strlen(argv[2])=12): result=1
strncmp: result=strncasecmp(argv[1]=|text-v.0.1|, argv[2]=|text-v.0.0.2|):
strncmp: result=strncasecmp(argv[1]=|text-v.0.1|, argv[2]=|text-v.0.0.2|): result=1

strncmp: result=strncmp(argv[1]=|text-v.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=8:strlen(argv[2])=12):
strncmp: result=strncmp(argv[1]=|text-v.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=8:strlen(argv[2])=12): result=1
strncmp: result=strncasecmp(argv[1]=|text-v.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=8:strlen(argv[2])=12):
strncmp: result=strncasecmp(argv[1]=|text-v.1|, argv[2]=|text-v.0.0.2|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=8:strlen(argv[2])=12): result=1
strncmp: result=strncasecmp(argv[1]=|text-v.1|, argv[2]=|text-v.0.0.2|):
strncmp: result=strncasecmp(argv[1]=|text-v.1|, argv[2]=|text-v.0.0.2|): result=1

strncmp: result=strncmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.1.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13):
strncmp: result=strncmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.1.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13): result=7
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.1.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13):
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.1.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13): result=7
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.1.15|):
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.1.15|): result=1

strncmp: result=strncmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.2.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13):
strncmp: result=strncmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.2.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13): result=-1
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.2.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13):
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.2.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13): result=-1
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.2.15|):
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.2.15|): result=1

strncmp: result=strncmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.3.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13):
strncmp: result=strncmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.3.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13): result=-2
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.3.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13):
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.3.15|, strlen(argv[1])>strlen(argv[2])?strlen(argv[1])=13:strlen(argv[2])=13): result=-2
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.3.15|):
strncmp: result=strncasecmp(argv[1]=|text-v.0.15.1|, argv[2]=|text-v.0.3.15|): result=1

#top strncpy¶

/* Copy no more than N characters of SRC to DEST.  */
extern char *strncpy (char *__restrict __dest,
              __const char *__restrict __src, size_t __n)
     __THROW __nonnull ((1, 2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	char buffer[16];
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s sometext\n", argv[0]);
		printf("       %s 012345678901234567890123456789\n", argv[0]);
		return 0;
	}
	
	memset(buffer, 0x00, sizeof(buffer));
	
	strncpy(buffer, argv[1], sizeof(buffer));
	printf("%s: strlen(buffer)=%02u sizeof(buffer)=%lu buffer=|%s|\n", self, (unsigned int)strlen(buffer), (unsigned long int)sizeof(buffer), buffer);
	
	
	
	memset(buffer, 0x00, sizeof(buffer));
	
	strncpy(buffer, argv[1], sizeof(buffer)-1);
	printf("%s: strlen(buffer)=%02u sizeof(buffer)=%lu buffer=|%s|\n", self, (unsigned int)strlen(buffer), (unsigned long int)sizeof(buffer), buffer);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strncpy

Usage: /home/local/code/ansiccode/strings/strncpy <some-text>
Examples:
       /home/local/code/ansiccode/strings/strncpy sometext
       /home/local/code/ansiccode/strings/strncpy 012345678901234567890123456789

/home/local/code/ansiccode/strings/strncpy sometext
/home/local/code/ansiccode/strings/strncpy 012345678901234567890123456789

strncpy: strlen(buffer)=08 sizeof(buffer)=16 buffer=|sometext|
strncpy: strlen(buffer)=08 sizeof(buffer)=16 buffer=|sometext|

strncpy: strlen(buffer)=24 sizeof(buffer)=16 buffer=|0123456789012345PHǿ�:ǿ|
strncpy: strlen(buffer)=15 sizeof(buffer)=16 buffer=|012345678901234|

#top strndup¶

/* Return a malloc'd copy of at most N bytes of STRING.  The
   resultant string is terminated even if no null terminator
   appears before STRING[N].  */
#if defined __USE_GNU
extern char *strndup (__const char *__string, size_t __n)
     __THROW __attribute_malloc__ __nonnull ((1));
#endif

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkstemp(), mkdtemp(), system(), realpath(), abs(), labs(), llabs(), getloadavg(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_STRNDUP)
	char *strptr;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s text\n", argv[0]);
		printf("       %s 1234567890012345678901234567890123456789\n", argv[0]);
		return 0;
	}
	
	
#if defined(HAVE_STRNDUP)
	printf("%s: strptr=strndup(argv[1]=|%s|, 32):\n", self, argv[1]);
	strptr=strndup(argv[1], 32);
	printf("%s: strptr=strndup(argv[1]=|%s|, 32): strptr=|%s|\n", self, argv[1], strptr);
	free(strptr);
#else
	/* strndup() is not available on this OS platform !!! */
	printf("%s: strndup() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strncpy

Usage: /home/local/code/ansiccode/strings/strncpy <some-text>
Examples:
       /home/local/code/ansiccode/strings/strncpy text
       /home/local/code/ansiccode/strings/strncpy chunk

/home/local/code/ansiccode/strings/strncpy text
/home/local/code/ansiccode/strings/strncpy chunk

strncpy: strlen(buffer)=04 sizeof(buffer)=32 buffer=|text|
strncpy: strlen(buffer)=08 sizeof(buffer)=32 buffer=|texttext|
strncpy: strlen(buffer)=12 sizeof(buffer)=32 buffer=|texttexttext|
strncpy: strlen(buffer)=16 sizeof(buffer)=32 buffer=|texttexttexttext|
strncpy: strlen(buffer)=20 sizeof(buffer)=32 buffer=|texttexttexttexttext|
strncpy: strlen(buffer)=24 sizeof(buffer)=32 buffer=|texttexttexttexttexttext|
strncpy: strlen(buffer)=28 sizeof(buffer)=32 buffer=|texttexttexttexttexttexttext|
strncpy: strlen(buffer)=31 sizeof(buffer)=32 buffer=|texttexttexttexttexttexttexttex|
strncpy: strlen(buffer)=31 sizeof(buffer)=32 buffer=|texttexttexttexttexttexttexttex|

strncpy: strlen(buffer)=05 sizeof(buffer)=32 buffer=|chunk|
strncpy: strlen(buffer)=10 sizeof(buffer)=32 buffer=|chunkchunk|
strncpy: strlen(buffer)=15 sizeof(buffer)=32 buffer=|chunkchunkchunk|
strncpy: strlen(buffer)=20 sizeof(buffer)=32 buffer=|chunkchunkchunkchunk|
strncpy: strlen(buffer)=25 sizeof(buffer)=32 buffer=|chunkchunkchunkchunkchunk|
strncpy: strlen(buffer)=30 sizeof(buffer)=32 buffer=|chunkchunkchunkchunkchunkchunk|
strncpy: strlen(buffer)=31 sizeof(buffer)=32 buffer=|chunkchunkchunkchunkchunkchunkc|
strncpy: strlen(buffer)=31 sizeof(buffer)=32 buffer=|chunkchunkchunkchunkchunkchunkc|
strncpy: strlen(buffer)=31 sizeof(buffer)=32 buffer=|chunkchunkchunkchunkchunkchunkc|

#top strnlen¶

/* Find the length of STRING, but scan at most MAXLEN characters.
   If no '\0' terminator is found in that many characters, return MAXLEN.  */
extern size_t strnlen (__const char *__string, size_t __maxlen)
     __THROW __attribute_pure__ __nonnull ((1));

size_t strnlen(const char *__string, const size_t __maxlen) {
	char *__strptr = memchr(__string, 0x00, __maxlen);
	if (__strptr!=NULL) return __strptr - __string;
	else return __maxlen;
}

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_STRNLEN)
	int result;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s text\n", argv[0]);
		printf("       %s 1234567890012345678901234567890123456789\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_STRNLEN)
	printf("%s: result=strnlen(argv[1]=|%s|, 32):\n", self, argv[1]);
	result=strnlen(argv[1], 32);
	printf("%s: result=strnlen(argv[1]=|%s|, 32): result=%d\n", self, argv[1], result);
#else
	/* strnlen() is not available on this OS platform !!! */
	printf("%s: strnlen() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strnlen

Usage: /home/local/code/ansiccode/strings/strnlen <some-text>
Examples:
       /home/local/code/ansiccode/strings/strnlen text
       /home/local/code/ansiccode/strings/strnlen 1234567890012345678901234567890123456789

/home/local/code/ansiccode/strings/strnlen text
/home/local/code/ansiccode/strings/strnlen 1234567890012345678901234567890123456789

strnlen: result=strnlen(argv[1]=|text|, 32):
strnlen: result=strnlen(argv[1]=|text|, 32): result=4

strnlen: result=strnlen(argv[1]=|1234567890012345678901234567890123456789|, 32):
strnlen: result=strnlen(argv[1]=|1234567890012345678901234567890123456789|, 32): result=32

#top strpbrk¶

/* Find the first occurrence in S of any character in ACCEPT.  */
extern char *strpbrk (__const char *__s, __const char *__accept)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	char *strtext;
	char *keytext;
	char *chrptr;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s \"This is a sample string\" aeiouy\n", argv[0]);
		printf("       %s \"scheme://user:pass@host:port/path?query#anchor\" \"@#$%%^&*-_=+;:,./?\"\n", argv[0]);
		return 0;
	}
	
	strtext=argv[1];
	keytext=argv[2];
	
	printf("%s: Letters in strtext=|%s| are |", self, strtext);
	chrptr=strpbrk (strtext, keytext);
	while (chrptr!=NULL) {
		printf("%c ", *chrptr);
		chrptr=strpbrk(chrptr+1, keytext);
	}
	printf("|\n");
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strpbrk	

Usage: /home/local/code/ansiccode/strings/strpbrk <some-text>
Examples:
       /home/local/code/ansiccode/strings/strpbrk "This is a sample string" aeiouy
       /home/local/code/ansiccode/strings/strpbrk "scheme://user:pass@host:port/path?query#anchor" "@#$%^&*-_=+;:,./?"

/home/local/code/ansiccode/strings/strpbrk "This is a sample string" aeiouy
/home/local/code/ansiccode/strings/strpbrk "scheme://user:pass@host:port/path?query#anchor" "@#$%^&*-_=+;:,./?"

strpbrk: Letters in strtext=|This is a sample string| are |i i a a e i |

strpbrk: Letters in strtext=|scheme://user:pass@host:port/path?query#anchor| are |: / / : @ : / ? # |

#top strrchr¶

/* Find the last occurrence of C in S.  */
extern char *strrchr (__const char *__s, int __c)
     __THROW __attribute_pure__ __nonnull ((1));

#top strsep¶

/* Return the next DELIM-delimited token from *STRINGP,
   terminating it with a '\0', and update *STRINGP to point past it.  */
extern char *strsep (char **__restrict __stringp,
             __const char *__restrict __delim)
     __THROW __nonnull ((1, 2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_STRSEP)
	char **srcs;
	char *strptr;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s \"some text for test strsep() function working on string\" \" \"\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_STRSEP)
	srcs=&argv[1];
	do {
		printf("%s: strptr=strsep(srcs=|%s|, argv[2]=|%s|):\n", self, *srcs, argv[2]);
		strptr=strsep(srcs, argv[2]);
		printf("%s: strptr=strsep(srcs=|%s|, argv[2]=|%s|): strptr=|%s|\n", self, *srcs, argv[2], strptr);
	} while (strptr!=NULL);
#else
	/* strsep() is not available on this OS platform !!! */
	printf("%s: strsep() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strsep

Usage: /home/local/code/ansiccode/strings/strsep <some-text>
Examples:
       /home/local/code/ansiccode/strings/strsep "some text for test strsep() function working on string" " "

/home/local/code/ansiccode/strings/strsep "some text for test strsep() function working on string" " "

strsep: strptr=strsep(srcs=|some text for test strsep() function working on string|, argv[2]=| |):
strsep: strptr=strsep(srcs=|text for test strsep() function working on string|, argv[2]=| |): strptr=|some|
strsep: strptr=strsep(srcs=|text for test strsep() function working on string|, argv[2]=| |):
strsep: strptr=strsep(srcs=|for test strsep() function working on string|, argv[2]=| |): strptr=|text|
strsep: strptr=strsep(srcs=|for test strsep() function working on string|, argv[2]=| |):
strsep: strptr=strsep(srcs=|test strsep() function working on string|, argv[2]=| |): strptr=|for|
strsep: strptr=strsep(srcs=|test strsep() function working on string|, argv[2]=| |):
strsep: strptr=strsep(srcs=|strsep() function working on string|, argv[2]=| |): strptr=|test|
strsep: strptr=strsep(srcs=|strsep() function working on string|, argv[2]=| |):
strsep: strptr=strsep(srcs=|function working on string|, argv[2]=| |): strptr=|strsep()|
strsep: strptr=strsep(srcs=|function working on string|, argv[2]=| |):
strsep: strptr=strsep(srcs=|working on string|, argv[2]=| |): strptr=|function|
strsep: strptr=strsep(srcs=|working on string|, argv[2]=| |):
strsep: strptr=strsep(srcs=|on string|, argv[2]=| |): strptr=|working|
strsep: strptr=strsep(srcs=|on string|, argv[2]=| |):
strsep: strptr=strsep(srcs=|string|, argv[2]=| |): strptr=|on|
strsep: strptr=strsep(srcs=|string|, argv[2]=| |):
strsep: strptr=strsep(srcs=|(null)|, argv[2]=| |): strptr=|string|
strsep: strptr=strsep(srcs=|(null)|, argv[2]=| |):
strsep: strptr=strsep(srcs=|(null)|, argv[2]=| |): strptr=|(null)|

#top strsignal¶

/* Return a string describing the meaning of the signal number in SIG.  */
extern char *strsignal (int __sig) __THROW;

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkstemp(), mkdtemp(), system(), realpath(), abs(), labs(), llabs(), getloadavg(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_STRSIGNAL)
	int  isign;
	char *ssign;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s\n", argv[0]);
		printf("Examples:\n");
		printf("       %s 0\n", argv[0]);
		printf("       %s 1\n", argv[0]);
		printf("       %s 2\n", argv[0]);
		printf("       %s 3\n", argv[0]);
		printf("       %s 5\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_STRSIGNAL)
	isign=atoi(argv[1]);
	ssign=strsignal(isign);
	printf("strsing=strsignal(%d): received signal: isign:ssign=%d:%s\n", isign, isign, ssign);
#endif
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strsignal

Usage: /home/local/code/ansiccode/strings/strsignal
Examples:
       /home/local/code/ansiccode/strings/strsignal 0
       /home/local/code/ansiccode/strings/strsignal 1
       /home/local/code/ansiccode/strings/strsignal 2
       /home/local/code/ansiccode/strings/strsignal 3
       /home/local/code/ansiccode/strings/strsignal 5

/home/local/code/ansiccode/strings/strsignal 0
/home/local/code/ansiccode/strings/strsignal 1
/home/local/code/ansiccode/strings/strsignal 2
/home/local/code/ansiccode/strings/strsignal 3
/home/local/code/ansiccode/strings/strsignal 5

strsing=strsignal(0): received signal: isign:ssign=0:Unknown signal 0

strsing=strsignal(1): received signal: isign:ssign=1:Hangup

strsing=strsignal(2): received signal: isign:ssign=2:Interrupt

strsing=strsignal(3): received signal: isign:ssign=3:Quit

strsing=strsignal(5): received signal: isign:ssign=5:Trace/breakpoint trap

#top strspn¶

/* Return the length of the initial segment of S which
   consists entirely of characters in ACCEPT.  */
extern size_t strspn (__const char *__s, __const char *__accept)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	char *strtext;
	char *accept;
	char *reject;
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s 129th 1234567890 abcdefghijklmnopqrstuvxyz\n", argv[0]);
		printf("       %s some4text4for3test4working7function8strspn abcdefghijklmnopqrstuvxyz 1234567890\n", argv[0]);
		return 0;
	}
	
	strtext=argv[1];
	accept=argv[2];
	reject=argv[3];
	
	result=strspn(strtext, accept);
	printf("%s: The strtext=|%s| contains accept=|%s| initial number has %d chars.\n", self, strtext, accept, result);
	
	result=strcspn(strtext, reject);
	printf("%s: The strtext=|%s| contains first reject=|%s| chars at position %d.\n", self, strtext, reject, result+1);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strspn

Usage: /home/local/code/ansiccode/strings/strspn <some-text>
Examples:
       /home/local/code/ansiccode/strings/strspn 129th 1234567890 abcdefghijklmnopqrstuvxyz
       /home/local/code/ansiccode/strings/strspn some4text4for3test4working7function8strspn abcdefghijklmnopqrstuvxyz 1234567890

/home/local/code/ansiccode/strings/strspn 129th 1234567890 abcdefghijklmnopqrstuvxyz
/home/local/code/ansiccode/strings/strspn some4text4for3test4working7function8strspn abcdefghijklmnopqrstuvxyz 1234567890

strspn: The strtext=|129th| contains accept=|1234567890| initial number has 3 chars.
strspn: The strtext=|129th| contains first reject=|abcdefghijklmnopqrstuvxyz| chars at position 4.

strspn: The strtext=|some4text4for3test4working7function8strspn| contains accept=|abcdefghijklmnopqrstuvxyz| initial number has 4 chars.
strspn: The strtext=|some4text4for3test4working7function8strspn| contains first reject=|1234567890| chars at position 5.

#top strstr¶

/* Find the first occurrence of NEEDLE in HAYSTACK.  */
extern char *strstr (__const char *__haystack, __const char *__needle)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	char *strptr;
	char chfirst;
	char chlast;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<4) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s \"some text for test strstr() FUNCTION working on STRING\" te \" \" \" \"\n", argv[0]);
		printf("       %s \"some text for test strstr() FUNCTION working on STRING\" on \" \" \" \"\n", argv[0]);
		printf("       %s \"some text for test strstr() FUNCTION working on STRING\" some t t\n", argv[0]);
		printf("       %s \"some text for test strstr() FUNCTION working on STRING\" string x x\n", argv[0]);
		return 0;
	}
	
	printf("%s: strptr=strsep(argv[1]=|%s|, argv[2]=|%s|):\n", self, argv[1], argv[2]);
	strptr=strstr(argv[1], argv[2]);
	printf("%s: strptr=strsep(argv[1]=|%s|, argv[2]=|%s|): strptr=|%s|\n", self, argv[1], argv[2], strptr);
	
#if defined(HAVE_STRCASESTR)
	printf("%s: strptr=strcasestr(argv[1]=|%s|, argv[2]=|%s|):\n", self, argv[1], argv[2]);
	strptr=strcasestr(argv[1], argv[2]);
	printf("%s: strptr=strcasestr(argv[1]=|%s|, argv[2]=|%s|): strptr=|%s|\n", self, argv[1], argv[2], strptr);
#else
	/* strcasestr() is not available on this OS platform !!! */
	printf("%s: strcasestr() is not available on this OS platform !!!\n", self);
#endif
	
	chfirst=argv[3][0];
	printf("%s: strptr=strchr(argv[1]=|%s|, chfirst=|%c|):\n", self, argv[1], chfirst);
	strptr=strchr(argv[1], chfirst);
	printf("%s: strptr=strchr(argv[1]=|%s|, chfirst=|%c|): strptr=|%s|\n", self, argv[1], chfirst, strptr);
	
	chlast=argv[4][0];
	printf("%s: strptr=strrchr(argv[1]=|%s|, chlast=|%c|):\n", self, argv[1], chlast);
	strptr=strrchr(argv[1], chlast);
	printf("%s: strptr=strrchr(argv[1]=|%s|, chlast=|%c|): strptr=|%s|\n", self, argv[1], chlast, strptr);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strstr

Usage: /home/local/code/ansiccode/strings/strstr <some-text>
Examples:
       /home/local/code/ansiccode/strings/strstr "some text for test strstr() FUNCTION working on STRING" te " " " "
       /home/local/code/ansiccode/strings/strstr "some text for test strstr() FUNCTION working on STRING" on " " " "
       /home/local/code/ansiccode/strings/strstr "some text for test strstr() FUNCTION working on STRING" some t t
       /home/local/code/ansiccode/strings/strstr "some text for test strstr() FUNCTION working on STRING" string x x

/home/local/code/ansiccode/strings/strstr "some text for test strstr() FUNCTION working on STRING" te " " " "
/home/local/code/ansiccode/strings/strstr "some text for test strstr() FUNCTION working on STRING" on " " " "
/home/local/code/ansiccode/strings/strstr "some text for test strstr() FUNCTION working on STRING" some t t
/home/local/code/ansiccode/strings/strstr "some text for test strstr() FUNCTION working on STRING" string x x

strstr: strptr=strsep(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|te|):
strstr: strptr=strsep(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|te|): strptr=|text for test strstr() FUNCTION working on STRING|
strstr: strptr=strcasestr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|te|):
strstr: strptr=strcasestr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|te|): strptr=|text for test strstr() FUNCTION working on STRING|
strstr: strptr=strchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chfirst=| |):
strstr: strptr=strchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chfirst=| |): strptr=| text for test strstr() FUNCTION working on STRING|
strstr: strptr=strrchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chlast=| |):
strstr: strptr=strrchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chlast=| |): strptr=| STRING|

strstr: strptr=strsep(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|on|):
strstr: strptr=strsep(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|on|): strptr=|on STRING|
strstr: strptr=strcasestr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|on|):
strstr: strptr=strcasestr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|on|): strptr=|ON working on STRING|
strstr: strptr=strchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chfirst=| |):
strstr: strptr=strchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chfirst=| |): strptr=| text for test strstr() FUNCTION working on STRING|
strstr: strptr=strrchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chlast=| |):
strstr: strptr=strrchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chlast=| |): strptr=| STRING|

strstr: strptr=strsep(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|some|):
strstr: strptr=strsep(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|some|): strptr=|some text for test strstr() FUNCTION working on STRING|
strstr: strptr=strcasestr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|some|):
strstr: strptr=strcasestr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|some|): strptr=|some text for test strstr() FUNCTION working on STRING|
strstr: strptr=strchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chfirst=|t|):
strstr: strptr=strchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chfirst=|t|): strptr=|text for test strstr() FUNCTION working on STRING|
strstr: strptr=strrchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chlast=|t|):
strstr: strptr=strrchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chlast=|t|): strptr=|tr() FUNCTION working on STRING|

strstr: strptr=strsep(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|string|):
strstr: strptr=strsep(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|string|): strptr=|(null)|
strstr: strptr=strcasestr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|string|):
strstr: strptr=strcasestr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, argv[2]=|string|): strptr=|STRING|
strstr: strptr=strchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chfirst=|x|):
strstr: strptr=strchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chfirst=|x|): strptr=|xt for test strstr() FUNCTION working on STRING|
strstr: strptr=strrchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chlast=|x|):
strstr: strptr=strrchr(argv[1]=|some text for test strstr() FUNCTION working on STRING|, chlast=|x|): strptr=|xt for test strstr() FUNCTION working on STRING|

#top strtok¶

/* Divide S into tokens separated by characters in DELIM.  */
extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
     __THROW __nonnull ((2));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
	char *srcs;
	char *strptr;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <some-text>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s \"some text for test strtok() function working on string\" \" \"\n", argv[0]);
		return 0;
	}
	
	srcs=argv[1];
	strptr=strtok(srcs, argv[2]);
	printf("%s: strptr=strtok(srcs=|%s|, argv[2]=|%s|): strptr=|%s|\n", self, srcs, argv[2], strptr);
	while (strptr!=NULL) {
		strptr=strtok(NULL, argv[2]);
		printf("%s: strptr=strtok(srcs=|%s|, argv[2]=|%s|): strptr=|%s|\n", self, "NULL", argv[2], strptr);
	}
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/strtok

Usage: /home/local/code/ansiccode/strings/strtok <some-text>
Examples:
       /home/local/code/ansiccode/strings/strtok "some text for test strtok() function working on string" " "

/home/local/code/ansiccode/strings/strtok "some text for test strtok() function working on string" " "

strtok: strptr=strtok(srcs=|some|, argv[2]=| |): strptr=|some|
strtok: strptr=strtok(srcs=|NULL|, argv[2]=| |): strptr=|text|
strtok: strptr=strtok(srcs=|NULL|, argv[2]=| |): strptr=|for|
strtok: strptr=strtok(srcs=|NULL|, argv[2]=| |): strptr=|test|
strtok: strptr=strtok(srcs=|NULL|, argv[2]=| |): strptr=|strtok()|
strtok: strptr=strtok(srcs=|NULL|, argv[2]=| |): strptr=|function|
strtok: strptr=strtok(srcs=|NULL|, argv[2]=| |): strptr=|working|
strtok: strptr=strtok(srcs=|NULL|, argv[2]=| |): strptr=|on|
strtok: strptr=strtok(srcs=|NULL|, argv[2]=| |): strptr=|string|
strtok: strptr=strtok(srcs=|NULL|, argv[2]=| |): strptr=|(null)|

#top strverscmp¶

/* Compare S1 and S2 as strings holding name & indices/version numbers.  */
extern int strverscmp (__const char *__s1, __const char *__s2)
     __THROW __attribute_pure__ __nonnull ((1, 2));

#top strxfrm¶

/* Put a transformation of SRC into no more than N bytes of DEST.  */
extern size_t strxfrm (char *__restrict __dest,
               __const char *__restrict __src, size_t __n)
     __THROW __nonnull ((2));

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

#top tolower¶

/* Return the lowercase version of C.  */
extern int tolower (int __c) __THROW;

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

#top toupper¶

/* Return the uppercase version of C.  */
extern int toupper (int __c) __THROW;

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

#top vprintf¶

/* Write formatted output to stdout from argument list ARG.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern int vprintf (__const char *__restrict __format, _G_va_list __arg);

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */

#include <stdarg.h>        /* for va_list, va_start(), va_end(), */



void vprintf_formatted(const char *format, ...) {
	va_list args;
	
	va_start(args, format);
	vprintf(format, args);
	va_end(args);
}



int main(int argc, char **argv) {
	char *self;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
	vprintf_formatted("%s: printf formatted string into stdout, main(int argc, char **argv): argc=%d argv[0]=%s)\n", self, argc, argv[0]);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/vprintf

vprintf: printf formatted string into stdout, main(int argc, char **argv): argc=1 argv[0]=/home/local/code/ansiccode/strings/vprintf)

#top vscanf¶

/* Read formatted input from stdin into argument list ARG.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern int vscanf (__const char *__restrict __format, _G_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 1, 0))) __wur;

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

#top vsnprintf¶

/* Maximum chars of output to write in MAXLEN.  */
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
              __const char *__restrict __format, _G_va_list __arg)
     __THROW __attribute__ ((__format__ (__printf__, 3, 0)));

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */

#include <stdarg.h>        /* for va_list, va_start(), va_end(), */



void vsnprintf_formatted(const char *format, ...) {
	char buffdata[1024];
	va_list args;
	
	memset(buffdata, 0x00, sizeof(buffdata));
	va_start(args, format);
	vsnprintf(buffdata, sizeof(buffdata), format, args);
	va_end(args);
	printf("vsprintf_formatted(const char *format, ...): buffdata=|%s|\n", buffdata);
}



int main(int argc, char **argv) {
	char *self;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
	vsnprintf_formatted("%s: printf formatted string into buffer, main(int argc, char **argv): argc=%d self=%s)\n", self, argc, argv[0]);
	
	return 0;
}

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

/home/local/code/ansiccode/strings/vsnprintf

vsprintf_formatted(const char *format, ...): buffdata=|vsnprintf: printf formatted string into buffer, main(int argc, char **argv): argc=1 self=/home/local/code/ansiccode/strings/vsnprintf)
|

#top vsprintf¶

/* Write formatted output to S from argument list ARG.  */
extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
             _G_va_list __arg) __THROW;

#top vsscanf¶

/* Read formatted input from S into argument list ARG.  */
extern int vsscanf (__const char *__restrict __s,
		    __const char *__restrict __format, _G_va_list __arg)
     __THROW __attribute__ ((__format__ (__scanf__, 2, 0)));

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows