aboutsummaryrefslogtreecommitdiffstats
path: root/missing
diff options
context:
space:
mode:
Diffstat (limited to 'missing')
-rw-r--r--missing/dup2.c12
-rw-r--r--missing/gcvt.c9
-rw-r--r--missing/getopt.c91
-rw-r--r--missing/memcmp.c18
-rw-r--r--missing/memcpy.c18
-rw-r--r--missing/memset.c18
-rw-r--r--missing/random.c365
-rw-r--r--missing/strcase.c93
-rw-r--r--missing/strchr.c35
-rw-r--r--missing/strerror.c45
-rw-r--r--missing/strtod.c117
-rw-r--r--missing/tmpnam.c27
-rw-r--r--missing/vprintf.c54
13 files changed, 902 insertions, 0 deletions
diff --git a/missing/dup2.c b/missing/dup2.c
new file mode 100644
index 00000000..01068348
--- /dev/null
+++ b/missing/dup2.c
@@ -0,0 +1,12 @@
+#ifndef F_DUPFD
+#include <fcntl.h>
+#endif
+
+int
+dup2 (old, new)
+int old, new;
+{
+ (void) close(new);
+
+ return fcntl(old, F_DUPFD, new);
+}
diff --git a/missing/gcvt.c b/missing/gcvt.c
new file mode 100644
index 00000000..1ebe41e1
--- /dev/null
+++ b/missing/gcvt.c
@@ -0,0 +1,9 @@
+char *
+gcvt(value, digits, buff)
+double value;
+int digits;
+char *buff;
+{
+ sprintf(buff, "%*g", digits, value);
+ return (buff);
+}
diff --git a/missing/getopt.c b/missing/getopt.c
new file mode 100644
index 00000000..d9e52945
--- /dev/null
+++ b/missing/getopt.c
@@ -0,0 +1,91 @@
+/*
+** @(#)getopt.c 2.5 (smail) 9/15/87
+*/
+
+/*
+ * Here's something you've all been waiting for: the AT&T public domain
+ * source for getopt(3). It is the code which was given out at the 1985
+ * UNIFORUM conference in Dallas. I obtained it by electronic mail
+ * directly from AT&T. The people there assure me that it is indeed
+ * in the public domain.
+ *
+ * There is no manual page. That is because the one they gave out at
+ * UNIFORUM was slightly different from the current System V Release 2
+ * manual page. The difference apparently involved a note about the
+ * famous rules 5 and 6, recommending using white space between an option
+ * and its first argument, and not grouping options that have arguments.
+ * Getopt itself is currently lenient about both of these things White
+ * space is allowed, but not mandatory, and the last option in a group can
+ * have an argument. That particular version of the man page evidently
+ * has no official existence, and my source at AT&T did not send a copy.
+ * The current SVR2 man page reflects the actual behavor of this getopt.
+ * However, I am not about to post a copy of anything licensed by AT&T.
+ */
+
+#if defined(MSDOS) || defined(USG)
+#define index strchr
+#endif
+
+/*LINTLIBRARY*/
+#define NULL 0
+#define EOF (-1)
+#define ERR(s, c) if(opterr){\
+ extern int write();\
+ char errbuf[2];\
+ errbuf[0] = c; errbuf[1] = '\n';\
+ (void) write(2, argv[0], (unsigned)strlen(argv[0]));\
+ (void) write(2, s, (unsigned)strlen(s));\
+ (void) write(2, errbuf, 2);}
+
+extern char *index();
+
+int opterr = 1;
+int optind = 1;
+int optopt;
+char *optarg;
+
+int
+getopt(argc, argv, opts)
+int argc;
+char **argv, *opts;
+{
+ static int sp = 1;
+ register int c;
+ register char *cp;
+
+ if(sp == 1)
+ if(optind >= argc ||
+ argv[optind][0] != '-' || argv[optind][1] == '\0')
+ return(EOF);
+ else if(strcmp(argv[optind], "--") == NULL) {
+ optind++;
+ return(EOF);
+ }
+ optopt = c = argv[optind][sp];
+ if(c == ':' || (cp=index(opts, c)) == NULL) {
+ ERR(": illegal option -- ", c);
+ if(argv[optind][++sp] == '\0') {
+ optind++;
+ sp = 1;
+ }
+ return('?');
+ }
+ if(*++cp == ':') {
+ if(argv[optind][sp+1] != '\0')
+ optarg = &argv[optind++][sp+1];
+ else if(++optind >= argc) {
+ ERR(": option requires an argument -- ", c);
+ sp = 1;
+ return('?');
+ } else
+ optarg = argv[optind++];
+ sp = 1;
+ } else {
+ if(argv[optind][++sp] == '\0') {
+ sp = 1;
+ optind++;
+ }
+ optarg = NULL;
+ }
+ return(c);
+}
diff --git a/missing/memcmp.c b/missing/memcmp.c
new file mode 100644
index 00000000..e39c10ec
--- /dev/null
+++ b/missing/memcmp.c
@@ -0,0 +1,18 @@
+/*
+ * memcmp --- compare strings.
+ *
+ * We use our own routine since it has to act like strcmp() for return
+ * value, and the BSD manual says bcmp() only returns zero/non-zero.
+ */
+
+int
+memcmp (s1, s2, l)
+register char *s1, *s2;
+register int l;
+{
+ for (; l--; s1++, s2++) {
+ if (*s1 != *s2)
+ return (*s1 - *s2);
+ }
+ return (*--s1 - *--s2);
+}
diff --git a/missing/memcpy.c b/missing/memcpy.c
new file mode 100644
index 00000000..3c4accdf
--- /dev/null
+++ b/missing/memcpy.c
@@ -0,0 +1,18 @@
+/*
+ * memcpy --- copy strings.
+ *
+ * We supply this routine for those systems that aren't standard yet.
+ */
+
+char *
+memcpy (dest, src, l)
+register char *dest, *src;
+register int l;
+{
+ register char *ret = dest;
+
+ while (l--)
+ *dest++ = *src++;
+
+ return ret;
+}
diff --git a/missing/memset.c b/missing/memset.c
new file mode 100644
index 00000000..120bdcb4
--- /dev/null
+++ b/missing/memset.c
@@ -0,0 +1,18 @@
+/*
+ * memset --- initialize memory
+ *
+ * We supply this routine for those systems that aren't standard yet.
+ */
+
+char *
+memset (dest, val, l)
+register char *dest, val;
+register int l;
+{
+ register char *ret = dest;
+
+ while (l--)
+ *dest++ = val;
+
+ return ret;
+}
diff --git a/missing/random.c b/missing/random.c
new file mode 100644
index 00000000..3708fe90
--- /dev/null
+++ b/missing/random.c
@@ -0,0 +1,365 @@
+/*
+ * Copyright (c) 1983 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley. The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)random.c 5.5 (Berkeley) 7/6/88";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+
+/*
+ * random.c:
+ * An improved random number generation package. In addition to the standard
+ * rand()/srand() like interface, this package also has a special state info
+ * interface. The initstate() routine is called with a seed, an array of
+ * bytes, and a count of how many bytes are being passed in; this array is then
+ * initialized to contain information for random number generation with that
+ * much state information. Good sizes for the amount of state information are
+ * 32, 64, 128, and 256 bytes. The state can be switched by calling the
+ * setstate() routine with the same array as was initiallized with initstate().
+ * By default, the package runs with 128 bytes of state information and
+ * generates far better random numbers than a linear congruential generator.
+ * If the amount of state information is less than 32 bytes, a simple linear
+ * congruential R.N.G. is used.
+ * Internally, the state information is treated as an array of longs; the
+ * zeroeth element of the array is the type of R.N.G. being used (small
+ * integer); the remainder of the array is the state information for the
+ * R.N.G. Thus, 32 bytes of state information will give 7 longs worth of
+ * state information, which will allow a degree seven polynomial. (Note: the
+ * zeroeth word of state information also has some other information stored
+ * in it -- see setstate() for details).
+ * The random number generation technique is a linear feedback shift register
+ * approach, employing trinomials (since there are fewer terms to sum up that
+ * way). In this approach, the least significant bit of all the numbers in
+ * the state table will act as a linear feedback shift register, and will have
+ * period 2^deg - 1 (where deg is the degree of the polynomial being used,
+ * assuming that the polynomial is irreducible and primitive). The higher
+ * order bits will have longer periods, since their values are also influenced
+ * by pseudo-random carries out of the lower bits. The total period of the
+ * generator is approximately deg*(2**deg - 1); thus doubling the amount of
+ * state information has a vast influence on the period of the generator.
+ * Note: the deg*(2**deg - 1) is an approximation only good for large deg,
+ * when the period of the shift register is the dominant factor. With deg
+ * equal to seven, the period is actually much longer than the 7*(2**7 - 1)
+ * predicted by this formula.
+ */
+
+
+
+/*
+ * For each of the currently supported random number generators, we have a
+ * break value on the amount of state information (you need at least this
+ * many bytes of state info to support this random number generator), a degree
+ * for the polynomial (actually a trinomial) that the R.N.G. is based on, and
+ * the separation between the two lower order coefficients of the trinomial.
+ */
+
+#define TYPE_0 0 /* linear congruential */
+#define BREAK_0 8
+#define DEG_0 0
+#define SEP_0 0
+
+#define TYPE_1 1 /* x**7 + x**3 + 1 */
+#define BREAK_1 32
+#define DEG_1 7
+#define SEP_1 3
+
+#define TYPE_2 2 /* x**15 + x + 1 */
+#define BREAK_2 64
+#define DEG_2 15
+#define SEP_2 1
+
+#define TYPE_3 3 /* x**31 + x**3 + 1 */
+#define BREAK_3 128
+#define DEG_3 31
+#define SEP_3 3
+
+#define TYPE_4 4 /* x**63 + x + 1 */
+#define BREAK_4 256
+#define DEG_4 63
+#define SEP_4 1
+
+
+/*
+ * Array versions of the above information to make code run faster -- relies
+ * on fact that TYPE_i == i.
+ */
+
+#define MAX_TYPES 5 /* max number of types above */
+
+static int degrees[ MAX_TYPES ] = { DEG_0, DEG_1, DEG_2,
+ DEG_3, DEG_4 };
+
+static int seps[ MAX_TYPES ] = { SEP_0, SEP_1, SEP_2,
+ SEP_3, SEP_4 };
+
+
+
+/*
+ * Initially, everything is set up as if from :
+ * initstate( 1, &randtbl, 128 );
+ * Note that this initialization takes advantage of the fact that srandom()
+ * advances the front and rear pointers 10*rand_deg times, and hence the
+ * rear pointer which starts at 0 will also end up at zero; thus the zeroeth
+ * element of the state information, which contains info about the current
+ * position of the rear pointer is just
+ * MAX_TYPES*(rptr - state) + TYPE_3 == TYPE_3.
+ */
+
+static long randtbl[ DEG_3 + 1 ] = { TYPE_3,
+ 0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342,
+ 0xde3b81e0, 0xdf0a6fb5, 0xf103bc02, 0x48f340fb,
+ 0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd,
+ 0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86,
+ 0xda672e2a, 0x1588ca88, 0xe369735d, 0x904f35f7,
+ 0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc,
+ 0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b,
+ 0xf5ad9d0e, 0x8999220b, 0x27fb47b9 };
+
+/*
+ * fptr and rptr are two pointers into the state info, a front and a rear
+ * pointer. These two pointers are always rand_sep places aparts, as they cycle
+ * cyclically through the state information. (Yes, this does mean we could get
+ * away with just one pointer, but the code for random() is more efficient this
+ * way). The pointers are left positioned as they would be from the call
+ * initstate( 1, randtbl, 128 )
+ * (The position of the rear pointer, rptr, is really 0 (as explained above
+ * in the initialization of randtbl) because the state table pointer is set
+ * to point to randtbl[1] (as explained below).
+ */
+
+static long *fptr = &randtbl[ SEP_3 + 1 ];
+static long *rptr = &randtbl[ 1 ];
+
+
+
+/*
+ * The following things are the pointer to the state information table,
+ * the type of the current generator, the degree of the current polynomial
+ * being used, and the separation between the two pointers.
+ * Note that for efficiency of random(), we remember the first location of
+ * the state information, not the zeroeth. Hence it is valid to access
+ * state[-1], which is used to store the type of the R.N.G.
+ * Also, we remember the last location, since this is more efficient than
+ * indexing every time to find the address of the last element to see if
+ * the front and rear pointers have wrapped.
+ */
+
+static long *state = &randtbl[ 1 ];
+
+static int rand_type = TYPE_3;
+static int rand_deg = DEG_3;
+static int rand_sep = SEP_3;
+
+static long *end_ptr = &randtbl[ DEG_3 + 1 ];
+
+
+
+/*
+ * srandom:
+ * Initialize the random number generator based on the given seed. If the
+ * type is the trivial no-state-information type, just remember the seed.
+ * Otherwise, initializes state[] based on the given "seed" via a linear
+ * congruential generator. Then, the pointers are set to known locations
+ * that are exactly rand_sep places apart. Lastly, it cycles the state
+ * information a given number of times to get rid of any initial dependencies
+ * introduced by the L.C.R.N.G.
+ * Note that the initialization of randtbl[] for default usage relies on
+ * values produced by this routine.
+ */
+
+srandom( x )
+
+ unsigned x;
+{
+ register int i, j;
+ long random();
+
+ if( rand_type == TYPE_0 ) {
+ state[ 0 ] = x;
+ }
+ else {
+ j = 1;
+ state[ 0 ] = x;
+ for( i = 1; i < rand_deg; i++ ) {
+ state[i] = 1103515245*state[i - 1] + 12345;
+ }
+ fptr = &state[ rand_sep ];
+ rptr = &state[ 0 ];
+ for( i = 0; i < 10*rand_deg; i++ ) random();
+ }
+}
+
+
+
+/*
+ * initstate:
+ * Initialize the state information in the given array of n bytes for
+ * future random number generation. Based on the number of bytes we
+ * are given, and the break values for the different R.N.G.'s, we choose
+ * the best (largest) one we can and set things up for it. srandom() is
+ * then called to initialize the state information.
+ * Note that on return from srandom(), we set state[-1] to be the type
+ * multiplexed with the current value of the rear pointer; this is so
+ * successive calls to initstate() won't lose this information and will
+ * be able to restart with setstate().
+ * Note: the first thing we do is save the current state, if any, just like
+ * setstate() so that it doesn't matter when initstate is called.
+ * Returns a pointer to the old state.
+ */
+
+char *
+initstate( seed, arg_state, n )
+
+ unsigned seed; /* seed for R. N. G. */
+ char *arg_state; /* pointer to state array */
+ int n; /* # bytes of state info */
+{
+ register char *ostate = (char *)( &state[ -1 ] );
+
+ if( rand_type == TYPE_0 ) state[ -1 ] = rand_type;
+ else state[ -1 ] = MAX_TYPES*(rptr - state) + rand_type;
+ if( n < BREAK_1 ) {
+ if( n < BREAK_0 ) {
+ fprintf( stderr, "initstate: not enough state (%d bytes) with which to do jack; ignored.\n", n );
+ return 0;
+ }
+ rand_type = TYPE_0;
+ rand_deg = DEG_0;
+ rand_sep = SEP_0;
+ }
+ else {
+ if( n < BREAK_2 ) {
+ rand_type = TYPE_1;
+ rand_deg = DEG_1;
+ rand_sep = SEP_1;
+ }
+ else {
+ if( n < BREAK_3 ) {
+ rand_type = TYPE_2;
+ rand_deg = DEG_2;
+ rand_sep = SEP_2;
+ }
+ else {
+ if( n < BREAK_4 ) {
+ rand_type = TYPE_3;
+ rand_deg = DEG_3;
+ rand_sep = SEP_3;
+ }
+ else {
+ rand_type = TYPE_4;
+ rand_deg = DEG_4;
+ rand_sep = SEP_4;
+ }
+ }
+ }
+ }
+ state = &( ( (long *)arg_state )[1] ); /* first location */
+ end_ptr = &state[ rand_deg ]; /* must set end_ptr before srandom */
+ srandom( seed );
+ if( rand_type == TYPE_0 ) state[ -1 ] = rand_type;
+ else state[ -1 ] = MAX_TYPES*(rptr - state) + rand_type;
+ return( ostate );
+}
+
+
+
+/*
+ * setstate:
+ * Restore the state from the given state array.
+ * Note: it is important that we also remember the locations of the pointers
+ * in the current state information, and restore the locations of the pointers
+ * from the old state information. This is done by multiplexing the pointer
+ * location into the zeroeth word of the state information.
+ * Note that due to the order in which things are done, it is OK to call
+ * setstate() with the same state as the current state.
+ * Returns a pointer to the old state information.
+ */
+
+char *
+setstate( arg_state )
+
+ char *arg_state;
+{
+ register long *new_state = (long *)arg_state;
+ register int type = new_state[0]%MAX_TYPES;
+ register int rear = new_state[0]/MAX_TYPES;
+ char *ostate = (char *)( &state[ -1 ] );
+
+ if( rand_type == TYPE_0 ) state[ -1 ] = rand_type;
+ else state[ -1 ] = MAX_TYPES*(rptr - state) + rand_type;
+ switch( type ) {
+ case TYPE_0:
+ case TYPE_1:
+ case TYPE_2:
+ case TYPE_3:
+ case TYPE_4:
+ rand_type = type;
+ rand_deg = degrees[ type ];
+ rand_sep = seps[ type ];
+ break;
+
+ default:
+ fprintf( stderr, "setstate: state info has been munged; not changed.\n" );
+ }
+ state = &new_state[ 1 ];
+ if( rand_type != TYPE_0 ) {
+ rptr = &state[ rear ];
+ fptr = &state[ (rear + rand_sep)%rand_deg ];
+ }
+ end_ptr = &state[ rand_deg ]; /* set end_ptr too */
+ return( ostate );
+}
+
+
+
+/*
+ * random:
+ * If we are using the trivial TYPE_0 R.N.G., just do the old linear
+ * congruential bit. Otherwise, we do our fancy trinomial stuff, which is the
+ * same in all ther other cases due to all the global variables that have been
+ * set up. The basic operation is to add the number at the rear pointer into
+ * the one at the front pointer. Then both pointers are advanced to the next
+ * location cyclically in the table. The value returned is the sum generated,
+ * reduced to 31 bits by throwing away the "least random" low bit.
+ * Note: the code takes advantage of the fact that both the front and
+ * rear pointers can't wrap on the same call by not testing the rear
+ * pointer if the front one has wrapped.
+ * Returns a 31-bit random number.
+ */
+
+long
+random()
+{
+ long i;
+
+ if( rand_type == TYPE_0 ) {
+ i = state[0] = ( state[0]*1103515245 + 12345 )&0x7fffffff;
+ }
+ else {
+ *fptr += *rptr;
+ i = (*fptr >> 1)&0x7fffffff; /* chucking least random bit */
+ if( ++fptr >= end_ptr ) {
+ fptr = state;
+ ++rptr;
+ }
+ else {
+ if( ++rptr >= end_ptr ) rptr = state;
+ }
+ }
+ return( i );
+}
diff --git a/missing/strcase.c b/missing/strcase.c
new file mode 100644
index 00000000..d8fa674a
--- /dev/null
+++ b/missing/strcase.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 1987 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley. The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char sccsid[] = "@(#)strcasecmp.c 5.6 (Berkeley) 6/27/88";
+#endif /* LIBC_SCCS and not lint */
+
+#ifndef USG
+#include <sys/types.h>
+#else
+#define u_char unsigned char
+#endif
+
+/*
+ * This array is designed for mapping upper and lower case letter
+ * together for a case independent comparison. The mappings are
+ * based upon ascii character sequences.
+ */
+static u_char charmap[] = {
+ '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
+ '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
+ '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
+ '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
+ '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
+ '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
+ '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
+ '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
+ '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
+ '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
+ '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
+ '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
+ '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
+ '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
+ '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
+ '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
+ '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
+ '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
+ '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
+ '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
+ '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
+ '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
+ '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
+ '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
+ '\300', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
+ '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
+ '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
+ '\370', '\371', '\372', '\333', '\334', '\335', '\336', '\337',
+ '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
+ '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
+ '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
+ '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
+};
+
+strcasecmp(s1, s2)
+ char *s1, *s2;
+{
+ register u_char *cm = charmap,
+ *us1 = (u_char *)s1,
+ *us2 = (u_char *)s2;
+
+ while (cm[*us1] == cm[*us2++])
+ if (*us1++ == '\0')
+ return(0);
+ return(cm[*us1] - cm[*--us2]);
+}
+
+strncasecmp(s1, s2, n)
+ char *s1, *s2;
+ register int n;
+{
+ register u_char *cm = charmap,
+ *us1 = (u_char *)s1,
+ *us2 = (u_char *)s2;
+
+ while (--n >= 0 && cm[*us1] == cm[*us2++])
+ if (*us1++ == '\0')
+ return(0);
+ return(n < 0 ? 0 : cm[*us1] - cm[*--us2]);
+}
diff --git a/missing/strchr.c b/missing/strchr.c
new file mode 100644
index 00000000..234ac883
--- /dev/null
+++ b/missing/strchr.c
@@ -0,0 +1,35 @@
+/*
+ * strchr --- search a string for a character
+ *
+ * We supply this routine for those systems that aren't standard yet.
+ */
+
+char *
+strchr (str, c)
+register char *str, c;
+{
+ for (; *str; str++)
+ if (*str == c)
+ return str;
+
+ return NULL;
+}
+
+/*
+ * strrchr --- find the last occurrence of a character in a string
+ *
+ * We supply this routine for those systems that aren't standard yet.
+ */
+
+char *
+strrchr (str, c)
+register char *str, c;
+{
+ register char *save = NULL;
+
+ for (; *str; str++)
+ if (*str == c)
+ save = str;
+
+ return save;
+}
diff --git a/missing/strerror.c b/missing/strerror.c
new file mode 100644
index 00000000..e9c20804
--- /dev/null
+++ b/missing/strerror.c
@@ -0,0 +1,45 @@
+/*
+ * strerror.c --- ANSI C compatible system error routine
+ */
+
+/*
+ * Copyright (C) 1986, 1988, 1989 the Free Software Foundation, Inc.
+ *
+ * This file is part of GAWK, the GNU implementation of the
+ * AWK Progamming Language.
+ *
+ * GAWK is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 1, or (at your option)
+ * any later version.
+ *
+ * GAWK is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GAWK; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+extern int sys_nerr;
+extern char *sys_errlist[];
+
+/* have to get right decl of sprintf early on */
+#ifndef BUFSIZ /* stdio specific definition */
+#include <stdio.h>
+#endif
+
+char *
+strerror(n)
+int n;
+{
+ static char mesg[30];
+
+ if (n < 0 || n > sys_nerr) {
+ sprintf (mesg, "Unknown error (%d)", n);
+ return mesg;
+ } else
+ return sys_errlist[n];
+}
diff --git a/missing/strtod.c b/missing/strtod.c
new file mode 100644
index 00000000..79350a1e
--- /dev/null
+++ b/missing/strtod.c
@@ -0,0 +1,117 @@
+/*
+ * strtod.c
+ *
+ * Stupid version of System V strtod(3) library routine.
+ * Does no overflow/underflow checking.
+ *
+ * A real number is defined to be
+ * optional leading white space
+ * optional sign
+ * string of digits with optional decimal point
+ * optional 'e' or 'E'
+ * followed by optional sign or space
+ * followed by an integer
+ *
+ * if ptr is not NULL a pointer to the character terminating the
+ * scan is returned in *ptr. If no number formed, *ptr is set to str
+ * and 0 is returned.
+ *
+ * For speed, we don't do the conversion ourselves. Instead, we find
+ * the end of the number and then call atof() to do the dirty work.
+ * This bought us a 10% speedup on a sample program at uunet.uu.net.
+ */
+
+#include <ctype.h>
+
+extern double atof();
+
+double
+strtod (s, ptr)
+register char *s, **ptr;
+{
+ double ret = 0.0;
+ char *start = s;
+ char *begin = NULL;
+ int success = 0;
+
+ /* optional white space */
+ while (isspace(*s))
+ s++;
+
+ /* optional sign */
+ if (*s == '+' || *s == '-') {
+ s++;
+ if (*(s-1) == '-')
+ begin = s - 1;
+ else
+ begin = s;
+ }
+
+ /* string of digits with optional decimal point */
+ if (isdigit(*s) && ! begin)
+ begin = s;
+
+ while (isdigit(*s)) {
+ s++;
+ success++;
+ }
+
+ if (*s == '.') {
+ if (! begin)
+ begin = s;
+ s++;
+ while (isdigit(*s))
+ s++;
+ success++;
+ }
+
+ if (s == start || success == 0) /* nothing there */
+ goto out;
+
+ /*
+ * optional 'e' or 'E'
+ * followed by optional sign or space
+ * followed by an integer
+ */
+
+ if (*s == 'e' || *s == 'E') {
+ s++;
+
+ /* XXX - atof probably doesn't allow spaces here */
+ while (isspace(*s))
+ s++;
+
+ if (*s == '+' || *s == '-')
+ s++;
+
+ while (isdigit(*s))
+ s++;
+ }
+
+ /* go for it */
+ ret = atof(begin);
+
+out:
+ if (! success)
+ s = start; /* in case all we did was skip whitespace */
+
+ if (ptr)
+ *ptr = s;
+
+ return ret;
+}
+
+#ifdef TEST
+main (argc, argv)
+int argc;
+char **argv;
+{
+ double d;
+ char *p;
+
+ for (argc--, argv++; argc; argc--, argv++) {
+ d = strtod (*argv, & p);
+ printf ("%lf [%s]\n", d, p);
+ }
+}
+#endif
diff --git a/missing/tmpnam.c b/missing/tmpnam.c
new file mode 100644
index 00000000..8f49859a
--- /dev/null
+++ b/missing/tmpnam.c
@@ -0,0 +1,27 @@
+/*
+ * tmpnam - an implementation for systems lacking a library version
+ * this version does not rely on the P_tmpdir and L_tmpnam constants.
+ */
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+static char template[] = "/tmp/gawkXXXXXX";
+
+char *
+tmpnam(tmp)
+char *tmp;
+{
+ static char tmpbuf[sizeof(template)];
+
+ if (tmp == NULL) {
+ (void) strcpy(tmpbuf, template);
+ (void) mktemp(tmpbuf);
+ return tmpbuf;
+ } else {
+ (void) strcpy(tmp, template);
+ (void) mktemp(tmp);
+ return tmp;
+ }
+}
diff --git a/missing/vprintf.c b/missing/vprintf.c
new file mode 100644
index 00000000..dea4ca86
--- /dev/null
+++ b/missing/vprintf.c
@@ -0,0 +1,54 @@
+#include <stdio.h>
+#include <varargs.h>
+
+#ifndef BUFSIZ
+#include <stdio.h>
+#endif
+
+#ifndef va_dcl
+#include <varargs.h>
+#endif
+
+int
+vsprintf(str, fmt, ap)
+ char *str, *fmt;
+ va_list ap;
+{
+ FILE f;
+ int len;
+
+ f._flag = _IOWRT+_IOSTRG;
+ f._ptr = (char *)str; /* My copy of BSD stdio.h has this as (char *)
+ * with a comment that it should be
+ * (unsigned char *). Since this code is
+ * intended for use on a vanilla BSD system,
+ * we'll stick with (char *) for now.
+ */
+ f._cnt = 32767;
+ len = _doprnt(fmt, ap, &f);
+ *f._ptr = 0;
+ return (len);
+}
+
+int
+vfprintf(iop, fmt, ap)
+ FILE *iop;
+ char *fmt;
+ va_list ap;
+{
+ int len;
+
+ len = _doprnt(fmt, ap, iop);
+ return (ferror(iop) ? EOF : len);
+}
+
+int
+vprintf(fmt, ap)
+ char *fmt;
+ va_list ap;
+{
+ int len;
+
+ len = _doprnt(fmt, ap, stdout);
+ return (ferror(stdout) ? EOF : len);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-26 11:17:17 +0000