cechew@bruce.OZ (Earl Chew) (09/29/89)
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 1 (of 6)."
# Contents: 0_bugs.txt MANIFEST _fakfls.c _ioread.c _misc.c _os.c
# _vscanf.c clearerr.c ctermid.c cuserid.c feof.c ferror.c fflush.c
# fgetc.c fileno.c fputc.c getc.c getchar.c getw.c printf.c putc.c
# putchar.c putw.c remove.c rewind.c scanf.c turboc.cfg vprintf.c
# xexit.c xfputs.c xfwrite.c xprintf.c xputc.c xputs.c xsprintf.c
# ybcopy.c ylen.c ylimits.c ylimits.h ylower.c ymemlen.c ymemory.c
# ynull.c yopen.c yrename.c ystdarg.c ystdc.c ystring.c ystrings.c
# ystrlen.c ytime.c ytypes.c yuchar.c yumask.c yvarargs.c
# Wrapped by cechew@bruce on Fri Sep 29 16:23:36 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f '0_bugs.txt' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'0_bugs.txt'\"
else
echo shar: Extracting \"'0_bugs.txt'\" \(232 characters\)
sed "s/^X//" >'0_bugs.txt' <<'END_OF_FILE'
Xo vfprintf.c and _vfscanf.c needs some work to complete the ANSIfication.
Xo _rename.c needs work.
Xo a+ with three argument open emulation may not function properly
X when several processes attempt to write to a file simultaneously.
END_OF_FILE
if test 232 -ne `wc -c <'0_bugs.txt'`; then
echo shar: \"'0_bugs.txt'\" unpacked with wrong size!
fi
# end of '0_bugs.txt'
fi
if test -f 'MANIFEST' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'MANIFEST'\"
else
echo shar: Extracting \"'MANIFEST'\" \(4887 characters\)
sed "s/^X//" >'MANIFEST' <<'END_OF_FILE'
X File Name Archive # Description
X-----------------------------------------------------------
X 0_bugs.txt 1 Documentation
X 0_minix.txt 2 Documentation
X 0_notes.txt 4 Documentation
X MANIFEST 1 This shipping list
X _allocbu.c 2 Stdio source code
X _fakfls.c 1 Stdio source code
X _file.c 3 Stdio source code
X _fopen.c 3 Stdio source code
X _ioread.c 1 Stdio source code
X _iowrite.c 2 Stdio source code
X _misc.c 1 Stdio source code
X _open3.c 3 Stdio source code
X _os.c 1 Stdio source code
X _rename.c 2 Stdio source code
X _stdio.c 4 Stdio source code
X _update.c 3 Stdio source code
X _vfscanf.c 4 Stdio source code
X _vscanf.c 1 Stdio source code
X _vsscanf.c 2 Stdio source code
X atexit.c 2 Stdio source code
X bitset.h 3 Header file
X clearerr.c 1 Stdio source code
X config.h 5 Header file
X ctermid.c 1 Stdio source code
X cuserid.c 1 Stdio source code
X exit.c 2 Stdio source code
X fclose.c 2 Stdio source code
X fdopen.c 2 Stdio source code
X feof.c 1 Stdio source code
X ferror.c 1 Stdio source code
X fflush.c 1 Stdio source code
X fgetc.c 1 Stdio source code
X fgets.c 3 Stdio source code
X fileno.c 1 Stdio source code
X fopen.c 2 Stdio source code
X fprintf.c 2 Stdio source code
X fputc.c 1 Stdio source code
X fputs.c 2 Stdio source code
X fread.c 3 Stdio source code
X freopen.c 2 Stdio source code
X fscanf.c 2 Stdio source code
X fseek.c 2 Stdio source code
X ftell.c 2 Stdio source code
X fwrite.c 3 Stdio source code
X getc.c 1 Stdio source code
X getchar.c 1 Stdio source code
X gets.c 3 Stdio source code
X getw.c 1 Stdio source code
X makefile.dos 3 Makefile
X makefile.unx 3 Makefile
X perror.c 2 Stdio source code
X printf.c 1 Stdio source code
X putc.c 1 Stdio source code
X putchar.c 1 Stdio source code
X puts.c 2 Stdio source code
X putw.c 1 Stdio source code
X remove.c 1 Stdio source code
X rewind.c 1 Stdio source code
X scanf.c 1 Stdio source code
X setbuf.c 2 Stdio source code
X setvbuf.c 3 Stdio source code
X sprintf.c 2 Stdio source code
X sscanf.c 2 Stdio source code
X stdarg.h 2 Header file
X stdio.g 4 Header file source
X stdiolib.h 5 Header file
X tmpfile.c 2 Stdio source code
X tmpnam.c 3 Stdio source code
X turboc.cfg 1
X ungetc.c 2 Stdio source code
X vfprintf.c 5 Stdio source code
X vprintf.c 1 Stdio source code
X vsprintf.c 2 Stdio source code
X xercise.c 6 Exercise file
X xexit.c 1 Exercise file
X xfputs.c 1 Exercise file
X xfwrite.c 1 Exercise file
X xprintf.c 1 Exercise file
X xputc.c 1 Exercise file
X xputs.c 1 Exercise file
X xsprintf.c 1 Exercise file
X ybcopy.c 1 Installation file
X yinstall.sh 4 Installation script
X ylen.c 1 Installation file
X ylimits.c 1 Installation file
X ylimits.h 1 Header file
X ylower.c 1 Installation file
X ymemlen.c 1 Installation file
X ymemory.c 1 Installation file
X ynull.c 1 Installation file
X yopen.c 1 Installation file
X yrename.c 1 Installation file
X ystdarg.c 1 Installation file
X ystdc.c 1 Installation file
X ystring.c 1 Installation file
X ystrings.c 1 Installation file
X ystrlen.c 1 Installation file
X ytime.c 1 Installation file
X ytypes.c 1 Installation file
X yuchar.c 1 Installation file
X yumask.c 1 Installation file
X yvarargs.c 1 Installation file
END_OF_FILE
if test 4887 -ne `wc -c <'MANIFEST'`; then
echo shar: \"'MANIFEST'\" unpacked with wrong size!
fi
# end of 'MANIFEST'
fi
if test -f '_fakfls.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'_fakfls.c'\"
else
echo shar: Extracting \"'_fakfls.c'\" \(425 characters\)
sed "s/^X//" >'_fakfls.c' <<'END_OF_FILE'
X/* _ f a k f l s
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Fake _ioflush() for exit() so that stdio won't be hauled in
X * for programs that don't need it.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xvoid _ioflush(T(void,))
X
X{
X}
END_OF_FILE
if test 425 -ne `wc -c <'_fakfls.c'`; then
echo shar: \"'_fakfls.c'\" unpacked with wrong size!
fi
# end of '_fakfls.c'
fi
if test -f '_ioread.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'_ioread.c'\"
else
echo shar: Extracting \"'_ioread.c'\" \(611 characters\)
sed "s/^X//" >'_ioread.c' <<'END_OF_FILE'
X/* _ i o r e a d
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Call read(2) repeatedly data read without interrupt.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include <stdiolib.h>
X
X/*LINTLIBRARY*/
X
Xint _ioread(T(int fd, fd), T(char *p, p), T(int n, n))
X
XD(int fd) /* file */
XD(char *p) /* buffer */
XD(int n) /* bytes */
X
X{
X int r; /* bytes read by read call */
X
X do
X r = read(fd, p, n);
X while (r == -1 && errno == EINTR);
X
X return r;
X}
END_OF_FILE
if test 611 -ne `wc -c <'_ioread.c'`; then
echo shar: \"'_ioread.c'\" unpacked with wrong size!
fi
# end of '_ioread.c'
fi
if test -f '_misc.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'_misc.c'\"
else
echo shar: Extracting \"'_misc.c'\" \(405 characters\)
sed "s/^X//" >'_misc.c' <<'END_OF_FILE'
X/* _ m i s c
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Default failure and success.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xint _bfail(T(void,)) { return EOF; }
X
Xint _bsucceed(T(void,)) { return 0; }
END_OF_FILE
if test 405 -ne `wc -c <'_misc.c'`; then
echo shar: \"'_misc.c'\" unpacked with wrong size!
fi
# end of '_misc.c'
fi
if test -f '_os.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'_os.c'\"
else
echo shar: Extracting \"'_os.c'\" \(450 characters\)
sed "s/^X//" >'_os.c' <<'END_OF_FILE'
X/* _ o s
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Miscellaneous support code. This depends on the configuration
X * file.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
X/* Miscellaneous operating system support code */
X
X#define SOURCE
X#include "config.h"
END_OF_FILE
if test 450 -ne `wc -c <'_os.c'`; then
echo shar: \"'_os.c'\" unpacked with wrong size!
fi
# end of '_os.c'
fi
if test -f '_vscanf.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'_vscanf.c'\"
else
echo shar: Extracting \"'_vscanf.c'\" \(559 characters\)
sed "s/^X//" >'_vscanf.c' <<'END_OF_FILE'
X/* v s c a n f
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This function provides the same functionality as scanf except
X * that it uses varargs.h.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xint _vscanf(T(const char *fmt, fmt), T(VA_LIST args, args))
X
XD(char *fmt) /* format */
XD(VA_LIST args) /* argument list */
X
X{
X return _vfscanf(stdin, fmt, args);
X}
END_OF_FILE
if test 559 -ne `wc -c <'_vscanf.c'`; then
echo shar: \"'_vscanf.c'\" unpacked with wrong size!
fi
# end of '_vscanf.c'
fi
if test -f 'clearerr.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'clearerr.c'\"
else
echo shar: Extracting \"'clearerr.c'\" \(467 characters\)
sed "s/^X//" >'clearerr.c' <<'END_OF_FILE'
X/* c l e a r e r r
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This is clearerr() wrapped inside a function.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X#undef clearerr
X
X/*LINTLIBRARY*/
X
Xvoid clearerr(T(FILE *fp, fp))
X
XD(FILE *fp) /* stream */
X
X{
X CLEARFLAG(fp, (_IOEOF | _IOERR));
X}
END_OF_FILE
if test 467 -ne `wc -c <'clearerr.c'`; then
echo shar: \"'clearerr.c'\" unpacked with wrong size!
fi
# end of 'clearerr.c'
fi
if test -f 'ctermid.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ctermid.c'\"
else
echo shar: Extracting \"'ctermid.c'\" \(538 characters\)
sed "s/^X//" >'ctermid.c' <<'END_OF_FILE'
X/* c t e r m i d
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Return a name that could be used to access the controlling
X * terminal.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xchar *ctermid(T(char *s, s))
X
XD(char *s) /* name buffer */
X
X{
X static char ttyname[L_ctermid] = "/dev/tty";
X
X return s != NULL ? strcpy(s, ttyname) : ttyname;
X}
END_OF_FILE
if test 538 -ne `wc -c <'ctermid.c'`; then
echo shar: \"'ctermid.c'\" unpacked with wrong size!
fi
# end of 'ctermid.c'
fi
if test -f 'cuserid.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'cuserid.c'\"
else
echo shar: Extracting \"'cuserid.c'\" \(654 characters\)
sed "s/^X//" >'cuserid.c' <<'END_OF_FILE'
X/* c u s e r i d
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Return the login name of the owner of the process.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xchar *cuserid(T(char *s, s))
X
XD(char *s) /* name buffer */
X
X{
X static char name[L_cuserid]; /* name buffer */
X struct passwd *pp; /* point at password */
X
X if (s == NULL)
X s = name;
X return (pp = getpwuid(geteuid())) != NULL
X ? strncpy(s, pp->pw_name, L_cuserid)
X : (*s = 0, s);
X}
END_OF_FILE
if test 654 -ne `wc -c <'cuserid.c'`; then
echo shar: \"'cuserid.c'\" unpacked with wrong size!
fi
# end of 'cuserid.c'
fi
if test -f 'feof.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'feof.c'\"
else
echo shar: Extracting \"'feof.c'\" \(441 characters\)
sed "s/^X//" >'feof.c' <<'END_OF_FILE'
X/* f e o f
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This is feof() wrapped inside a function.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X#undef feof
X
X/*LINTLIBRARY*/
X
Xint feof(T(FILE *fp, fp))
X
XD(FILE *fp) /* stream */
X
X{
X return TESTFLAG(fp, _IOEOF);
X}
END_OF_FILE
if test 441 -ne `wc -c <'feof.c'`; then
echo shar: \"'feof.c'\" unpacked with wrong size!
fi
# end of 'feof.c'
fi
if test -f 'ferror.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ferror.c'\"
else
echo shar: Extracting \"'ferror.c'\" \(451 characters\)
sed "s/^X//" >'ferror.c' <<'END_OF_FILE'
X/* f e r r o r
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This is ferror() wrapped inside a function.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X#undef ferror
X
X/*LINTLIBRARY*/
X
Xint ferror(T(FILE *fp, fp))
X
XD(FILE *fp) /* stream */
X
X{
X return TESTFLAG(fp, _IOERR);
X}
END_OF_FILE
if test 451 -ne `wc -c <'ferror.c'`; then
echo shar: \"'ferror.c'\" unpacked with wrong size!
fi
# end of 'ferror.c'
fi
if test -f 'fflush.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'fflush.c'\"
else
echo shar: Extracting \"'fflush.c'\" \(615 characters\)
sed "s/^X//" >'fflush.c' <<'END_OF_FILE'
X/* f f l u s h
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Flush a stream. The contents of the buffer are written to the
X * file if the stream was opened for writing. The buffer pointers
X * are reset to indicate an empty buffer.
X *
X * The function returns zero on success and EOF on failure.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xint fflush(T(FILE *fp, fp))
X
XD(FILE *fp) /* stream */
X
X{
X return FFLUSH(fp);
X}
END_OF_FILE
if test 615 -ne `wc -c <'fflush.c'`; then
echo shar: \"'fflush.c'\" unpacked with wrong size!
fi
# end of 'fflush.c'
fi
if test -f 'fgetc.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'fgetc.c'\"
else
echo shar: Extracting \"'fgetc.c'\" \(594 characters\)
sed "s/^X//" >'fgetc.c' <<'END_OF_FILE'
X/* f g e t c
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This is the getc() macro wrapped inside a function. This behaves
X * similarly to getc() but runs more slowly. It takes up less
X * space per invocation and its name can be passed as an argument
X * to other functions.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xint fgetc(T(FILE *fp, fp))
X
XD(FILE *fp) /* stream */
X
X{
X return getc(fp);
X}
X
END_OF_FILE
if test 594 -ne `wc -c <'fgetc.c'`; then
echo shar: \"'fgetc.c'\" unpacked with wrong size!
fi
# end of 'fgetc.c'
fi
if test -f 'fileno.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'fileno.c'\"
else
echo shar: Extracting \"'fileno.c'\" \(440 characters\)
sed "s/^X//" >'fileno.c' <<'END_OF_FILE'
X/* f i l e n o
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This is fileno() wrapped inside a function.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X#undef fileno
X
X/*LINTLIBRARY*/
X
Xint fileno(T(FILE *fp, fp))
X
XD(FILE *fp) /* stream */
X
X{
X return fp->_file;
X}
END_OF_FILE
if test 440 -ne `wc -c <'fileno.c'`; then
echo shar: \"'fileno.c'\" unpacked with wrong size!
fi
# end of 'fileno.c'
fi
if test -f 'fputc.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'fputc.c'\"
else
echo shar: Extracting \"'fputc.c'\" \(690 characters\)
sed "s/^X//" >'fputc.c' <<'END_OF_FILE'
X/* f p u t c
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This is putc wrapped inside a function. This behaves like
X * putc but runs more slowly. It takes less space per invocation
X * and its name can be passed as an argument to a function.
X *
X * The function returns the character output on success and
X * EOF on failure.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xint fputc(T(int ch, ch), T(FILE *fp, fp))
X
XD(int ch) /* character */
XD(FILE *fp) /* stream */
X
X{
X return putc(ch, fp);
X}
X
END_OF_FILE
if test 690 -ne `wc -c <'fputc.c'`; then
echo shar: \"'fputc.c'\" unpacked with wrong size!
fi
# end of 'fputc.c'
fi
if test -f 'getc.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'getc.c'\"
else
echo shar: Extracting \"'getc.c'\" \(570 characters\)
sed "s/^X//" >'getc.c' <<'END_OF_FILE'
X/* g e t c
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This is getc() wrapped inside a function.
X *
X * The function returns the character output on success and
X * EOF on failure.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X#undef getc
X
X/*LINTLIBRARY*/
X
Xint getc(T(FILE *fp, fp))
X
XD(FILE *fp) /* stream */
X
X{
X return fp->_rptr < fp->_rend
X ? UCHAR(*fp->_rptr++)
X : (*fp->_filbuf)(fp);
X}
END_OF_FILE
if test 570 -ne `wc -c <'getc.c'`; then
echo shar: \"'getc.c'\" unpacked with wrong size!
fi
# end of 'getc.c'
fi
if test -f 'getchar.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'getchar.c'\"
else
echo shar: Extracting \"'getchar.c'\" \(412 characters\)
sed "s/^X//" >'getchar.c' <<'END_OF_FILE'
X/* g e t c h a r
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This is getchar() wrapped inside a function.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X#undef getchar
X
X/*LINTLIBRARY*/
X
Xint getchar(T(void,))
X
X{
X return getc(stdin);
X}
X
END_OF_FILE
if test 412 -ne `wc -c <'getchar.c'`; then
echo shar: \"'getchar.c'\" unpacked with wrong size!
fi
# end of 'getchar.c'
fi
if test -f 'getw.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'getw.c'\"
else
echo shar: Extracting \"'getw.c'\" \(604 characters\)
sed "s/^X//" >'getw.c' <<'END_OF_FILE'
X/* g e t w
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Read a word from a stream. The function will return EOF on error.
X * Because EOF is also a valid integer, it is better to check for
X * errors using ferror.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xint getw(T(FILE *fp, fp))
X
XD(FILE *fp) /* stream */
X
X{
X int w; /* word read */
X
X return fread((void *) &w, sizeof(int), 1, fp) == 1 ? w : EOF;
X}
END_OF_FILE
if test 604 -ne `wc -c <'getw.c'`; then
echo shar: \"'getw.c'\" unpacked with wrong size!
fi
# end of 'getw.c'
fi
if test -f 'printf.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'printf.c'\"
else
echo shar: Extracting \"'printf.c'\" \(678 characters\)
sed "s/^X//" >'printf.c' <<'END_OF_FILE'
X/* p r i n t f
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Formatted output to stdout. The function returns the number of bytes
X * output on success and EOF on failure.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X/*VARARGS1*/
X/*ARGSUSED*/
X
Xint printf(T(const char *fmt, fmt), VA_ALIST)
X
XD(char *fmt) /* format */
XVA_DCL
X
X{
X VA_LIST arg; /* argument vector */
X int v; /* return value */
X
X VA_START(arg, fmt);
X v = vfprintf(stdout, fmt, arg);
X VA_END(arg);
X return v;
X}
END_OF_FILE
if test 678 -ne `wc -c <'printf.c'`; then
echo shar: \"'printf.c'\" unpacked with wrong size!
fi
# end of 'printf.c'
fi
if test -f 'putc.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'putc.c'\"
else
echo shar: Extracting \"'putc.c'\" \(630 characters\)
sed "s/^X//" >'putc.c' <<'END_OF_FILE'
X/* p u t c
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This is putc() wrapped inside a function.
X *
X * The function returns the character output on success and
X * EOF on failure.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X#undef putc
X
X/*LINTLIBRARY*/
X
Xint putc(T(int ch, ch), T(FILE *fp, fp))
X
XD(int ch) /* character */
XD(FILE *fp) /* stream */
X
X{
X return fp->_wptr < fp->_wend
X ? UCHAR(*fp->_wptr++ = ch)
X : (*fp->_flsbuf)(ch, fp);
X}
END_OF_FILE
if test 630 -ne `wc -c <'putc.c'`; then
echo shar: \"'putc.c'\" unpacked with wrong size!
fi
# end of 'putc.c'
fi
if test -f 'putchar.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'putchar.c'\"
else
echo shar: Extracting \"'putchar.c'\" \(533 characters\)
sed "s/^X//" >'putchar.c' <<'END_OF_FILE'
X/* p u t c h a r
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This is putchar() wrapped inside a function.
X *
X * The function returns the character output on success and
X * EOF on failure.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X#undef putchar
X
X/*LINTLIBRARY*/
X
Xint putchar(T(int ch, ch))
X
XD(int ch) /* character */
X
X{
X return putc(ch, stdout);
X}
X
END_OF_FILE
if test 533 -ne `wc -c <'putchar.c'`; then
echo shar: \"'putchar.c'\" unpacked with wrong size!
fi
# end of 'putchar.c'
fi
if test -f 'putw.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'putw.c'\"
else
echo shar: Extracting \"'putw.c'\" \(648 characters\)
sed "s/^X//" >'putw.c' <<'END_OF_FILE'
X/* p u t w
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Write a word to a stream. The function putw returns the word written
X * or EOF on error. Because EOF is a valid word, it is better for the
X * caller to check for errors using ferror.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xint putw(T(int w, w), T(FILE *fp, fp))
X
XD(int w) /* word to write */
XD(FILE *fp) /* stream */
X
X{
X return fwrite((void *) &w, sizeof(int), 1, fp) == 1 ? w : EOF;
X}
END_OF_FILE
if test 648 -ne `wc -c <'putw.c'`; then
echo shar: \"'putw.c'\" unpacked with wrong size!
fi
# end of 'putw.c'
fi
if test -f 'remove.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'remove.c'\"
else
echo shar: Extracting \"'remove.c'\" \(531 characters\)
sed "s/^X//" >'remove.c' <<'END_OF_FILE'
X/* r e m o v e
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Remove a file. The file named is removed. Return EOF if
X * something goes wrong, otherwise return 0.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
X#undef remove
X
Xint remove(T(const char *name, name))
X
XD(char *name) /* name of file */
X
X{
X return unlink(name) != 0 ? EOF : 0;
X}
END_OF_FILE
if test 531 -ne `wc -c <'remove.c'`; then
echo shar: \"'remove.c'\" unpacked with wrong size!
fi
# end of 'remove.c'
fi
if test -f 'rewind.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'rewind.c'\"
else
echo shar: Extracting \"'rewind.c'\" \(550 characters\)
sed "s/^X//" >'rewind.c' <<'END_OF_FILE'
X/* r e w i n d
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This function rewinds a stream to the beginning of the file.
X * It is equivalent to fseek(fp, 0L, 0) except that no value
X * is returned.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xvoid rewind(T(FILE *fp, fp))
X
XD(FILE *fp) /* stream */
X
X{
X (void) fseek(fp, 0L, SEEK_SET);
X clearerr(fp);
X}
END_OF_FILE
if test 550 -ne `wc -c <'rewind.c'`; then
echo shar: \"'rewind.c'\" unpacked with wrong size!
fi
# end of 'rewind.c'
fi
if test -f 'scanf.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'scanf.c'\"
else
echo shar: Extracting \"'scanf.c'\" \(672 characters\)
sed "s/^X//" >'scanf.c' <<'END_OF_FILE'
X/* s c a n f
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * Formatted input from stdin. The function returns the number items
X * scanned from stdin and EOF on failure.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X/*VARARGS1*/
X/*ARGSUSED*/
X
Xint scanf(T(const char *fmt, fmt), VA_ALIST)
X
XD(char *fmt) /* format */
XVA_DCL
X
X{
X VA_LIST arg; /* argument vector */
X int v; /* return value */
X
X VA_START(arg, fmt);
X v = _vfscanf(stdin, fmt, arg);
X VA_END(arg);
X return v;
X}
END_OF_FILE
if test 672 -ne `wc -c <'scanf.c'`; then
echo shar: \"'scanf.c'\" unpacked with wrong size!
fi
# end of 'scanf.c'
fi
if test -f 'turboc.cfg' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'turboc.cfg'\"
else
echo shar: Extracting \"'turboc.cfg'\" \(72 characters\)
sed "s/^X//" >'turboc.cfg' <<'END_OF_FILE'
X-wamp
X-wcln
X-wuse
X-w-rvl
X-wsig
X-wamb
X-wstv
X-wnod
X-wucp
X-A
X-O
X-Z
X-j1
X-g1
END_OF_FILE
if test 72 -ne `wc -c <'turboc.cfg'`; then
echo shar: \"'turboc.cfg'\" unpacked with wrong size!
fi
# end of 'turboc.cfg'
fi
if test -f 'vprintf.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'vprintf.c'\"
else
echo shar: Extracting \"'vprintf.c'\" \(563 characters\)
sed "s/^X//" >'vprintf.c' <<'END_OF_FILE'
X/* v p r i n t f
X *
X * (C) Copyright C E Chew
X *
X * Feel free to copy, use and distribute this software provided:
X *
X * 1. you do not pretend that you wrote it
X * 2. you leave this copyright notice intact.
X *
X * This function provides the same functionality as printf except
X * that it uses varargs.h.
X *
X * Patchlevel 2.0
X *
X * Edit History:
X */
X
X#include "stdiolib.h"
X
X/*LINTLIBRARY*/
X
Xint vprintf(T(const char *fmt, fmt), T(VA_LIST args, args))
X
XD(char *fmt) /* format */
XD(VA_LIST args) /* argument list */
X
X{
X return vfprintf(stdout, fmt, args);
X}
END_OF_FILE
if test 563 -ne `wc -c <'vprintf.c'`; then
echo shar: \"'vprintf.c'\" unpacked with wrong size!
fi
# end of 'vprintf.c'
fi
if test -f 'xexit.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xexit.c'\"
else
echo shar: Extracting \"'xexit.c'\" \(24 characters\)
sed "s/^X//" >'xexit.c' <<'END_OF_FILE'
Xmain()
X
X{
X return 0;
X}
END_OF_FILE
if test 24 -ne `wc -c <'xexit.c'`; then
echo shar: \"'xexit.c'\" unpacked with wrong size!
fi
# end of 'xexit.c'
fi
if test -f 'xfputs.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xfputs.c'\"
else
echo shar: Extracting \"'xfputs.c'\" \(161 characters\)
sed "s/^X//" >'xfputs.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xmain()
X
X{
X int i;
X
X for (i = 0; i < 10000; i++) {
X fputs("Here is a line that is to be printed on stdout\n", stdout);
X }
X return 0;
X}
END_OF_FILE
if test 161 -ne `wc -c <'xfputs.c'`; then
echo shar: \"'xfputs.c'\" unpacked with wrong size!
fi
# end of 'xfputs.c'
fi
if test -f 'xfwrite.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xfwrite.c'\"
else
echo shar: Extracting \"'xfwrite.c'\" \(290 characters\)
sed "s/^X//" >'xfwrite.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xmain()
X
X{
X char *malloc();
X void exit();
X char *b;
X int i;
X
X if ((b = malloc(48*1024)) == 0) {
X fputs("No memory for buffer\n", stderr);
X exit(1);
X }
X
X for (i = 0; i < 100; i++)
X fwrite(b, 1023, 1, stdout);
X
X fwrite(b, 1023, 48, stdout);
X
X return 0;
X}
END_OF_FILE
if test 290 -ne `wc -c <'xfwrite.c'`; then
echo shar: \"'xfwrite.c'\" unpacked with wrong size!
fi
# end of 'xfwrite.c'
fi
if test -f 'xprintf.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xprintf.c'\"
else
echo shar: Extracting \"'xprintf.c'\" \(235 characters\)
sed "s/^X//" >'xprintf.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xmain()
X
X{
X int i;
X
X for (i = 0; i < 1000; i++) {
X printf(" Heading Line \n\
X%70s\n\
X%70d\n\
X%70ld\n",
X"String to be printed as a test", 0x7fff, 0x7ffffffL);
X }
X return 0;
X}
END_OF_FILE
if test 235 -ne `wc -c <'xprintf.c'`; then
echo shar: \"'xprintf.c'\" unpacked with wrong size!
fi
# end of 'xprintf.c'
fi
if test -f 'xputc.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xputc.c'\"
else
echo shar: Extracting \"'xputc.c'\" \(162 characters\)
sed "s/^X//" >'xputc.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xmain()
X
X{
X int i, j;
X
X for (i = 0; i < 1000; i++) {
X for (j = 0; j < 26; j++)
X putchar('a'+j);
X putchar('\n');
X }
X return 0;
X}
END_OF_FILE
if test 162 -ne `wc -c <'xputc.c'`; then
echo shar: \"'xputc.c'\" unpacked with wrong size!
fi
# end of 'xputc.c'
fi
if test -f 'xputs.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xputs.c'\"
else
echo shar: Extracting \"'xputs.c'\" \(154 characters\)
sed "s/^X//" >'xputs.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xmain()
X
X{
X int i;
X
X for (i = 0; i < 10000; i++) {
X puts("Here is a line that is to be printed on the stdout");
X }
X return 0;
X}
END_OF_FILE
if test 154 -ne `wc -c <'xputs.c'`; then
echo shar: \"'xputs.c'\" unpacked with wrong size!
fi
# end of 'xputs.c'
fi
if test -f 'xsprintf.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'xsprintf.c'\"
else
echo shar: Extracting \"'xsprintf.c'\" \(259 characters\)
sed "s/^X//" >'xsprintf.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xmain()
X
X{
X int i;
X char buf[1024];
X
X for (i = 0; i < 1000; i++) {
X sprintf(buf, " Heading Line \n\
X%70s\n\
X%70d\n\
X%70ld\n",
X"String to be printed as a test", 0x7fff, 0x7ffffffL);
X }
X return 0;
X}
END_OF_FILE
if test 259 -ne `wc -c <'xsprintf.c'`; then
echo shar: \"'xsprintf.c'\" unpacked with wrong size!
fi
# end of 'xsprintf.c'
fi
if test -f 'ybcopy.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ybcopy.c'\"
else
echo shar: Extracting \"'ybcopy.c'\" \(55 characters\)
sed "s/^X//" >'ybcopy.c' <<'END_OF_FILE'
Xextern int bcopy();
X
Xint main()
X
X{
X return bcopy();
X}
END_OF_FILE
if test 55 -ne `wc -c <'ybcopy.c'`; then
echo shar: \"'ybcopy.c'\" unpacked with wrong size!
fi
# end of 'ybcopy.c'
fi
if test -f 'ylen.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ylen.c'\"
else
echo shar: Extracting \"'ylen.c'\" \(696 characters\)
sed "s/^X//" >'ylen.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xint value(p, q)
X
Xchar *p;
Xchar *q;
X
X{
X int d, f;
X
X if (*p < '0' || *p > '9')
X p = q;
X
X sscanf(p, "%d.%d", &d, &f);
X return d*10+f;
X}
X
Xint main()
X
X{
X int sreal, suser, ssys, mreal, muser, msys;
X char x[20], y[20];
X int exit();
X
X scanf(" %s %s", x, y);
X sreal = value(x, y);
X
X scanf(" %s %s", x, y);
X suser = value(x, y);
X
X scanf(" %s %s", x, y);
X ssys = value(x, y);
X
X scanf(" %s %s", x, y);
X mreal = value(x, y);
X
X scanf(" %s %s", x, y);
X muser = value(x, y);
X
X scanf(" %s %s", x, y);
X msys = value(x, y);
X
X printf("/* %d %d %d */\n", sreal, suser, ssys);
X printf("/* %d %d %d */\n", mreal, muser, msys);
X
X return exit((muser+msys) > (suser+ssys));
X}
END_OF_FILE
if test 696 -ne `wc -c <'ylen.c'`; then
echo shar: \"'ylen.c'\" unpacked with wrong size!
fi
# end of 'ylen.c'
fi
if test -f 'ylimits.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ylimits.c'\"
else
echo shar: Extracting \"'ylimits.c'\" \(315 characters\)
sed "s/^X//" >'ylimits.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xint main()
X
X{
X char c;
X unsigned short us = ~0;
X unsigned int ui = ~0;
X int i, j;
X
X for (i = 0, j = 1; (c = j), c != 0; i++, j <<= 1)
X ;
X printf("#define CHAR_BIT %d\n", i);
X printf("#define USHRT_MAX %u\n", (int) us);
X printf("#define INT_MAX %u\n", (int) (ui >> 1));
X
X return 0;
X}
END_OF_FILE
if test 315 -ne `wc -c <'ylimits.c'`; then
echo shar: \"'ylimits.c'\" unpacked with wrong size!
fi
# end of 'ylimits.c'
fi
if test -f 'ylimits.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ylimits.h'\"
else
echo shar: Extracting \"'ylimits.h'\" \(49 characters\)
sed "s/^X//" >'ylimits.h' <<'END_OF_FILE'
X#include <limits.h>
X
Xint main()
X
X{
X return 0;
X}
END_OF_FILE
if test 49 -ne `wc -c <'ylimits.h'`; then
echo shar: \"'ylimits.h'\" unpacked with wrong size!
fi
# end of 'ylimits.h'
fi
if test -f 'ylower.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ylower.c'\"
else
echo shar: Extracting \"'ylower.c'\" \(87 characters\)
sed "s/^X//" >'ylower.c' <<'END_OF_FILE'
X#include <ctype.h>
X
Xint main()
X
X{
X int exit();
X
X return exit(tolower('a') != 'a');
X}
END_OF_FILE
if test 87 -ne `wc -c <'ylower.c'`; then
echo shar: \"'ylower.c'\" unpacked with wrong size!
fi
# end of 'ylower.c'
fi
if test -f 'ymemlen.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ymemlen.c'\"
else
echo shar: Extracting \"'ymemlen.c'\" \(190 characters\)
sed "s/^X//" >'ymemlen.c' <<'END_OF_FILE'
Xint main()
X
X{
X char *string = "abcdefghijklmpqrstuvwxyz";
X int i;
X char *j, *memchr();
X
X for (i = 0; i < 10000; i++)
X j = memchr(string, 0, ((unsigned int) (~0)) >> 1);
X return 0;
X}
END_OF_FILE
if test 190 -ne `wc -c <'ymemlen.c'`; then
echo shar: \"'ymemlen.c'\" unpacked with wrong size!
fi
# end of 'ymemlen.c'
fi
if test -f 'ymemory.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ymemory.c'\"
else
echo shar: Extracting \"'ymemory.c'\" \(102 characters\)
sed "s/^X//" >'ymemory.c' <<'END_OF_FILE'
Xint memset();
Xint memcpy();
Xint memchr();
X
Xint main()
X
X{
X return memset() && memcpy() && memchr();
X}
END_OF_FILE
if test 102 -ne `wc -c <'ymemory.c'`; then
echo shar: \"'ymemory.c'\" unpacked with wrong size!
fi
# end of 'ymemory.c'
fi
if test -f 'ynull.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ynull.c'\"
else
echo shar: Extracting \"'ynull.c'\" \(28 characters\)
sed "s/^X//" >'ynull.c' <<'END_OF_FILE'
Xint main()
X
X{
X return 0;
X}
END_OF_FILE
if test 28 -ne `wc -c <'ynull.c'`; then
echo shar: \"'ynull.c'\" unpacked with wrong size!
fi
# end of 'ynull.c'
fi
if test -f 'yopen.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'yopen.c'\"
else
echo shar: Extracting \"'yopen.c'\" \(75 characters\)
sed "s/^X//" >'yopen.c' <<'END_OF_FILE'
X#include <fcntl.h>
X
Xint main()
X
X{
X return O_CREAT | O_TRUNC | O_APPEND;
X}
END_OF_FILE
if test 75 -ne `wc -c <'yopen.c'`; then
echo shar: \"'yopen.c'\" unpacked with wrong size!
fi
# end of 'yopen.c'
fi
if test -f 'yrename.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'yrename.c'\"
else
echo shar: Extracting \"'yrename.c'\" \(43 characters\)
sed "s/^X//" >'yrename.c' <<'END_OF_FILE'
Xint main()
X
X{
X return rename("a", "b");
X}
END_OF_FILE
if test 43 -ne `wc -c <'yrename.c'`; then
echo shar: \"'yrename.c'\" unpacked with wrong size!
fi
# end of 'yrename.c'
fi
if test -f 'ystdarg.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ystdarg.c'\"
else
echo shar: Extracting \"'ystdarg.c'\" \(49 characters\)
sed "s/^X//" >'ystdarg.c' <<'END_OF_FILE'
X#include <stdarg.h>
X
Xint main()
X
X{
X return 0;
X}
END_OF_FILE
if test 49 -ne `wc -c <'ystdarg.c'`; then
echo shar: \"'ystdarg.c'\" unpacked with wrong size!
fi
# end of 'ystdarg.c'
fi
if test -f 'ystdc.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ystdc.c'\"
else
echo shar: Extracting \"'ystdc.c'\" \(96 characters\)
sed "s/^X//" >'ystdc.c' <<'END_OF_FILE'
Xint main()
X
X{
X int exit();
X
X#ifdef __STDC__
X return exit(0);
X#else
X return exit(1);
X#endif
X}
END_OF_FILE
if test 96 -ne `wc -c <'ystdc.c'`; then
echo shar: \"'ystdc.c'\" unpacked with wrong size!
fi
# end of 'ystdc.c'
fi
if test -f 'ystring.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ystring.c'\"
else
echo shar: Extracting \"'ystring.c'\" \(20 characters\)
sed "s/^X//" >'ystring.c' <<'END_OF_FILE'
X#include <string.h>
END_OF_FILE
if test 20 -ne `wc -c <'ystring.c'`; then
echo shar: \"'ystring.c'\" unpacked with wrong size!
fi
# end of 'ystring.c'
fi
if test -f 'ystrings.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ystrings.c'\"
else
echo shar: Extracting \"'ystrings.c'\" \(21 characters\)
sed "s/^X//" >'ystrings.c' <<'END_OF_FILE'
X#include <strings.h>
END_OF_FILE
if test 21 -ne `wc -c <'ystrings.c'`; then
echo shar: \"'ystrings.c'\" unpacked with wrong size!
fi
# end of 'ystrings.c'
fi
if test -f 'ystrlen.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ystrlen.c'\"
else
echo shar: Extracting \"'ystrlen.c'\" \(156 characters\)
sed "s/^X//" >'ystrlen.c' <<'END_OF_FILE'
Xint main()
X
X{
X char *string = "abcdefghijklmpqrstuvwxyz";
X int i, j;
X int strlen();
X
X for (i = 0; i < 10000; i++)
X j = strlen(string);
X return 0;
X}
END_OF_FILE
if test 156 -ne `wc -c <'ystrlen.c'`; then
echo shar: \"'ystrlen.c'\" unpacked with wrong size!
fi
# end of 'ystrlen.c'
fi
if test -f 'ytime.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ytime.c'\"
else
echo shar: Extracting \"'ytime.c'\" \(18 characters\)
sed "s/^X//" >'ytime.c' <<'END_OF_FILE'
X#include <time.h>
END_OF_FILE
if test 18 -ne `wc -c <'ytime.c'`; then
echo shar: \"'ytime.c'\" unpacked with wrong size!
fi
# end of 'ytime.c'
fi
if test -f 'ytypes.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'ytypes.c'\"
else
echo shar: Extracting \"'ytypes.c'\" \(52 characters\)
sed "s/^X//" >'ytypes.c' <<'END_OF_FILE'
X#include <sys/types.h>
X
Xint main()
X
X{
X return 0;
X}
END_OF_FILE
if test 52 -ne `wc -c <'ytypes.c'`; then
echo shar: \"'ytypes.c'\" unpacked with wrong size!
fi
# end of 'ytypes.c'
fi
if test -f 'yuchar.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'yuchar.c'\"
else
echo shar: Extracting \"'yuchar.c'\" \(138 characters\)
sed "s/^X//" >'yuchar.c' <<'END_OF_FILE'
Xint main()
X
X{
X int x = ~0;
X int exit();
X
X return exit(((int) ((unsigned char) x)) == x ||
X ((int) ((char) x)) != x) ;
X}
END_OF_FILE
if test 138 -ne `wc -c <'yuchar.c'`; then
echo shar: \"'yuchar.c'\" unpacked with wrong size!
fi
# end of 'yuchar.c'
fi
if test -f 'yumask.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'yumask.c'\"
else
echo shar: Extracting \"'yumask.c'\" \(155 characters\)
sed "s/^X//" >'yumask.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xint main()
X
X{
X char c;
X int i, j;
X
X for (i = 0, j = 1; (c = j), c != 0; i++, j <<= 1)
X ;
X printf("0x%x\n", j-1);
X
X return 0;
X}
END_OF_FILE
if test 155 -ne `wc -c <'yumask.c'`; then
echo shar: \"'yumask.c'\" unpacked with wrong size!
fi
# end of 'yumask.c'
fi
if test -f 'yvarargs.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'yvarargs.c'\"
else
echo shar: Extracting \"'yvarargs.c'\" \(21 characters\)
sed "s/^X//" >'yvarargs.c' <<'END_OF_FILE'
X#include <varargs.h>
END_OF_FILE
if test 21 -ne `wc -c <'yvarargs.c'`; then
echo shar: \"'yvarargs.c'\" unpacked with wrong size!
fi
# end of 'yvarargs.c'
fi
echo shar: End of archive 1 \(of 6\).
cp /dev/null ark1isdone
MISSING=""
for I in 1 2 3 4 5 6 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 6 archives.
rm -f ark[1-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0
--
Earl Chew, Dept of Computer Science, Monash University, Australia 3168
ARPA: cechew%bruce.cs.monash.oz.au@uunet.uu.net ACS : cechew@bruce.oz