From 69f02d8abcd6ae9d1cc2f441d4f66d9cecd63f23 Mon Sep 17 00:00:00 2001 From: eck Date: Tue, 30 May 1989 13:34:25 +0000 Subject: [PATCH] Initial revision --- lang/cem/libcc.ansi/stdio/LIST | 50 ++++ lang/cem/libcc.ansi/stdio/clearerr.c | 12 + lang/cem/libcc.ansi/stdio/data.c | 28 ++ lang/cem/libcc.ansi/stdio/doprnt.c | 368 ++++++++++++++++++++++++ lang/cem/libcc.ansi/stdio/doscan.c | 410 +++++++++++++++++++++++++++ lang/cem/libcc.ansi/stdio/ecvt.c | 196 +++++++++++++ lang/cem/libcc.ansi/stdio/fclose.c | 31 ++ lang/cem/libcc.ansi/stdio/feof.c | 14 + lang/cem/libcc.ansi/stdio/ferror.c | 14 + lang/cem/libcc.ansi/stdio/fflush.c | 47 +++ lang/cem/libcc.ansi/stdio/fgetc.c | 12 + lang/cem/libcc.ansi/stdio/fgetpos.c | 15 + lang/cem/libcc.ansi/stdio/fgets.c | 24 ++ lang/cem/libcc.ansi/stdio/fillbuf.c | 54 ++++ lang/cem/libcc.ansi/stdio/fltpr.c | 148 ++++++++++ lang/cem/libcc.ansi/stdio/flushbuf.c | 96 +++++++ lang/cem/libcc.ansi/stdio/fopen.c | 83 ++++++ lang/cem/libcc.ansi/stdio/fprintf.c | 25 ++ lang/cem/libcc.ansi/stdio/fputc.c | 12 + lang/cem/libcc.ansi/stdio/fputs.c | 18 ++ lang/cem/libcc.ansi/stdio/fread.c | 27 ++ lang/cem/libcc.ansi/stdio/freopen.c | 88 ++++++ lang/cem/libcc.ansi/stdio/fscanf.c | 23 ++ lang/cem/libcc.ansi/stdio/fseek.c | 60 ++++ lang/cem/libcc.ansi/stdio/fsetpos.c | 12 + lang/cem/libcc.ansi/stdio/ftell.c | 33 +++ lang/cem/libcc.ansi/stdio/fwrite.c | 28 ++ lang/cem/libcc.ansi/stdio/gcvt.c | 144 ++++++++++ lang/cem/libcc.ansi/stdio/getc.c | 14 + lang/cem/libcc.ansi/stdio/getchar.c | 14 + lang/cem/libcc.ansi/stdio/gets.c | 23 ++ lang/cem/libcc.ansi/stdio/loc_incl.h | 50 ++++ lang/cem/libcc.ansi/stdio/perror.c | 16 ++ lang/cem/libcc.ansi/stdio/printf.c | 25 ++ lang/cem/libcc.ansi/stdio/putc.c | 14 + lang/cem/libcc.ansi/stdio/putchar.c | 14 + lang/cem/libcc.ansi/stdio/puts.c | 12 + lang/cem/libcc.ansi/stdio/remove.c | 13 + lang/cem/libcc.ansi/stdio/rename.c | 16 ++ lang/cem/libcc.ansi/stdio/rewind.c | 14 + lang/cem/libcc.ansi/stdio/scanf.c | 25 ++ lang/cem/libcc.ansi/stdio/setbuf.c | 18 ++ lang/cem/libcc.ansi/stdio/setvbuf.c | 42 +++ lang/cem/libcc.ansi/stdio/sprintf.c | 31 ++ lang/cem/libcc.ansi/stdio/sscanf.c | 29 ++ lang/cem/libcc.ansi/stdio/tmpfile.c | 29 ++ lang/cem/libcc.ansi/stdio/tmpnam.c | 28 ++ lang/cem/libcc.ansi/stdio/ungetc.c | 24 ++ lang/cem/libcc.ansi/stdio/vfprintf.c | 20 ++ lang/cem/libcc.ansi/stdio/vprintf.c | 20 ++ lang/cem/libcc.ansi/stdio/vsprintf.c | 26 ++ 51 files changed, 2589 insertions(+) create mode 100644 lang/cem/libcc.ansi/stdio/LIST create mode 100644 lang/cem/libcc.ansi/stdio/clearerr.c create mode 100644 lang/cem/libcc.ansi/stdio/data.c create mode 100644 lang/cem/libcc.ansi/stdio/doprnt.c create mode 100644 lang/cem/libcc.ansi/stdio/doscan.c create mode 100644 lang/cem/libcc.ansi/stdio/ecvt.c create mode 100644 lang/cem/libcc.ansi/stdio/fclose.c create mode 100644 lang/cem/libcc.ansi/stdio/feof.c create mode 100644 lang/cem/libcc.ansi/stdio/ferror.c create mode 100644 lang/cem/libcc.ansi/stdio/fflush.c create mode 100644 lang/cem/libcc.ansi/stdio/fgetc.c create mode 100644 lang/cem/libcc.ansi/stdio/fgetpos.c create mode 100644 lang/cem/libcc.ansi/stdio/fgets.c create mode 100644 lang/cem/libcc.ansi/stdio/fillbuf.c create mode 100644 lang/cem/libcc.ansi/stdio/fltpr.c create mode 100644 lang/cem/libcc.ansi/stdio/flushbuf.c create mode 100644 lang/cem/libcc.ansi/stdio/fopen.c create mode 100644 lang/cem/libcc.ansi/stdio/fprintf.c create mode 100644 lang/cem/libcc.ansi/stdio/fputc.c create mode 100644 lang/cem/libcc.ansi/stdio/fputs.c create mode 100644 lang/cem/libcc.ansi/stdio/fread.c create mode 100644 lang/cem/libcc.ansi/stdio/freopen.c create mode 100644 lang/cem/libcc.ansi/stdio/fscanf.c create mode 100644 lang/cem/libcc.ansi/stdio/fseek.c create mode 100644 lang/cem/libcc.ansi/stdio/fsetpos.c create mode 100644 lang/cem/libcc.ansi/stdio/ftell.c create mode 100644 lang/cem/libcc.ansi/stdio/fwrite.c create mode 100644 lang/cem/libcc.ansi/stdio/gcvt.c create mode 100644 lang/cem/libcc.ansi/stdio/getc.c create mode 100644 lang/cem/libcc.ansi/stdio/getchar.c create mode 100644 lang/cem/libcc.ansi/stdio/gets.c create mode 100644 lang/cem/libcc.ansi/stdio/loc_incl.h create mode 100644 lang/cem/libcc.ansi/stdio/perror.c create mode 100644 lang/cem/libcc.ansi/stdio/printf.c create mode 100644 lang/cem/libcc.ansi/stdio/putc.c create mode 100644 lang/cem/libcc.ansi/stdio/putchar.c create mode 100644 lang/cem/libcc.ansi/stdio/puts.c create mode 100644 lang/cem/libcc.ansi/stdio/remove.c create mode 100644 lang/cem/libcc.ansi/stdio/rename.c create mode 100644 lang/cem/libcc.ansi/stdio/rewind.c create mode 100644 lang/cem/libcc.ansi/stdio/scanf.c create mode 100644 lang/cem/libcc.ansi/stdio/setbuf.c create mode 100644 lang/cem/libcc.ansi/stdio/setvbuf.c create mode 100644 lang/cem/libcc.ansi/stdio/sprintf.c create mode 100644 lang/cem/libcc.ansi/stdio/sscanf.c create mode 100644 lang/cem/libcc.ansi/stdio/tmpfile.c create mode 100644 lang/cem/libcc.ansi/stdio/tmpnam.c create mode 100644 lang/cem/libcc.ansi/stdio/ungetc.c create mode 100644 lang/cem/libcc.ansi/stdio/vfprintf.c create mode 100644 lang/cem/libcc.ansi/stdio/vprintf.c create mode 100644 lang/cem/libcc.ansi/stdio/vsprintf.c diff --git a/lang/cem/libcc.ansi/stdio/LIST b/lang/cem/libcc.ansi/stdio/LIST new file mode 100644 index 000000000..b6a31f2aa --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/LIST @@ -0,0 +1,50 @@ +llib +tmpfile.c +tmpnam.c +rename.c +remove.c +fopen.c +freopen.c +setbuf.c +setvbuf.c +perror.c +fprintf.c +printf.c +sprintf.c +vfprintf.c +vprintf.c +vsprintf.c +doprnt.c +fscanf.c +scanf.c +sscanf.c +doscan.c +fgetc.c +fgets.c +getc.c +getchar.c +gets.c +putc.c +putchar.c +fputc.c +puts.c +fputs.c +ungetc.c +fread.c +fwrite.c +fgetpos.c +fsetpos.c +rewind.c +fseek.c +ftell.c +clearerr.c +feof.c +ferror.c +fltpr.c +ecvt.c +gcvt.c +fillbuf.c +fclose.c +flushbuf.c +fflush.c +data.c diff --git a/lang/cem/libcc.ansi/stdio/clearerr.c b/lang/cem/libcc.ansi/stdio/clearerr.c new file mode 100644 index 000000000..1d639db7c --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/clearerr.c @@ -0,0 +1,12 @@ +/* + * clearerr.c - clear error and end-of-file indicators of a stream + */ +/* $Header$ */ + +#include + +void +clearerr(FILE *stream) +{ + stream->_flags &= ~(_IOERR|_IOEOF); +} diff --git a/lang/cem/libcc.ansi/stdio/data.c b/lang/cem/libcc.ansi/stdio/data.c new file mode 100644 index 000000000..a8fd4ad4d --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/data.c @@ -0,0 +1,28 @@ +/* + * data.c - this is the initialization for the standard streams + */ +/* $Header$ */ + +#include + +struct _iobuf _stdin = { + 0, 0, _IOREAD, 0, + (char *)NULL, (unsigned char *)NULL, (unsigned char *)NULL, +}; + +struct _iobuf _stdout = { + 1, 0, _IOWRITE, 0, + (char *)NULL, (unsigned char *)NULL, (unsigned char *)NULL, +}; + +struct _iobuf _stderr = { + 2, 0, _IOWRITE | _IONBF, 0, + (char *)NULL, (unsigned char *)NULL, (unsigned char *)NULL, +}; + +struct _iobuf *_iotable[FOPEN_MAX] = { + &_stdin, + &_stdout, + &_stderr, + 0 +}; diff --git a/lang/cem/libcc.ansi/stdio/doprnt.c b/lang/cem/libcc.ansi/stdio/doprnt.c new file mode 100644 index 000000000..68d060b36 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/doprnt.c @@ -0,0 +1,368 @@ +/* + * doprnt.c - print formatted output + */ +/* $Header$ */ + +#include +#include +#include +#include +#include "loc_incl.h" + +static char * +gnum(register const char *f, int *ip, va_list *app) +{ + register int i, c; + + if (*f == '*') { + *ip = va_arg((*app), int); + f++; + } else { + i = 0; + while ((c = *f - '0') >= 0 && c <= 9) { + i = i*10 + c; + f++; + } + *ip = i; + } + return(f); +} + +#if EM_WSIZE == EM_PSIZE +#define set_pointer(flags) /* nothing */ +#elif EM_LSIZE == EM_PSIZE +#define set_pointer(flags) (flags |= FL_LONG) +#else +#define set_pointer(flags) /* nothing */ +#error garbage pointer size +#endif + +char * +i_compute(unsigned long val, int base, char *s, int nrdigits) +{ + int c; + + c= val % base ; + val /= base ; + if (val || nrdigits > 0) + s = i_compute(val, base, s, nrdigits - 1); + *s++ = (c>9 ? c-10+'a' : c+'0'); + return(s); +} + +/* print an ordinal number */ +static char * +o_print(va_list *ap, int flags, char *s, char c, int precision, int is_signed) +{ + long signed_val; + unsigned long unsigned_val; + char *old_s = s; + int i, base, is_zero = 0, is_neg = 0; + + switch (flags & (FL_SHORT | FL_LONG)) { + case FL_SHORT: + if (is_signed) { + signed_val = (short) va_arg(*ap, int); + } else { + unsigned_val = (unsigned short) va_arg(*ap, unsigned); + } + break; + case FL_LONG: + if (is_signed) { + signed_val = va_arg(*ap, long); + } else { + unsigned_val = va_arg(*ap, unsigned long); + } + break; + default: + if (is_signed) { + signed_val = va_arg(*ap, int); + } else { + unsigned_val = va_arg(*ap, unsigned int); + } + break; + } + + if (is_signed) { + if (signed_val < 0) { + *s++ = '-'; + signed_val = -signed_val; + } else if (flags & FL_SIGN) *s++ = '+'; + else if (flags & FL_SPACE) *s++ = ' '; + unsigned_val = signed_val; + } + if (!unsigned_val) { + if (precision != 0) + *s++ = '0'; + return s; + } + if (((flags & FL_ALT) && (c == 'x' || c == 'X' || c == 'o')) + || c == 'p') { + *s++ = '0'; + if (c != 'o') + *s++ = (c == 'X') ? 'X' : 'x'; + } + + switch (c) { + case 'b': base = 2; break; + case 'o': base = 8; break; + case 'd': + case 'i': + case 'u': base = 10; break; + case 'x': + case 'X': + case 'p': base = 16; break; + } + + s = i_compute(unsigned_val, base, s, precision - 1); + + if (c == 'X') + while (old_s != s) { + *old_s = toupper(*old_s); + old_s++; + } + + return s; +} + +#ifndef NOFLOAT +static char * +f_print(va_list *ap, int flags, char *s, char c, int precision) +{ + register char *old_s = s; + double d_val; + +#if EM_DSIZE != EM_LDSIZE + long double ld_val; + + if (flags & FL_LONGDOUBLE) ld_val = va_arg(*ap, long double); + else +#endif + d_val = va_arg(*ap, double); + + switch(c) { + case 'f': +#if EM_DSIZE != EM_LDSIZE + if (flags & FL_LONGDOUBLE) + s = _pfloat_ldbl(ld_val, s, precision, flags); + else +#endif + s = _pfloat(d_val, s, precision, flags); + break; + case 'e': + case 'E': +#if EM_DSIZE != EM_LDSIZE + if (flags & FL_LONGDOUBLE) + s = _pscien_ldbl(ld_val, s, precision, flags); + else +#endif + s = _pscien(d_val, s, precision, flags); + break; + case 'g': + case 'G': +#if EM_DSIZE != EM_LDSIZE + if (flags & FL_LONGDOUBLE) + s = gcvt_ldbl(ld_val, precision, s, flags) + strlen(s); + else +#endif + s = gcvt(d_val, precision, s, flags) + strlen(s); + break; + } + if ( c == 'E' || c == 'G') { + while (*old_s && *old_s != 'e') old_s++; + if (*old_s == 'e') *old_s = 'E'; + } + return s; +} +#endif /* NOFLOAT */ + +int +_doprnt(register const char *fmt, va_list ap, FILE *stream) +{ + register char *s; + unsigned int uint; + register int j; + int i, c, width, precision, zfill, flags, between_fill; + int nrchars=0; + char *oldfmt, *s1, buf[1025]; + + while (c = *fmt++) { + if (c != '%') { +#ifdef CPM + if (c == '\n') { + putc('\r', stream); + nrchars++; + } +#endif + putc(c, stream); + nrchars++; + continue; + } + flags = 0; + do { + switch(*fmt) { + case '-': flags |= FL_LJUST; break; + case '+': flags |= FL_SIGN; break; + case ' ': flags |= FL_SPACE; break; + case '#': flags |= FL_ALT; break; + case '0': flags |= FL_ZEROFILL; break; + default: flags |= FL_NOMORE; continue; + } + fmt++; + } while(!(flags & FL_NOMORE)); + + oldfmt = fmt; + fmt = gnum(fmt, &width, &ap); + if (fmt != oldfmt) flags |= FL_WIDTHSPEC; + + if (*fmt == '.') { + fmt++; oldfmt = fmt; + fmt = gnum(fmt, &precision, &ap); + if (precision >= 0) flags |= FL_PRECSPEC; + } + + if ((flags & FL_WIDTHSPEC) && width < 0) { + width = -width; + flags |= FL_LJUST; + } + if (!(flags & FL_WIDTHSPEC)) width = 1; + + if (flags & FL_SIGN) + flags &= ~FL_SPACE; + + if (flags & (FL_LJUST | FL_PRECSPEC)) + flags &= ~FL_ZEROFILL; + + zfill = ' '; + if (flags & FL_ZEROFILL) + zfill = '0'; + + s = s1 = buf; + + switch (*fmt) { + case 'h': flags |= FL_SHORT; fmt++; break; + case 'l': flags |= FL_LONG; fmt++; break; + case 'L': flags |= FL_LONGDOUBLE; fmt++; break; + } + + switch (c = *fmt++) { + default: +#ifdef CPM + if (c == '\n') { + putc('\r', stream); + nrchars++; + } +#endif + putc(c, stream); + nrchars++; + continue; + case 'n': + if (flags & FL_SHORT) + *va_arg(ap, short *) = (short) nrchars; + else if (flags & FL_LONG) + *va_arg(ap, long *) = (long) nrchars; + else + *va_arg(ap, int *) = (int) nrchars; + continue; + case 's': + s1 = va_arg(ap, char *); + if (s1 == NULL) + s1 = "(null)"; + s = s1; + do { + if (*s == '\0') + break; + s++; + } while (!(flags & FL_PRECSPEC) || --precision); + break; + case 'p': + set_pointer(flags); + /* fallthrough */ + case 'b': + case 'o': + case 'u': + case 'x': + case 'X': + if (!(flags & FL_PRECSPEC)) precision = 1; + s = o_print(&ap, flags, s, c, precision, 0); + break; + case 'd': + case 'i': + flags |= FL_SIGNEDCONV; + if (!(flags & FL_PRECSPEC)) precision = 1; + s = o_print(&ap, flags, s, c, precision, 1); + break; + case 'c': + uint = va_arg(ap, unsigned int); + for ( i= sizeof(uint) -1 ; i>=0 ; i-- ) { + if ( *s = uint%256 ) s++; + uint/= 256 ; + } + break; +#ifndef NOFLOAT + case 'G': + case 'g': + if ((flags & FL_PRECSPEC) && (precision == 0)) + precision = 1; + case 'f': + case 'E': + case 'e': + if (!(flags & FL_PRECSPEC)) + precision = 6; + + if (precision >= sizeof(buf)) + precision = sizeof(buf) - 1; + + flags |= FL_SIGNEDCONV; + s = f_print(&ap, flags, s, c, precision); + break; +#endif /* NOFLOAT */ + case 'r': + ap = va_arg(ap, va_list); + fmt = va_arg(ap, char *); + continue; + } + j = s - s1; + + /* between_fill is true under the following conditions: + * 1- the fill character is '0' + * and + * 2a- the number is of the form 0x... or 0X... + * or + * 2b- the number contains a sign or space + */ + between_fill = 0; + if ((flags & FL_ZEROFILL) + && (((c == 'x' || c == 'X') && (flags & FL_ALT)) + || (c == 'p') + || ((flags & FL_SIGNEDCONV) + && ( *s1 == '+' || *s1 == '-' || *s1 == ' ')))) + between_fill++; + + if ((i = width - j) > 0) + if (!(flags & FL_LJUST)) { /* right justify */ + nrchars += i; + if (between_fill) { + if (flags & FL_SIGNEDCONV) { + j--; nrchars++; + putc(*s1++, stream); + } else { + j -= 2; nrchars += 2; + putc(*s1++, stream); + putc(*s1++, stream); + } + } + do putc(zfill, stream); + while (--i); + } + + nrchars += j; + while (--j >= 0) + putc(*s1++, stream); + + if (i > 0) nrchars += i; + while (--i >= 0) + putc(zfill, stream); + } + return nrchars; +} diff --git a/lang/cem/libcc.ansi/stdio/doscan.c b/lang/cem/libcc.ansi/stdio/doscan.c new file mode 100644 index 000000000..6ef9ee338 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/doscan.c @@ -0,0 +1,410 @@ +/* + * doscan.c - scan formatted input + */ +/* $Header$ */ + +#include +#include +#include +#include +#include "loc_incl.h" + +#define NUMLEN 128 + +static char Xtable[128]; +static char inp_buf[NUMLEN]; + +/* Collect a number of characters which constitite an ordinal number. + * When the type is 'i', the base can be 8, 10, or 16, depending on the + * first 1 or 2 characters. This means that the base must be adjusted + * according to the format of the number. At the end of the function, base + * is then set to 0, so strtol() will get the right argument. + */ +static char * +o_collect(register int c, register FILE *stream, char type, + int width, int *base) +{ + register char *bufp = inp_buf; + + switch (type) { + case 'i': /* i means octal, decimal or hexadecimal */ + case 'p': + case 'x': + case 'X': *base = 16; break; + case 'd': + case 'u': *base = 10; break; + case 'o': *base = 8; break; + case 'b': *base = 2; break; + } + + if (c == '-' || c == '+') { + *bufp++ = c; + width--; + c = getc(stream); + } + + if (width && c == '0' && *base == 16) { + *bufp++ = c; + width--; + c = getc(stream); + if (c != 'x' && c != 'X') { + if (type == 'i') *base = 8; + } + else if (width) { + *bufp++ = c; + width--; + c = getc(stream); + } + } + else if (type == 'i') *base = 10; + + while (width) { + if (((*base == 10) && isdigit(c)) + || ((*base == 16) && isxdigit(c)) + || ((*base == 8) && isdigit(c) && (c < '8')) + || ((*base == 2) && isdigit(c) && (c < '2'))) { + *bufp++ = c; + width--; + c = getc(stream); + } + else break; + } + + if (c != EOF) ungetc(c, stream); + if (type == 'i') *base = 0; + *bufp-- = '\0'; + return bufp; +} + +#ifndef NOFLOAT +/* The function f_collect() reads a string that has the format of a + * floating-point number. The function returns as soon as a format-error + * is encountered, leaving the offending character in the input. This means + * that 1.el leaves the 'l' in the input queue. Since all detection of + * format errors is done here, _doscan() doesn't call strtod() when it's + * not necessary. + */ +static char * +f_collect(register int c, register FILE *stream, int width) +{ + register char *bufp = inp_buf; + int digit_seen = 0; + + if (c == '-' || c == '+') { + *bufp++ = c; + width--; + c = getc(stream); + } + + while (width && isdigit(c)) { + digit_seen++; + *bufp++ = c; + width--; + c = getc(stream); + } + if (width && c == '.') { + *bufp++ = c; + width--; + c = getc(stream); + while (width && isdigit(c)) { + digit_seen++; + *bufp++ = c; + width--; + c = getc(stream); + } + } + + if (!digit_seen) { + if (c != EOF) ungetc(c, stream); + return inp_buf - 1; + } + else digit_seen = 0; + + if (width && (c == 'e' || c == 'E')) { + *bufp++ = c; + width--; + c = getc(stream); + if (width && (c == '+' || c == '-')) { + *bufp++ = c; + width--; + c = getc(stream); + } + while (width && isdigit(c)) { + digit_seen++; + *bufp++ = c; + width--; + c = getc(stream); + } + if (!digit_seen) { + if (c != EOF) ungetc(c,stream); + return inp_buf - 1; + } + } + + if (c != EOF) ungetc(c, stream); + *bufp-- = '\0'; + return bufp; +} +#endif /* NOFLOAT */ + + +/* + * the routine that does the scanning + */ + +int +_doscan(register FILE *stream, const char *format, va_list ap) +{ + int done = 0; /* number of items done */ + int nrchars = 0; /* number of characters read */ + int base; /* conversion base */ + unsigned long val; /* an integer value */ + char *str, *tmp_string; /* temporary pointers */ + unsigned width; /* width of field */ + int flags; /* some flags */ + int reverse; /* reverse the checking in [...] */ + int kind; + register int ic; +#ifndef NOFLOAT + double d_val; +#endif + + ic = getc(stream); + if (ic == EOF) + return EOF; + ungetc(ic,stream); + + while (1) { + if (isspace(*format)) { + while (isspace (*format)) + ++format; /* skip whitespace */ + ic = getc(stream); + nrchars++; + while (isspace (ic)) { + ic = getc(stream); + nrchars++; + } + } + else { + ic = getc(stream); + nrchars++; + } + if (!*format) + break; /* end of format */ + if (ic == EOF) + return done; /* seen an error */ + if (*format != '%') { + if (ic != *format) + break; /* matching error */ + ++format; + continue; + } + ++format; + if (*format == '%') { + if (ic == '%') { + format++; + continue; + } + else break; + } + flags = 0; + if (*format == '*') { + ++format; + flags |= FL_NOASSIGN; + } + if (isdigit (*format)) { + flags |= FL_WIDTHSPEC; + for (width = 0; isdigit (*format);) + width = width * 10 + *format++ - '0'; + } + + switch (*format) { + case 'h': flags |= FL_SHORT; format++; break; + case 'l': flags |= FL_LONG; format++; break; + case 'L': flags |= FL_LONGDOUBLE; format++; break; + } + kind = *format; + if ((kind != 'c') && (kind != '[') && (kind != 'n')) { + while (ic != EOF && isspace(ic)) { + ic = getc(stream); + nrchars++; + } + } + switch (kind) { + default: + if (kind == ic) continue; + break; + case 'n': + if (ic != EOF) + ungetc(ic, stream); + nrchars--; + if (flags & FL_SHORT) + *va_arg(ap, short *) = (short) nrchars; + else if (flags & FL_LONG) + *va_arg(ap, long *) = (long) nrchars; + else + *va_arg(ap, int *) = (int) nrchars; + break; + case 'b': /* binary */ + case 'd': /* decimal */ + case 'i': /* general integer */ + case 'o': /* octal */ + case 'p': /* pointer */ + case 'u': /* unsigned */ + case 'x': /* hexadecimal */ + case 'X': /* ditto */ + if (!(flags & FL_WIDTHSPEC)) + width = NUMLEN; + if (!width) return done; + str = o_collect(ic, stream, kind, width, &base); + if (str < inp_buf) return done; + nrchars += str - inp_buf + 1; + if (!(flags & FL_NOASSIGN)) { + if (kind == 'd' || kind == 'i') + val = strtol(inp_buf, &tmp_string, base); + else + val = strtoul(inp_buf, &tmp_string, base); + if (flags & FL_LONG) + *va_arg(ap, unsigned long *) = (unsigned long) val; + else if (flags & FL_SHORT) + *va_arg(ap, unsigned short *) = (unsigned short) val; + else + *va_arg(ap, unsigned *) = (unsigned) val; + done++; + } + break; + case 'c': + if (!(flags & FL_WIDTHSPEC)) + width = 1; + if (!(flags & FL_NOASSIGN)) + tmp_string = va_arg(ap, char *); + if (!width) return done; + if (width && !(flags & FL_NOASSIGN) && (ic != EOF)) + ++done; + while (width && ic != EOF) { + if (!(flags & FL_NOASSIGN)) + *tmp_string++ = (char) ic; + width--; + ic = getc(stream); + nrchars++; + } + + if (ic != EOF) + ungetc(ic,stream); + nrchars--; + break; + + case 's': + if (!(flags & FL_WIDTHSPEC)) + width = 0xffff; + if (!(flags & FL_NOASSIGN)) + tmp_string = va_arg(ap, char *); + if (!width) return done; + if (!(flags & FL_NOASSIGN)) + ++done; + while (width && ic != EOF && !isspace(ic)) { + if (!(flags & FL_NOASSIGN)) + *tmp_string++ = (char) ic; + width--; + ic = getc(stream); + nrchars++; + /* terminate the string */ + if (!(flags & FL_NOASSIGN)) + *tmp_string = '\0'; + } + if (ic != EOF) + ungetc(ic,stream); + nrchars--; + break; + + case '[': + if (!(flags & FL_WIDTHSPEC)) + width = 0xffff; + + if (!width) return done; + if ( *(++format) == '^' ) { + reverse = 1; + format++; + } else + reverse = 0; + + for (tmp_string = Xtable; tmp_string < &Xtable[128] + ; tmp_string++) + *tmp_string = 0; + + if (*format == ']') Xtable[*format++] = 1; + while (*format && *format != ']') { + Xtable[*format++] = 1; + if (*format == '-') { + format++; + if (*format + && *format != ']' + && *(format) >= *(format -2)) { + int c; + + for( c = *(format -2) + 1 + ; c <= *format ; c++) + Xtable[c] = 1; + format++; + } + else Xtable['-'] = 1; + } + } + if (!*format) + return done; + + if (!(flags & FL_NOASSIGN)) + tmp_string = va_arg(ap, char *); + while (width && ic != EOF && (Xtable[ic] ^ reverse)) { + if (!(flags & FL_NOASSIGN)) + *tmp_string++ = (char) ic; + width--; + ic = getc(stream); + nrchars++; + } + if (ic != EOF) + ungetc(ic, stream); + nrchars--; + if (!(flags & FL_NOASSIGN)) { /* terminate string */ + *tmp_string = '\0'; + ++done; + } + break; +#ifndef NOFLOAT: + case 'e': + case 'E': + case 'f': + case 'g': + case 'G': + if (!(flags & FL_WIDTHSPEC)) width = NUMLEN; + if (width > NUMLEN) width = NUMLEN; + + if (!width) return done; + str = f_collect(ic, stream, width); + if (str < inp_buf) return done; + nrchars += str - inp_buf + 1; + if (!(flags & FL_NOASSIGN)) { + d_val = strtod(inp_buf, &tmp_string); +#if EM_DSIZE != EM_LDSIZE + if (flags & FL_LONGDOUBLE) + *va_arg(ap, long double *) = (long double) d_val; + else +#endif /* EM_DSIZE != EM_LDSIZE */ + if (flags & FL_LONG) + *va_arg(ap, double *) = (double) d_val; + else + *va_arg(ap, float *) = (float) d_val; + done++; + } + break; +#endif + } /* end switch */ + ++format; + } +all_done: + if (ic != EOF) + ungetc(ic, stream); + /* nrchars--; just to keep it clean */ +quit: + return done; +} diff --git a/lang/cem/libcc.ansi/stdio/ecvt.c b/lang/cem/libcc.ansi/stdio/ecvt.c new file mode 100644 index 000000000..733ce1850 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/ecvt.c @@ -0,0 +1,196 @@ +/* + * ecvt.c - conversion routines for printing floating point numbers + */ +/* $Header$ */ + +#ifndef NOFLOAT + +static char *cvt(double value, int ndigit, int *decpt, int *sign, int ecvtflag); +#define NDIGITS 128 + +char * +ecvt(double value, int ndigit, int *decpt, int *sign) +{ + return cvt(value, ndigit, decpt, sign, 1); +} + +char * +fcvt(double value, int ndigit, int *decpt, int *sign) +{ + return cvt(value, ndigit, decpt, sign, 0); +} + +static struct powers_of_10 { + double pval; + double rpval; + int exp; +} p10[] = { + 1.0e32, 1.0e-32, 32, + 1.0e16, 1.0e-16, 16, + 1.0e8, 1.0e-8, 8, + 1.0e4, 1.0e-4, 4, + 1.0e2, 1.0e-2, 2, + 1.0e1, 1.0e-1, 1, + 1.0e0, 1.0e0, 0 +}; + +static char * +cvt(double value, int ndigit, int *decpt, int *sign, int ecvtflag) +{ + static char buf[NDIGITS+1]; + register char *p = buf; + register char *pe; + + if (ndigit < 0) ndigit = 0; + if (ndigit > NDIGITS) ndigit = NDIGITS; + pe = &buf[ndigit]; + buf[0] = '\0'; + + *sign = 0; + if (value < 0) { + *sign = 1; + value = -value; + } + + *decpt = 0; + if (value != 0.0) { + register struct powers_of_10 *pp = &p10[0]; + + if (value >= 10.0) do { + while (value >= pp->pval) { + value *= pp->rpval; + *decpt += pp->exp; + } + } while ((++pp)->exp > 0); + + pp = &p10[0]; + if (value < 1.0) do { + while (value * pp->pval < 10.0) { + value *= pp->pval; + *decpt -= pp->exp; + } + } while ((++pp)->exp > 0); + + (*decpt)++; /* because now value in [1.0, 10.0) */ + } + if (!ecvtflag) { + /* for fcvt() we need ndigit digits behind the dot */ + pe += *decpt; + if (pe > &buf[NDIGITS]) pe = &buf[NDIGITS]; + } + while (p <= pe) { + *p++ = (int)value + '0'; + value = 10.0 * (value - (int)value); + } + if (pe >= buf) { + p = pe; + *p += 5; /* round of at the end */ + while (*p > '9') { + *p = '0'; + if (p > buf) ++*--p; + else { + *p = '1'; + ++*decpt; + if (!ecvtflag) { + /* maybe add another digit at the end, + because the point was shifted right + */ + if (pe > buf) *pe = '0'; + pe++; + } + } + } + *pe = '\0'; + } + return buf; +} + +#if EM_DSIZE != EM_LDSIZE + +static char *cvt_ldbl(long double value, int ndigit, int *decpt, + int *sign, int ecvtflag); + +char * +ecvt_ldbl(long double value, int ndigit, int *decpt, int *sign) +{ + return cvt_ldbl(value, ndigit, decpt, sign, 1); +} + +char * +fcvt_ldbl(long double value, int ndigit, int *decpt, int *sign) +{ + return cvt_ldbl(value, ndigit, decpt, sign, 0); +} + +static char * +cvt_ldbl(long double value, int ndigit, int *decpt, int *sign, int ecvtflag) +{ + static char buf[NDIGITS+1]; + register char *p = buf; + register char *pe; + + if (ndigit < 0) ndigit = 0; + if (ndigit > NDIGITS) ndigit = NDIGITS; + pe = &buf[ndigit]; + buf[0] = '\0'; + + *sign = 0; + if (value < 0) { + *sign = 1; + value = -value; + } + + *decpt = 0; + if (value != 0.0) { + register struct powers_of_10 *pp = &p10[0]; + + if (value >= 10.0) do { + while (value >= pp->pval) { + value *= pp->rpval; + *decpt += pp->exp; + } + } while ((++pp)->exp > 0); + + pp = &p10[0]; + if (value < 1.0) do { + while (value * pp->pval < 10.0) { + value *= pp->pval; + *decpt -= pp->exp; + } + } while ((++pp)->exp > 0); + + (*decpt)++; /* because now value in [1.0, 10.0) */ + } + if (!ecvtflag) { + /* for fcvt() we need ndigit digits behind the dot */ + pe += *decpt; + if (pe > &buf[NDIGITS]) pe = &buf[NDIGITS]; + } + while (p <= pe) { + *p++ = (int)value + '0'; + value = 10.0 * (value - (int)value); + } + if (pe >= buf) { + p = pe; + *p += 5; /* round of at the end */ + while (*p > '9') { + *p = '0'; + if (p > buf) ++*--p; + else { + *p = '1'; + ++*decpt; + if (!ecvtflag) { + /* maybe add another digit at the end, + because the point was shifted right + */ + if (pe > buf) *pe = '0'; + pe++; + } + } + } + *pe = '\0'; + } + return buf; +} +#endif /* EM_DSIZE != EM_LDSIZE */ +#endif /* NOFLOAT */ diff --git a/lang/cem/libcc.ansi/stdio/fclose.c b/lang/cem/libcc.ansi/stdio/fclose.c new file mode 100644 index 000000000..bab766a82 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fclose.c @@ -0,0 +1,31 @@ +/* + * fclose.c - flush a stream and close the file + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int close(int d); + +int +fclose(FILE *fp) +{ + register int i, retval = 0; + + for (i=0; i= FOPEN_MAX) + return(EOF); + if (fflush(fp)) retval = EOF; /* ??? */ + if (close(fileno(fp))) retval = EOF; /* ??? */ + if ( io_testflag(fp,_IOMYBUF) && fp->_buf ) + free((void *)fp->_buf); + if (fp != &_stdin && fp != &_stdout && fp != &_stderr) + free((void *)fp); + return(retval); +} diff --git a/lang/cem/libcc.ansi/stdio/feof.c b/lang/cem/libcc.ansi/stdio/feof.c new file mode 100644 index 000000000..79648d944 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/feof.c @@ -0,0 +1,14 @@ +/* + * feof.c - test if eof on a stream occurred + */ +/* $Header$ */ + +#include + +#undef feof + +int +feof(FILE *stream) +{ + return (stream->_flags & _IOEOF) != 0; +} diff --git a/lang/cem/libcc.ansi/stdio/ferror.c b/lang/cem/libcc.ansi/stdio/ferror.c new file mode 100644 index 000000000..4ef976657 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/ferror.c @@ -0,0 +1,14 @@ +/* + * ferror .c - test if an error on a stream occurred + */ +/* $Header$ */ + +#include + +#undef ferror + +int +ferror(FILE *stream) +{ + return (stream->_flags & _IOERR) != 0; +} diff --git a/lang/cem/libcc.ansi/stdio/fflush.c b/lang/cem/libcc.ansi/stdio/fflush.c new file mode 100644 index 000000000..4f6e678fe --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fflush.c @@ -0,0 +1,47 @@ +/* + * fflush.c - flush stream(s) + */ +/* $Header$ */ + +#include +#include "loc_incl.h" + +int write(int d, static char *buf, int nbytes); + +int +fflush(FILE *stream) +{ + int count, c1, i, retval = 0; + + if (!stream) { + for(i= 0; i < FOPEN_MAX; i++) + if (_iotable[i] && fflush(_iotable[i])) + retval = EOF; + return retval; + } + + if (!stream->_buf || + io_testflag(stream,_IONBF) || + !io_testflag(stream,_IOWRITE) ) + return(0); + + if (io_testflag(stream, _IOLBF)) + count = -stream->_count; + else count = stream->_bufsiz - stream->_count; + + if ( count <= 0 ) + return(0); + + c1 = write(stream->_fd, (char *)stream->_buf, count); + + if ( count == c1 ) { + if (io_testflag(stream, _IOLBF)) + stream->_count = 0; + else stream->_count = stream->_bufsiz; + stream->_ptr = stream->_buf; + return(count); + } + + stream->_flags |= _IOERR; + return(EOF); +} diff --git a/lang/cem/libcc.ansi/stdio/fgetc.c b/lang/cem/libcc.ansi/stdio/fgetc.c new file mode 100644 index 000000000..e7a488326 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fgetc.c @@ -0,0 +1,12 @@ +/* + * fgetc - get an unsigned character and return it as an int + */ +/* $Header$ */ + +#include + +int +fgetc(FILE *stream) +{ + return getc(stream); +} diff --git a/lang/cem/libcc.ansi/stdio/fgetpos.c b/lang/cem/libcc.ansi/stdio/fgetpos.c new file mode 100644 index 000000000..fd0802d53 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fgetpos.c @@ -0,0 +1,15 @@ +/* + * fgetpos.c - get the position in the file + */ +/* $Header$ */ + +#include +#include + +int +fgetpos(FILE *stream, fpos_t *pos) +{ + *pos = ftell(stream); + if (*pos == -1) return -1; + return 0; +} diff --git a/lang/cem/libcc.ansi/stdio/fgets.c b/lang/cem/libcc.ansi/stdio/fgets.c new file mode 100644 index 000000000..ad49f5353 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fgets.c @@ -0,0 +1,24 @@ +/* + * fgets.c - get a string from a file + */ +/* $Header$ */ + +#include + +char * +fgets(char *s, int n, FILE *stream) +{ + register int ch; + register char *ptr; + + ptr = s; + while (--n > 0 && (ch = getc(stream)) != EOF) { + *ptr++ = ch; + if ( ch == '\n') + break; + } + if (ch == EOF && ptr==s) + return(NULL); + *ptr = '\0'; + return(s); +} diff --git a/lang/cem/libcc.ansi/stdio/fillbuf.c b/lang/cem/libcc.ansi/stdio/fillbuf.c new file mode 100644 index 000000000..9b4a5d1a0 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fillbuf.c @@ -0,0 +1,54 @@ +/* + * fillbuf.c - fill a buffer + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int read(int d, char *buf, int nbytes); + +int +_fillbuf(register FILE *stream) +{ + static unsigned char ch[FOPEN_MAX]; + + stream->_count = 0; + if (fileno(stream) < 0) return EOF; + if (io_testflag(stream, (_IOEOF | _IOERR ))) + return (EOF); + + if (!io_testflag(stream, _IOREAD) ) + return (EOF); + + if (!io_testflag(stream, _IONBF) && !stream->_buf) { + stream->_buf = (unsigned char *) malloc(BUFSIZ); + if (!stream->_buf) { + stream->_flags |= _IONBF; + } + else { + stream->_flags |= _IOMYBUF; + stream->_bufsiz = BUFSIZ; + } + } + if (!stream->_buf) { + stream->_buf = &ch[fileno(stream)]; + stream->_bufsiz = 1; + } + stream->_ptr = stream->_buf; + stream->_count = read(stream->_fd, (char *)stream->_buf, stream->_bufsiz); + + if (stream->_count <= 0){ + if (stream->_count == 0) { + stream->_flags |= _IOEOF; + } + else + stream->_flags |= _IOERR; + + return (EOF); + } + stream->_count--; + + return *stream->_ptr++; +} diff --git a/lang/cem/libcc.ansi/stdio/fltpr.c b/lang/cem/libcc.ansi/stdio/fltpr.c new file mode 100644 index 000000000..f56ab8713 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fltpr.c @@ -0,0 +1,148 @@ +/* + * floatpr.c - print floating point numbers + */ +/* $Header$ */ + +#ifndef NOFLOAT +#include "loc_incl.h" + +char * +_pfloat(double r, register char *s, int n, int flags) +{ + register char *s1; + int sign, dp; + register int i; + + s1 = fcvt(r, n, &dp, &sign); + if (sign) + *s++ = '-'; + else if (flags & FL_SIGN) + *s++ = '+'; + else if (flags & FL_SPACE) + *s++ = ' '; + + if (dp<=0) + *s++ = '0'; + for (i=dp; i>0; i--) + if (*s1) *s++ = *s1++; + else *s++ = '0'; + if (((i=n) > 0) || (flags & FL_ALT)) + *s++ = '.'; + while (++dp <= 0) { + if (--i<0) + break; + *s++ = '0'; + } + while (--i >= 0) + if (*s1) *s++ = *s1++; + else *s++ = '0'; + return(s); +} + +char * +_pscien(double r, register char *s, int n, int flags) +{ + int sign, dp; + register char *s1; + + s1 = ecvt(r, n + 1, &dp, &sign); + if (sign) + *s++ = '-'; + else if (flags & FL_SIGN) + *s++ = '+'; + else if (flags & FL_SPACE) + *s++ = ' '; + + *s++ = *s1++; + if ((n > 0) || (flags & FL_ALT)) + *s++ = '.'; + while (--n>0) + if (*s1) *s++ = *s1++; + else *s++ = '0'; + *s++ = 'e'; + if ( r != 0 ) --dp ; + if ( dp<0 ) { + *s++ = '-' ; dp= -dp ; + } else { + *s++ = '+' ; + } + if (dp >= 100) { + *s++ = '0' + (dp / 100); + dp %= 100; + } + *s++ = '0' + (dp/10); + *s++ = '0' + (dp%10); + return(s); +} + +#if EM_DSIZE != EM_LDSIZE +char * +_pfloat_ldbl(long double r, register char *s, int n, int flags) +{ + register char *s1; + int sign, dp; + register int i; + + s1 = fcvt(r, n, &dp, &sign); + if (sign) + *s++ = '-'; + else if (flags & FL_SIGN) + *s++ = '+'; + else if (flags & FL_SPACE) + *s++ = ' '; + + if (dp<=0) + *s++ = '0'; + for (i=dp; i>0; i--) + if (*s1) *s++ = *s1++; + else *s++ = '0'; + if (((i=n) > 0) || (flags & FL_ALT)) + *s++ = '.'; + while (++dp <= 0) { + if (--i<0) + break; + *s++ = '0'; + } + while (--i >= 0) + if (*s1) *s++ = *s1++; + else *s++ = '0'; + return(s); +} + +char * +_pscien_ldbl(long double r, register char *s, int n, int flags) +{ + int sign, dp; + register char *s1; + + s1 = ecvt(r, n + 1, &dp, &sign); + if (sign) + *s++ = '-'; + else if (flags & FL_SIGN) + *s++ = '+'; + else if (flags & FL_SPACE) + *s++ = ' '; + + *s++ = *s1++; + if ((n > 0) || (flags & FL_ALT)) + *s++ = '.'; + while (--n>0) + if (*s1) *s++ = *s1++; + else *s++ = '0'; + *s++ = 'e'; + if ( r != 0 ) --dp ; + if ( dp<0 ) { + *s++ = '-' ; dp= -dp ; + } else { + *s++ = '+' ; + } + if (dp >= 100) { + *s++ = '0' + (dp / 100); + dp %= 100; + } + *s++ = '0' + (dp/10); + *s++ = '0' + (dp%10); + return(s); +} +#endif /* EM_DSIZE != EM_LDSIZE */ +#endif /* NOFLOAT */ diff --git a/lang/cem/libcc.ansi/stdio/flushbuf.c b/lang/cem/libcc.ansi/stdio/flushbuf.c new file mode 100644 index 000000000..0dbd98e93 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/flushbuf.c @@ -0,0 +1,96 @@ +/* + * flushbuf.c - flush a buffer + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int write(int d, const char *buf, int nbytes); +int isatty(int d); + +int +_flushbuf(int c, FILE * stream) +{ + if (fileno(stream) < 0) return EOF; + if (!io_testflag(stream, _IONBF)) { + if (!stream->_buf) { + if (stream == stdout && isatty(fileno(stdout))) { + if (!(stream->_buf = + (unsigned char *) malloc(BUFSIZ))) { + stream->_flags |= _IONBF; + } + else { + stream->_flags |= _IOLBF; + stream->_bufsiz = BUFSIZ; + stream->_count = -1; + } + } + else { + if (!(stream->_buf = + (unsigned char *) malloc(BUFSIZ))) { + stream->_flags |= _IONBF; + } + else { + stream->_flags |= _IOMYBUF; + stream->_bufsiz = BUFSIZ; + stream->_count = BUFSIZ - 1; + } + } + stream->_ptr = stream->_buf; + } + } + + if (io_testflag(stream, _IONBF)) { + char c1 = c; + + stream->_count = 0; + if (write(fileno(stream), &c1, 1) != 1) { + stream->_flags |= _IOERR; + return EOF; + } + return c; + } + else if (io_testflag(stream, _IOLBF)) { + *stream->_ptr++ = c; + if (c == '\n' || stream->_count == -stream->_bufsiz) { + if (write(fileno(stream), (char *)stream->_buf, + -stream->_count) != -stream->_count) { + stream->_flags |= _IOERR; + return EOF; + } + else { + stream->_ptr = stream->_buf; + stream->_count = 0; + } + } + } + else { + int count = stream->_ptr - stream->_buf; + + stream->_count = stream->_bufsiz - 1; + stream->_ptr = stream->_buf + 1; + + if (count > 0) { + if (write(fileno(stream), (char *)stream->_buf, count) + != count) { + *(stream->_buf) = c; + stream->_flags |= _IOERR; + return EOF; + } + } + *(stream->_buf) = c; + } + return c; +} + +void +_cleanup(void) /* fflush((FILE *)NULL) ??? */ +{ + register int i; + + for( i = 0; i < FOPEN_MAX; i++ ) + if (_iotable[i]) + fclose(_iotable[i]); +} diff --git a/lang/cem/libcc.ansi/stdio/fopen.c b/lang/cem/libcc.ansi/stdio/fopen.c new file mode 100644 index 000000000..8292c53c7 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fopen.c @@ -0,0 +1,83 @@ +/* + * fopen.c - open a stream + */ +/* $Header$ */ + +#include +#include +#include +#include "loc_incl.h" + +#define PMODE 0666 + +int open(const char *path, int flags, int mode); +int close(int d); + +FILE * +fopen(const char *name, const char *mode) +{ + register int i; + int rwmode = 0, rwflags = 0; + FILE *stream; + int fd, flags = 0; + + for (i = 0; _iotable[i] != 0 ; i++) + if ( i >= FOPEN_MAX ) + return (FILE *)NULL; + + switch(*mode++) { + + case 'r': + flags |= _IOREAD; + rwmode = O_RDONLY; + break; + + case 'w': + flags |= _IOWRITE; + rwmode = O_WRONLY; + rwflags = O_CREAT | O_TRUNC; + break; + + case 'a': + flags |= _IOWRITE; + rwmode = O_WRONLY; + rwflags |= O_APPEND | O_CREAT; + break; + + default: + return (FILE *)NULL; + } + + while (*mode) { + switch(*mode++) { + + case 'b': + break; + + case '+': + rwmode = O_RDWR; + flags |= _IOREAD | _IOWRITE; + break; + + default: + return (FILE *)NULL; + + } + } + + fd = open(name, rwmode | rwflags, PMODE); + + if (fd < 0) return (FILE *)NULL; + + if (( stream = (FILE *) malloc(sizeof(FILE))) == NULL ) { + close(fd); + return (FILE *)NULL; + } + + stream->_count = 0; + stream->_fd = fd; + stream->_flags = flags; + stream->_buf = 0; + _iotable[i] = stream; + return stream; +} diff --git a/lang/cem/libcc.ansi/stdio/fprintf.c b/lang/cem/libcc.ansi/stdio/fprintf.c new file mode 100644 index 000000000..3416bd7fd --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fprintf.c @@ -0,0 +1,25 @@ +/* + * fprintf - write output on a stream + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int +fprintf(FILE *stream, const char *format, ...) +{ + va_list ap; + int retval; + + va_start(ap, format); + + retval = _doprnt (format, ap, stream); + if ( io_testflag(stream,_IOLBF) ) + fflush(stream); + + va_end(ap); + + return retval; +} diff --git a/lang/cem/libcc.ansi/stdio/fputc.c b/lang/cem/libcc.ansi/stdio/fputc.c new file mode 100644 index 000000000..ec759144c --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fputc.c @@ -0,0 +1,12 @@ +/* + * fputc.c - print an unsigned character + */ +/* $Header$ */ + +#include + +int +fputc(int c, FILE *stream) +{ + return putc(c, stream); +} diff --git a/lang/cem/libcc.ansi/stdio/fputs.c b/lang/cem/libcc.ansi/stdio/fputs.c new file mode 100644 index 000000000..c45345fca --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fputs.c @@ -0,0 +1,18 @@ +/* + * fputs - print a string + */ +/* $Header$ */ + +#include + +int +fputs(register const char *s, register FILE *stream) +{ + register int retval = 0; + + while (*s) + if (putc(*s++, stream) == EOF) return -1; + else retval++; + + return retval; +} diff --git a/lang/cem/libcc.ansi/stdio/fread.c b/lang/cem/libcc.ansi/stdio/fread.c new file mode 100644 index 000000000..095fe7bbe --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fread.c @@ -0,0 +1,27 @@ +/* + * fread.c - read a number of members into an array + */ +/* $Header$ */ + +#include + +size_t +fread(register void *ptr, size_t size, size_t nmemb, FILE *stream) +{ + int c; + size_t ndone = 0, s; + + if (size) + while ( ndone < nmemb ) { + s = size; + do { + if ((c = getc(stream)) != EOF) + *ptr++ = c; + else + return ndone; + } while (--s); + ndone++; + } + + return ndone; +} diff --git a/lang/cem/libcc.ansi/stdio/freopen.c b/lang/cem/libcc.ansi/stdio/freopen.c new file mode 100644 index 000000000..ca1b11829 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/freopen.c @@ -0,0 +1,88 @@ +/* + * freopen.c - open a file and associate a stream with it + */ +/* $Header$ */ + +#include +#include +#include +#include "loc_incl.h" + +#define PMODE 0666 +int open(const char *path, int flags, int mode); +int close(int d); + +FILE * +freopen(const char *name, const char *mode, FILE *stream) +{ + register int i; + int rwmode = 0, rwflags = 0; + int fd, flags = stream->_flags & ~(_IOWRITE|_IOREAD|_IOERR|_IOEOF); + + (void) fflush(stream); /* ignore errors */ + (void) close(fileno(stream)); + + switch(*mode++) { + + case 'r': + flags |= _IOREAD; + rwmode = O_RDONLY; + break; + + case 'w': + flags |= _IOWRITE; + rwmode = O_WRONLY; + rwflags = O_CREAT | O_TRUNC; + break; + + case 'a': + flags |= _IOWRITE; + rwmode = O_WRONLY; + rwflags |= O_APPEND | O_CREAT; + break; + + default: + return (FILE *)NULL; + } + + while (*mode) { + switch(*mode++) { + + case 'b': + break; + + case '+': + rwmode = O_RDWR; + flags |= _IOREAD | _IOWRITE; + break; + + default: + return (FILE *)NULL; + + } + } + + fd = open(name, rwmode | rwflags, PMODE); + + if (fd < 0) { + for( i = 0; i < FOPEN_MAX; i++) { + if (stream == _iotable[i]) { + _iotable[i] = 0; + break; + } + } + if (stream != stdin && stream != stdout && stream != stderr) + free((void *)stream); + return (FILE *)NULL; + } + + stream->_count = 0; + if (stream->_buf && !(flags & _IONBF) && (flags & _IOWRITE)) + if (flags & _IOLBF) + stream->_count = 0; + else stream->_count = stream->_bufsiz; + + stream->_fd = fd; + stream->_flags = flags; + return(stream); +} diff --git a/lang/cem/libcc.ansi/stdio/fscanf.c b/lang/cem/libcc.ansi/stdio/fscanf.c new file mode 100644 index 000000000..913a47071 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fscanf.c @@ -0,0 +1,23 @@ +/* + * fscanf.c - read formatted input from stream + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int +fscanf(FILE *stream, const char *format, ...) +{ + va_list ap; + int retval; + + va_start(ap, format); + + retval = _doscan(stream, format, ap); + + va_end(ap); + + return retval; +} diff --git a/lang/cem/libcc.ansi/stdio/fseek.c b/lang/cem/libcc.ansi/stdio/fseek.c new file mode 100644 index 000000000..18be8e726 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fseek.c @@ -0,0 +1,60 @@ +/* + * fseek.c - perform an fseek + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int lseek(int d, int offset, int whence); + +int +fseek(FILE *stream, long int offset, int whence) +{ + int count; + long pos; + +#if (SEEK_CUR != L_INCR) || (SEEK_SET != L_SET) || (SEEK_END != L_XTND) + int swhence; /* the real whence for lseek */ + + switch(whence) { /* map to UNIX values */ + case SEEK_CUR: swhence = L_INCR; break; + case SEEK_SET: swhence = L_SET; break; + case SEEK_END: swhence = L_XTND; break; + default: swhence = whence; break; + } +#else +#define swhence whence +#endif + + stream->_flags &= ~(_IOEOF | _IOERR); + /* Clear both the end of file and error flags */ + + if ( io_testflag(stream,_IOREAD) ) { + if ( whence < 2 && stream->_buf + && !io_testflag(stream,_IONBF) ) { + count = stream->_count; + pos = offset; + + if ( whence == SEEK_SET ) + pos += + count - lseek(fileno(stream), 0L, swhence); + else + offset -= count; + + if ( count > 0 && pos <= count + && pos >= stream->_buf - stream->_ptr ) { + stream->_ptr += (int) pos; + stream->_count -= (int) pos; + return(0); + } + } + pos = lseek(fileno(stream), offset, swhence); + stream->_count = 0; + } else if ( io_testflag(stream,_IOWRITE) ) { + fflush(stream); + pos = lseek(fileno(stream), offset, swhence); + } + return((pos == -1) ? -1 : 0 ); +} diff --git a/lang/cem/libcc.ansi/stdio/fsetpos.c b/lang/cem/libcc.ansi/stdio/fsetpos.c new file mode 100644 index 000000000..ef67ad05f --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fsetpos.c @@ -0,0 +1,12 @@ +/* + * fsetpos.c - set the position in the file + */ +/* $Header$ */ + +#include + +int +fsetpos(FILE *stream, fpos_t *pos) +{ + return fseek(stream, *pos, SEEK_SET); +} diff --git a/lang/cem/libcc.ansi/stdio/ftell.c b/lang/cem/libcc.ansi/stdio/ftell.c new file mode 100644 index 000000000..19f820b51 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/ftell.c @@ -0,0 +1,33 @@ +/* + * ftell.c - obtain the value of the file-position indicator of a stream + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int lseek(int d, int offset, int whence); + +long ftell(FILE * stream) +{ + long result; + int adjust; + + if ( io_testflag(stream,_IOREAD) ) + adjust = -stream->_count; + else if (io_testflag(stream,_IOWRITE) + && stream->_buf + && !io_testflag(stream,_IONBF)) + adjust = stream->_ptr - stream->_buf; + else + return -1L; + + result = lseek(fileno(stream), 0, L_INCR); + + if ( result == -1 ) + return result; + + result += (long) adjust; + return result; +} diff --git a/lang/cem/libcc.ansi/stdio/fwrite.c b/lang/cem/libcc.ansi/stdio/fwrite.c new file mode 100644 index 000000000..690148782 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/fwrite.c @@ -0,0 +1,28 @@ +/* + * fwrite.c - write a number of array elements on a file + */ +/* $Header$ */ + +#include + +size_t +fwrite(register const void *ptr, size_t size, size_t nmemb, + register FILE *stream) +{ + unsigned s; + unsigned ndone = 0; + + if (size) + while ( ndone < nmemb ) { + s = size; + do { + if (putc((int)*(unsigned char *)ptr, stream) + == EOF) + return(ndone); + ptr++; + } + while (--s); + ndone++; + } + return(ndone); +} diff --git a/lang/cem/libcc.ansi/stdio/gcvt.c b/lang/cem/libcc.ansi/stdio/gcvt.c new file mode 100644 index 000000000..a25f82f4e --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/gcvt.c @@ -0,0 +1,144 @@ +/* + * gcvt.c - conversion for printing a floating point number + */ +/* $Header$ */ + +#ifndef NOFLOAT +#include "loc_incl.h" + +#define NDIGINEXP(exp) (((exp) >= 100 || (exp) <= -100) ? 3 : 2) +#define LOW_EXP -4 +#define USE_EXP(exp, ndigits) (((exp) < LOW_EXP + 1) || (exp >= ndigits + 1)) + +char * +gcvt(double value, int ndigit, char *s, int flags) +{ + int sign, dp; + register char *s1, *s2; + register int i; + register int nndigit = ndigit; + + s1 = ecvt(value, ndigit, &dp, &sign); + s2 = s; + if (sign) *s2++ = '-'; + else if (flags & FL_SIGN) + *s2++ = '+'; + else if (flags & FL_SPACE) + *s2++ = ' '; + + if (!(flags & FL_ALT)) + for (i = nndigit - 1; i > 0 && s1[i] == '0'; i--) + nndigit--; + + if (USE_EXP(dp,ndigit)) { + /* Use E format */ + dp--; + *s2++ = *s1++; + if ((nndigit > 1) || (flags & FL_ALT)) *s2++ = '.'; + while (--nndigit > 0) *s2++ = *s1++; + *s2++ = 'e'; + if (dp < 0) { + *s2++ = '-'; + dp = -dp; + } + else *s2++ = '+'; + s2 += NDIGINEXP(dp); + *s2 = 0; + for (i = NDIGINEXP(dp); i > 0; i--) { + *--s2 = dp % 10 + '0'; + dp /= 10; + } + return s; + } + /* Use f format */ + if (dp <= 0) { + if (*s1 != '0') { + /* otherwise the whole number is 0 */ + *s2++ = '0'; + *s2++ = '.'; + } + while (dp < 0) { + dp++; + *s2++ = '0'; + } + } + for (i = 1; i <= nndigit; i++) { + *s2++ = *s1++; + if (i == dp) *s2++ = '.'; + } + if (i <= dp) { + while (i++ <= dp) *s2++ = '0'; + *s2++ = '.'; + } + if ((s2[-1]=='.') && !(flags & FL_ALT)) s2--; + *s2 = '\0'; + return s; +} + +#if EM_DSIZE != EM_LDSIZE +char * +gcvt_ldbl(long double value, int ndigit, char *s, int flags) +{ + int sign, dp; + register char *s1, *s2; + register int i; + register int nndigit = ndigit; + + s1 = ecvt_ldbl(value, ndigit, &dp, &sign); + s2 = s; + if (sign) *s2++ = '-'; + else if (flags & FL_SIGN) + *s2++ = '+'; + else if (flags & FL_SPACE) + *s2++ = ' '; + + if (!(flags & FL_ALT)) + for (i = nndigit - 1; i > 0 && s1[i] == '0'; i--) + nndigit--; + + if (USE_EXP(dp,ndigit)) { + /* Use E format */ + dp--; + *s2++ = *s1++; + if ((nndigit > 1) || (flags & FL_ALT)) *s2++ = '.'; + while (--nndigit > 0) *s2++ = *s1++; + *s2++ = 'e'; + if (dp < 0) { + *s2++ = '-'; + dp = -dp; + } + else *s2++ = '+'; + s2 += NDIGINEXP(dp); + *s2 = 0; + for (i = NDIGINEXP(dp); i > 0; i--) { + *--s2 = dp % 10 + '0'; + dp /= 10; + } + return s; + } + /* Use f format */ + if (dp <= 0) { + if (*s1 != '0') { + /* otherwise the whole number is 0 */ + *s2++ = '0'; + *s2++ = '.'; + } + while (dp < 0) { + dp++; + *s2++ = '0'; + } + } + for (i = 1; i <= nndigit; i++) { + *s2++ = *s1++; + if (i == dp) *s2++ = '.'; + } + if (i <= dp) { + while (i++ <= dp) *s2++ = '0'; + *s2++ = '.'; + } + if ((s2[-1]=='.') && !(flags & FL_ALT)) s2--; + *s2 = '\0'; + return s; +} +#endif /* EM_DSIZE != EM_LDSIZE */ +#endif /* NOFLOAT */ diff --git a/lang/cem/libcc.ansi/stdio/getc.c b/lang/cem/libcc.ansi/stdio/getc.c new file mode 100644 index 000000000..ac0e8320e --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/getc.c @@ -0,0 +1,14 @@ +/* + * getc.c - read an unsigned character + */ +/* $Header$ */ + +#include + +#undef getc + +int +getc(FILE *stream) +{ + return fgetc(stream); +} diff --git a/lang/cem/libcc.ansi/stdio/getchar.c b/lang/cem/libcc.ansi/stdio/getchar.c new file mode 100644 index 000000000..be66cd914 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/getchar.c @@ -0,0 +1,14 @@ +/* + * getchar.c - read a character from the standard input stream + */ +/* $Header$ */ + +#include + +#undef getchar + +int +getchar(void) +{ + return getc(stdin); +} diff --git a/lang/cem/libcc.ansi/stdio/gets.c b/lang/cem/libcc.ansi/stdio/gets.c new file mode 100644 index 000000000..ebf6aac2e --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/gets.c @@ -0,0 +1,23 @@ +/* + * gets.c - read a line from a stream + */ +/* $Header$ */ + +#include + +char * +gets(char *s) +{ + register int ch; + register char *ptr; + + ptr = s; + while ((ch = getc(stdin)) != EOF && ch != '\n') + *ptr++ = ch; + + if (ch == EOF && ptr==s) + return (char *)NULL; + + *ptr = '\0'; + return s; +} diff --git a/lang/cem/libcc.ansi/stdio/loc_incl.h b/lang/cem/libcc.ansi/stdio/loc_incl.h new file mode 100644 index 000000000..38fad4591 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/loc_incl.h @@ -0,0 +1,50 @@ +/* + * loc_incl.h - local include file for stdio library + */ +/* $Header$ */ + +#include + +#define fileno(p) ((p)->_fd) +#define io_testflag(p,x) ((p)->_flags & (x)) + +#include +int _doprnt(const char *format, va_list ap, FILE *stream); +int _doscan(FILE * stream, const char *format, va_list ap); +char *i_compute(unsigned long val, int base, char *s, int nrdigits); + +#ifndef NOFLOAT +char *_pfloat(double r, register char *s, int n, int flags); +char *_pscien(double r, register char *s, int n, int flags); +char *ecvt(double value, int ndigit, int *decpt, int *sign); +char *fcvt(double value, int ndigit, int *decpt, int *sign); +char *gcvt(double value, int ndigit, char *buf, int flags); + +/* + * When the sizes of doubles and long doubles are equal, the formats must + * be equal (since a backend only knows the size of a floating-point + * number). This means that the special routines for long doubles are not + * necessary. + */ +#if EM_DSIZE != EM_LDSIZE +char *_pfloat_ldbl(long double r, register char *s, int n, int flags); +char *_pscien_ldbl(long double r, register char *s, int n, int flags); +char *ecvt_ldbl(long double value, int ndigit, int *decpt, int *sign); +char *fcvt_ldbl(long double value, int ndigit, int *decpt, int *sign); +char *gcvt_ldbl(long double value, int ndigit, char *s, int flags); +#endif /* EM_DSIZE != EM_LDSIZE */ +#endif /* NOFLOAT */ + +#define FL_LJUST 0x0001 /* left-justify field */ +#define FL_SIGN 0x0002 /* sign in signed conversions */ +#define FL_SPACE 0x0004 /* space in signed conversions */ +#define FL_ALT 0x0008 /* alternate form */ +#define FL_ZEROFILL 0x0010 /* fill with zero's */ +#define FL_SHORT 0x0020 /* optional h */ +#define FL_LONG 0x0040 /* optional l */ +#define FL_LONGDOUBLE 0x0080 /* optional L */ +#define FL_WIDTHSPEC 0x0100 /* field width is specified */ +#define FL_PRECSPEC 0x0200 /* precision is specified */ +#define FL_SIGNEDCONV 0x0400 /* may contain a sign */ +#define FL_NOASSIGN 0x0800 /* do not assign (in scanf) */ +#define FL_NOMORE 0x1000 /* all flags collected */ diff --git a/lang/cem/libcc.ansi/stdio/perror.c b/lang/cem/libcc.ansi/stdio/perror.c new file mode 100644 index 000000000..70055e6fb --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/perror.c @@ -0,0 +1,16 @@ +/* + * perror.c - print an error message on the standard error output + */ +/* $Header$ */ + +#include +#include +#include + +void +perror(const char *s) +{ + if (s && *s) + (void) fprintf(stderr,"%s: ", s); + (void) fprintf(stderr,"%s\n", strerror(errno)); +} diff --git a/lang/cem/libcc.ansi/stdio/printf.c b/lang/cem/libcc.ansi/stdio/printf.c new file mode 100644 index 000000000..f1eb45b94 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/printf.c @@ -0,0 +1,25 @@ +/* + * printf - write on the standard output stream + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int +printf(const char *format, ...) +{ + va_list ap; + int retval; + + va_start(ap, format); + + retval = _doprnt(format, ap, stdout); + if (io_testflag(stdout,_IOLBF)) + fflush(stdout); + + va_end(ap); + + return retval; +} diff --git a/lang/cem/libcc.ansi/stdio/putc.c b/lang/cem/libcc.ansi/stdio/putc.c new file mode 100644 index 000000000..4204a5deb --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/putc.c @@ -0,0 +1,14 @@ +/* + * putc.c - print (or buffer) one character + */ +/* $Header$ */ + +#include + +#undef putc + +int +putc(int c, FILE *stream) +{ + return fputc(c, stream); +} diff --git a/lang/cem/libcc.ansi/stdio/putchar.c b/lang/cem/libcc.ansi/stdio/putchar.c new file mode 100644 index 000000000..1b483db09 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/putchar.c @@ -0,0 +1,14 @@ +/* + * putchar.c - print (or buffer) a character on the standard output stream + */ +/* $Header$ */ + +#include + +#undef putchar + +int +putchar(int c) +{ + return putc(c, stdout); +} diff --git a/lang/cem/libcc.ansi/stdio/puts.c b/lang/cem/libcc.ansi/stdio/puts.c new file mode 100644 index 000000000..a5830a4f6 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/puts.c @@ -0,0 +1,12 @@ +/* + * puts.c - print a string onto the standard output stream + */ +/* $Header$ */ + +#include + +int +puts(register const char *s) +{ + return fputs(s, stdout); +} diff --git a/lang/cem/libcc.ansi/stdio/remove.c b/lang/cem/libcc.ansi/stdio/remove.c new file mode 100644 index 000000000..3c05d8623 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/remove.c @@ -0,0 +1,13 @@ +/* + * remove.c - remove a file + */ +/* $Header$ */ + +#include + +int unlink(const char *path); + +int +remove(const char *filename) { + return unlink(filename); +} diff --git a/lang/cem/libcc.ansi/stdio/rename.c b/lang/cem/libcc.ansi/stdio/rename.c new file mode 100644 index 000000000..649bf45fa --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/rename.c @@ -0,0 +1,16 @@ +/* + * rename.c - rename a file + */ +/* $Header$ */ + +#include + +int link(const char *name1, const char *name2); +int unlink(const char *path); + +int +rename(const char *old, const char *new) { + if (!link(old, new)) + return remove(old); + else return -1; +} diff --git a/lang/cem/libcc.ansi/stdio/rewind.c b/lang/cem/libcc.ansi/stdio/rewind.c new file mode 100644 index 000000000..5b835881b --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/rewind.c @@ -0,0 +1,14 @@ +/* + * rewind.c - set the file position indicator of a stream to the start + */ +/* $Header$ */ + +#include +#include "loc_incl.h" + +void +rewind(FILE *stream) +{ + (void) fseek(stream, 0L, SEEK_SET); + clearerr(stream); +} diff --git a/lang/cem/libcc.ansi/stdio/scanf.c b/lang/cem/libcc.ansi/stdio/scanf.c new file mode 100644 index 000000000..1485d703a --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/scanf.c @@ -0,0 +1,25 @@ +/* + * scanf.c - read formatted input from the standard input stream + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int +scanf(const char *format, ...) +{ + va_list ap; + int retval; + + va_start(ap, format); + + retval = _doscan(stdin, format, ap); + + va_end(ap); + + return retval; +} + + diff --git a/lang/cem/libcc.ansi/stdio/setbuf.c b/lang/cem/libcc.ansi/stdio/setbuf.c new file mode 100644 index 000000000..4c2cf7b2c --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/setbuf.c @@ -0,0 +1,18 @@ +/* + * setbuf.c - control buffering of a stream + */ +/* $Header$ */ + +#include +#include "loc_incl.h" + +void +setbuf(register FILE *stream, char *buf) +{ + int mode; + + if (buf) mode = _IOFBF; + else mode = _IONBF; + + (void) setvbuf(stream, buf, mode, (size_t) BUFSIZ); +} diff --git a/lang/cem/libcc.ansi/stdio/setvbuf.c b/lang/cem/libcc.ansi/stdio/setvbuf.c new file mode 100644 index 000000000..d593cf94f --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/setvbuf.c @@ -0,0 +1,42 @@ +/* + * setbuf.c - control buffering of a stream + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int +setvbuf(register FILE *stream, char *buf, int mode, size_t size) +{ + int retval = 0; + + if (mode != _IOFBF && mode != _IOLBF && mode != _IONBF) + return EOF; + + if ( stream->_buf && io_testflag(stream,_IOMYBUF) ) + free((void *)stream->_buf); + + stream->_flags &= ~(_IOMYBUF | _IONBF | _IOLBF); + + if (!buf && (mode != _IONBF)) + if ((buf = (char *) malloc(size)) == NULL) retval = -1; + + stream->_buf = (unsigned char *) buf; + + stream->_count = 0; + stream->_flags |= mode; + stream->_ptr = stream->_buf; + + if (!buf) { + stream->_bufsiz = 1; + } else { + if (io_testflag(stream, _IOWRITE) + && !io_testflag(stream, _IOLBF)) + stream->_count = size; + stream->_bufsiz = size; + } + + return retval; +} diff --git a/lang/cem/libcc.ansi/stdio/sprintf.c b/lang/cem/libcc.ansi/stdio/sprintf.c new file mode 100644 index 000000000..08e54f6eb --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/sprintf.c @@ -0,0 +1,31 @@ +/* + * sprintf - print formatted output on an array + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int +sprintf(char * s, const char *format, ...) +{ + va_list ap; + int retval; + FILE tmp_stream; + + va_start(ap, format); + + tmp_stream._fd = -1; + tmp_stream._flags = _IOWRITE + _IONBF; + tmp_stream._buf = (unsigned char *) s; + tmp_stream._ptr = (unsigned char *) s; + tmp_stream._count = 32767; + + retval = _doprnt(format, ap, &tmp_stream); + putc('\0',&tmp_stream); + + va_end(ap); + + return retval; +} diff --git a/lang/cem/libcc.ansi/stdio/sscanf.c b/lang/cem/libcc.ansi/stdio/sscanf.c new file mode 100644 index 000000000..acff7c16f --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/sscanf.c @@ -0,0 +1,29 @@ +/* + * sscanf - read formatted output from a string + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int sscanf(const char *s, const char *format, ...) +{ + va_list ap; + int retval; + FILE tmp_stream; + + va_start(ap, format); + + tmp_stream._fd = -1; + tmp_stream._flags = _IOREAD + _IONBF; + tmp_stream._buf = (unsigned char *) s; + tmp_stream._ptr = (unsigned char *) s; + tmp_stream._count = 32767; + + retval = _doscan(&tmp_stream, format, ap); + + va_end(ap); + + return retval; +} diff --git a/lang/cem/libcc.ansi/stdio/tmpfile.c b/lang/cem/libcc.ansi/stdio/tmpfile.c new file mode 100644 index 000000000..58032d4a9 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/tmpfile.c @@ -0,0 +1,29 @@ +/* + * tmpfile.c - create and open a temporary file + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +unsigned int getpid(void); + +FILE * +tmpfile(void) { + static char name_buffer[L_tmpnam] = "/tmp/tmp." ; + static char *name = NULL; + FILE *file; + + if (!name) { + name = name_buffer + strlen(name_buffer); + i_compute(getpid(), 10, name, 5); + name += strlen(name); + *name++ = '\0'; + } + + file = fopen(name_buffer,"wb+"); + if (!file) return (FILE *)NULL; + if (remove(name_buffer)) return (FILE *)NULL; + return file; +} diff --git a/lang/cem/libcc.ansi/stdio/tmpnam.c b/lang/cem/libcc.ansi/stdio/tmpnam.c new file mode 100644 index 000000000..8f435e308 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/tmpnam.c @@ -0,0 +1,28 @@ +/* + * tmpnam.c - create a unique filename + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +unsigned int getpid(void); + +char * +tmpnam(char *s) { + static char name_buffer[L_tmpnam] = "/tmp/tmp."; + static unsigned long count = 0; + static char *name = NULL; + + if (!name) { + name = name_buffer + strlen(name_buffer); + name = i_compute(getpid(), 10, name, 5); + *name++ = '.'; + *name++ = '\0'; + } + if (++count > TMP_MAX) count = 1; /* wrap-around */ + *i_compute(count, 10, name, 3) = '\0'; + if (s) return strcpy(s, name_buffer); + else return name_buffer; +} diff --git a/lang/cem/libcc.ansi/stdio/ungetc.c b/lang/cem/libcc.ansi/stdio/ungetc.c new file mode 100644 index 000000000..5cabddbab --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/ungetc.c @@ -0,0 +1,24 @@ +/* + * ungetc.c - push a character back onto an imput stream + */ +/* $Header$ */ + +#include +#include "loc_incl.h" + +int +ungetc(int ch, FILE *stream) +{ + unsigned char *p; + + if (ch == EOF || !io_testflag(stream,_IOREAD)) + return EOF; + if (stream->_ptr == stream->_buf) { + if (stream->_count != 0) return EOF; + stream->_ptr++; + } + stream->_count++; + p = --(stream->_ptr); /* ??? Bloody vax assembler !!! */ + *p = (unsigned char) ch; + return ch; +} diff --git a/lang/cem/libcc.ansi/stdio/vfprintf.c b/lang/cem/libcc.ansi/stdio/vfprintf.c new file mode 100644 index 000000000..36eb40113 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/vfprintf.c @@ -0,0 +1,20 @@ +/* + * vfprintf - formatted output without ellipsis + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int +vfprintf(FILE *stream, const char *format, va_list arg) +{ + int retval; + + retval = _doprnt (format, arg, stream); + if (io_testflag(stream, _IOLBF)) + fflush(stream); + + return retval; +} diff --git a/lang/cem/libcc.ansi/stdio/vprintf.c b/lang/cem/libcc.ansi/stdio/vprintf.c new file mode 100644 index 000000000..99420ab5e --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/vprintf.c @@ -0,0 +1,20 @@ +/* + * vprintf - formatted output without ellipsis to the standard output stream + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int +vprintf(const char *format, va_list arg) +{ + int retval; + + retval = _doprnt(format, arg, stdout); + if (io_testflag(stdout, _IOLBF)) + fflush(stdout); + + return retval; +} diff --git a/lang/cem/libcc.ansi/stdio/vsprintf.c b/lang/cem/libcc.ansi/stdio/vsprintf.c new file mode 100644 index 000000000..3cd5cb184 --- /dev/null +++ b/lang/cem/libcc.ansi/stdio/vsprintf.c @@ -0,0 +1,26 @@ +/* + * vsprintf - print formatted output without ellipsis on an array + */ +/* $Header$ */ + +#include +#include +#include "loc_incl.h" + +int +vsprintf(char *s, const char *format, va_list arg) +{ + int retval; + FILE tmp_stream; + + tmp_stream._fd = -1; + tmp_stream._flags = _IOWRITE + _IONBF; + tmp_stream._buf = (unsigned char *) s; + tmp_stream._ptr = (unsigned char *) s; + tmp_stream._count = 32767; + + retval = _doprnt(format, arg, &tmp_stream); + putc('\0',&tmp_stream); + + return retval; +} -- 2.34.1