diff options
Diffstat (limited to 'src/lib/libc/stdlib')
84 files changed, 11963 insertions, 0 deletions
diff --git a/src/lib/libc/stdlib/Makefile.inc b/src/lib/libc/stdlib/Makefile.inc new file mode 100644 index 0000000000..e75fc0d8bf --- /dev/null +++ b/src/lib/libc/stdlib/Makefile.inc | |||
@@ -0,0 +1,54 @@ | |||
1 | # $OpenBDS: Makefile.inc,v 1.6 1996/08/21 03:47:21 tholo Exp $ | ||
2 | |||
3 | # stdlib sources | ||
4 | .PATH: ${.CURDIR}/arch/${MACHINE_ARCH}/stdlib ${.CURDIR}/stdlib | ||
5 | |||
6 | SRCS+= a64l.c abort.c atexit.c atoi.c atof.c atol.c bsearch.c calloc.c \ | ||
7 | cfree.c exit.c getenv.c getopt.c getsubopt.c heapsort.c l64a.c \ | ||
8 | malloc.c merge.c multibyte.c putenv.c qsort.c radixsort.c rand.c \ | ||
9 | random.c realpath.c setenv.c strtod.c strtol.c strtoq.c strtoul.c \ | ||
10 | strtouq.c system.c tfind.c tsearch.c \ | ||
11 | _rand48.c drand48.c erand48.c jrand48.c lcong48.c lrand48.c \ | ||
12 | mrand48.c nrand48.c seed48.c srand48.c qabs.c qdiv.c | ||
13 | |||
14 | .if (${MACHINE_ARCH} == "m68k") | ||
15 | SRCS+= abs.S div.c labs.c ldiv.c | ||
16 | LSRCS+= abs.c | ||
17 | .elif (${MACHINE_ARCH} == "i386") | ||
18 | SRCS+= abs.S div.S labs.S ldiv.S | ||
19 | LSRCS+= abs.c div.c labs.c ldiv.c | ||
20 | .elif (${MACHINE_ARCH} == "ns32k") | ||
21 | SRCS+= abs.S div.c labs.c ldiv.c | ||
22 | LSRCS+= abs.c | ||
23 | .elif (${MACHINE_ARCH} == "tahoe") | ||
24 | SRCS+= abs.S div.c labs.c ldiv.c | ||
25 | LSRCS+= abs.c | ||
26 | .elif (${MACHINE_ARCH} == "vax") | ||
27 | SRCS+= abs.c div.c labs.c ldiv.c | ||
28 | .elif (${MACHINE_ARCH} == "alpha") | ||
29 | # XXX should be .S's | ||
30 | SRCS+= abs.c div.c labs.c ldiv.c | ||
31 | .else | ||
32 | SRCS+= abs.c div.c labs.c ldiv.c | ||
33 | .endif | ||
34 | |||
35 | MAN+= a64l.3 abort.3 abs.3 alloca.3 atexit.3 atof.3 atoi.3 atol.3 bsearch.3 \ | ||
36 | calloc.3 div.3 exit.3 getenv.3 getopt.3 getsubopt.3 labs.3 ldiv.3 \ | ||
37 | malloc.3 memory.3 qabs.3 qdiv.3 qsort.3 radixsort.3 rand48.3 rand.3 \ | ||
38 | random.3 realpath.3 strtod.3 strtol.3 strtoul.3 system.3 tsearch.3 | ||
39 | |||
40 | MLINKS+=getenv.3 setenv.3 getenv.3 unsetenv.3 getenv.3 putenv.3 | ||
41 | MLINKS+=malloc.3 free.3 malloc.3 realloc.3 | ||
42 | MLINKS+=malloc.3 cfree.3 | ||
43 | MLINKS+=qsort.3 heapsort.3 qsort.3 mergesort.3 | ||
44 | MLINKS+=rand.3 srand.3 | ||
45 | MLINKS+=random.3 initstate.3 random.3 setstate.3 random.3 srandom.3 | ||
46 | MLINKS+=rand48.3 drand48.3 rand48.3 erand48.3 rand48.3 lrand48.3 | ||
47 | MLINKS+=rand48.3 mrand48.3 rand48.3 nrand48.3 rand48.3 jrand48.3 | ||
48 | MLINKS+=rand48.3 srand48.3 rand48.3 seed48.3 rand48.3 lcong48.3 | ||
49 | MLINKS+=strtol.3 strtoq.3 | ||
50 | MLINKS+=strtoul.3 strtouq.3 | ||
51 | MLINKS+=tsearch.3 tfind.3 | ||
52 | MLINKS+=tsearch.3 tdelete.3 | ||
53 | MLINKS+=tsearch.3 twalk.3 | ||
54 | MLINKS+=a64l.3 l64a.3 | ||
diff --git a/src/lib/libc/stdlib/_rand48.c b/src/lib/libc/stdlib/_rand48.c new file mode 100644 index 0000000000..fed7372f68 --- /dev/null +++ b/src/lib/libc/stdlib/_rand48.c | |||
@@ -0,0 +1,50 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | */ | ||
13 | |||
14 | #if defined(LIBC_SCCS) && !defined(lint) | ||
15 | static char rcsid[] = "$OpenBSD: _rand48.c,v 1.2 1996/08/19 08:33:19 tholo Exp $"; | ||
16 | #endif /* LIBC_SCCS and not lint */ | ||
17 | |||
18 | #include "rand48.h" | ||
19 | |||
20 | unsigned short __rand48_seed[3] = { | ||
21 | RAND48_SEED_0, | ||
22 | RAND48_SEED_1, | ||
23 | RAND48_SEED_2 | ||
24 | }; | ||
25 | unsigned short __rand48_mult[3] = { | ||
26 | RAND48_MULT_0, | ||
27 | RAND48_MULT_1, | ||
28 | RAND48_MULT_2 | ||
29 | }; | ||
30 | unsigned short __rand48_add = RAND48_ADD; | ||
31 | |||
32 | void | ||
33 | __dorand48(unsigned short xseed[3]) | ||
34 | { | ||
35 | unsigned long accu; | ||
36 | unsigned short temp[2]; | ||
37 | |||
38 | accu = (unsigned long) __rand48_mult[0] * (unsigned long) xseed[0] + | ||
39 | (unsigned long) __rand48_add; | ||
40 | temp[0] = (unsigned short) accu; /* lower 16 bits */ | ||
41 | accu >>= sizeof(unsigned short) * 8; | ||
42 | accu += (unsigned long) __rand48_mult[0] * (unsigned long) xseed[1] + | ||
43 | (unsigned long) __rand48_mult[1] * (unsigned long) xseed[0]; | ||
44 | temp[1] = (unsigned short) accu; /* middle 16 bits */ | ||
45 | accu >>= sizeof(unsigned short) * 8; | ||
46 | accu += __rand48_mult[0] * xseed[2] + __rand48_mult[1] * xseed[1] + __rand48_mult[2] * xseed[0]; | ||
47 | xseed[0] = temp[0]; | ||
48 | xseed[1] = temp[1]; | ||
49 | xseed[2] = (unsigned short) accu; | ||
50 | } | ||
diff --git a/src/lib/libc/stdlib/a64l.3 b/src/lib/libc/stdlib/a64l.3 new file mode 100644 index 0000000000..4ec707adf1 --- /dev/null +++ b/src/lib/libc/stdlib/a64l.3 | |||
@@ -0,0 +1,122 @@ | |||
1 | .\" | ||
2 | .\" Copyright (c) 1997 Todd C. Miller <Todd.Miller@courtesan.com> | ||
3 | .\" All rights reserved. | ||
4 | .\" | ||
5 | .\" Redistribution and use in source and binary forms, with or without | ||
6 | .\" modification, are permitted provided that the following conditions | ||
7 | .\" are met: | ||
8 | .\" 1. Redistributions of source code must retain the above copyright | ||
9 | .\" notice, this list of conditions and the following disclaimer. | ||
10 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
11 | .\" notice, this list of conditions and the following disclaimer in the | ||
12 | .\" documentation and/or other materials provided with the distribution. | ||
13 | .\" 3. The name of the author may not be used to endorse or promote products | ||
14 | .\" derived from this software without specific prior written permission. | ||
15 | .\" | ||
16 | .\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, | ||
17 | .\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY | ||
18 | .\" AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL | ||
19 | .\" THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
20 | .\" EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
21 | .\" PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | ||
22 | .\" OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | ||
23 | .\" WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | ||
24 | .\" OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | ||
25 | .\" ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | .\" | ||
27 | .\" $OpenBSD: a64l.3,v 1.2 1998/06/21 22:13:48 millert Exp $ | ||
28 | .\" | ||
29 | .Dd August 17, 1997 | ||
30 | .Dt A64L 3 | ||
31 | .Os | ||
32 | .Sh NAME | ||
33 | .Nm a64l , | ||
34 | .Nm l64a | ||
35 | .Nd convert between 32-bit integer and radix-64 ASCII string | ||
36 | .Sh SYNOPSIS | ||
37 | .Fd #include <stdlib.h> | ||
38 | .Ft long | ||
39 | .Fn a64l "const char *s" | ||
40 | .Ft char * | ||
41 | .Fn l64a "long l" | ||
42 | .Sh DESCRIPTION | ||
43 | The | ||
44 | .Fn a64l | ||
45 | and | ||
46 | .Fn l64a | ||
47 | functions are used to maintain numbers stored in radix-64 | ||
48 | ASCII characters. This is a notation by which 32-bit integers | ||
49 | can be represented by up to six characters; each character | ||
50 | represents a "digit" in a radix-64 notation. | ||
51 | .Pp | ||
52 | The characters used to represent "digits" are '.' for 0, '/' for 1, | ||
53 | '0' through '9' for 2-11, 'A' through 'Z' for 12-37, and 'a' through | ||
54 | 'z' for 38-63. | ||
55 | .Pp | ||
56 | The | ||
57 | .Fn a64l | ||
58 | function takes a pointer to a null-terminated radix-64 representation | ||
59 | and returns a corresponding 32-bit value. If the string pointed to by | ||
60 | .Ar s | ||
61 | contains more than six characters, | ||
62 | .Fn a64l | ||
63 | will use the first six. | ||
64 | .Fn A64l | ||
65 | scans the character string from left to right, decoding | ||
66 | each character as a 6-bit radix-64 number. If a long integer is | ||
67 | larger than 32 bits, the return value will be sign-extended. | ||
68 | .Pp | ||
69 | .Fn l64a | ||
70 | takes a long integer argument | ||
71 | .Ar l | ||
72 | and returns a pointer to the corresponding radix-64 representation. | ||
73 | .Sh RETURN VALUES | ||
74 | On success, | ||
75 | .Fn a64l | ||
76 | returns a 32-bit representation of | ||
77 | .Ar s . | ||
78 | If | ||
79 | .Ar s | ||
80 | is a NULL pointer or if it contains "digits" other than those described above, | ||
81 | .Fn a64l | ||
82 | returns -1L and sets the global variable errno to | ||
83 | .Va EINVAL . | ||
84 | .Pp | ||
85 | On success, | ||
86 | .Fn l64a | ||
87 | returns a pointer to a string containing the radix-64 representation of | ||
88 | .Ar l . | ||
89 | If | ||
90 | .Ar l | ||
91 | is 0, | ||
92 | .Fn l64a | ||
93 | returns a pointer to the empty string. | ||
94 | If | ||
95 | .Ar l | ||
96 | is negative, | ||
97 | .Fn l64a | ||
98 | returns a NULL pointer and sets the global variable errno to | ||
99 | .Va EINVAL . | ||
100 | .Sh WARNINGS | ||
101 | The value returned by | ||
102 | .Fn l64a | ||
103 | is a pointer into a static buffer, the contents of which | ||
104 | will be overwritten by subsequent calls. | ||
105 | .Pp | ||
106 | The value returned by | ||
107 | .Fn a64l | ||
108 | may be incorrect if the value is too large; for that reason, only strings | ||
109 | that resulted from a call to | ||
110 | .Fn l64a | ||
111 | should be used to call | ||
112 | .Fn a64l . | ||
113 | .Pp | ||
114 | If a long integer is larger than 32 bits, only the low-order | ||
115 | 32 bits are used. | ||
116 | .Sh STANDARDS | ||
117 | The | ||
118 | .Fn a64l | ||
119 | and | ||
120 | .Fn l64a | ||
121 | functions conform to | ||
122 | .St -xpg4.2 . | ||
diff --git a/src/lib/libc/stdlib/a64l.c b/src/lib/libc/stdlib/a64l.c new file mode 100644 index 0000000000..a68f0a6dcd --- /dev/null +++ b/src/lib/libc/stdlib/a64l.c | |||
@@ -0,0 +1,46 @@ | |||
1 | /* | ||
2 | * Written by J.T. Conklin <jtc@netbsd.org>. | ||
3 | * Public domain. | ||
4 | */ | ||
5 | |||
6 | #if defined(LIBC_SCCS) && !defined(lint) | ||
7 | static char *rcsid = "$OpenBSD: a64l.c,v 1.3 1997/08/17 22:58:34 millert Exp $"; | ||
8 | #endif /* LIBC_SCCS and not lint */ | ||
9 | |||
10 | #include <errno.h> | ||
11 | #include <stdlib.h> | ||
12 | |||
13 | long | ||
14 | a64l(s) | ||
15 | const char *s; | ||
16 | { | ||
17 | long value, digit, shift; | ||
18 | int i; | ||
19 | |||
20 | if (s == NULL) { | ||
21 | errno = EINVAL; | ||
22 | return(-1L); | ||
23 | } | ||
24 | |||
25 | value = 0; | ||
26 | shift = 0; | ||
27 | for (i = 0; *s && i < 6; i++, s++) { | ||
28 | if (*s >= '.' && *s <= '/') | ||
29 | digit = *s - '.'; | ||
30 | else if (*s >= '0' && *s <= '9') | ||
31 | digit = *s - '0' + 2; | ||
32 | else if (*s >= 'A' && *s <= 'Z') | ||
33 | digit = *s - 'A' + 12; | ||
34 | else if (*s >= 'a' && *s <= 'z') | ||
35 | digit = *s - 'a' + 38; | ||
36 | else { | ||
37 | errno = EINVAL; | ||
38 | return(-1L); | ||
39 | } | ||
40 | |||
41 | value |= digit << shift; | ||
42 | shift += 6; | ||
43 | } | ||
44 | |||
45 | return(value); | ||
46 | } | ||
diff --git a/src/lib/libc/stdlib/abort.3 b/src/lib/libc/stdlib/abort.3 new file mode 100644 index 0000000000..92c9a354d0 --- /dev/null +++ b/src/lib/libc/stdlib/abort.3 | |||
@@ -0,0 +1,70 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: abort.3,v 1.4 1997/07/17 07:39:41 deraadt Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt ABORT 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm abort | ||
43 | .Nd cause abnormal program termination | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft void | ||
47 | .Fn abort void | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn abort | ||
51 | function causes abnormal program termination to occur, unless the | ||
52 | signal | ||
53 | .Dv SIGABRT | ||
54 | is being caught and the signal handler does not return. | ||
55 | .Pp | ||
56 | Any open streams are flushed and closed. | ||
57 | .Sh RETURN VALUES | ||
58 | The | ||
59 | .Nm abort | ||
60 | function | ||
61 | never returns. | ||
62 | .Sh SEE ALSO | ||
63 | .Xr sigaction 2 , | ||
64 | .Xr exit 3 | ||
65 | .Sh STANDARDS | ||
66 | The | ||
67 | .Fn abort | ||
68 | function | ||
69 | conforms to | ||
70 | .St -p1003.1-90 . | ||
diff --git a/src/lib/libc/stdlib/abort.c b/src/lib/libc/stdlib/abort.c new file mode 100644 index 0000000000..4ea8a2ca4b --- /dev/null +++ b/src/lib/libc/stdlib/abort.c | |||
@@ -0,0 +1,77 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1985 Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: abort.c,v 1.5 1997/06/22 20:21:25 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <signal.h> | ||
39 | #include <stdlib.h> | ||
40 | #include <unistd.h> | ||
41 | |||
42 | void (*__cleanup)(); | ||
43 | |||
44 | void | ||
45 | abort() | ||
46 | { | ||
47 | static int cleanup_called = 0; | ||
48 | sigset_t mask; | ||
49 | |||
50 | |||
51 | sigfillset(&mask); | ||
52 | /* | ||
53 | * don't block SIGABRT to give any handler a chance; we ignore | ||
54 | * any errors -- X311J doesn't allow abort to return anyway. | ||
55 | */ | ||
56 | sigdelset(&mask, SIGABRT); | ||
57 | (void)sigprocmask(SIG_SETMASK, &mask, (sigset_t *)NULL); | ||
58 | |||
59 | /* | ||
60 | * POSIX requires we flush stdio buffers on abort | ||
61 | */ | ||
62 | if (cleanup_called == 0 && __cleanup != NULL) { | ||
63 | cleanup_called = 1; | ||
64 | (*__cleanup)(); | ||
65 | } | ||
66 | |||
67 | (void)kill(getpid(), SIGABRT); | ||
68 | |||
69 | /* | ||
70 | * if SIGABRT ignored, or caught and the handler returns, do | ||
71 | * it again, only harder. | ||
72 | */ | ||
73 | (void)signal(SIGABRT, SIG_DFL); | ||
74 | (void)sigprocmask(SIG_SETMASK, &mask, (sigset_t *)NULL); | ||
75 | (void)kill(getpid(), SIGABRT); | ||
76 | exit(1); | ||
77 | } | ||
diff --git a/src/lib/libc/stdlib/abs.3 b/src/lib/libc/stdlib/abs.3 new file mode 100644 index 0000000000..77f82b9402 --- /dev/null +++ b/src/lib/libc/stdlib/abs.3 | |||
@@ -0,0 +1,73 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: abs.3,v 1.2 1996/08/19 08:33:21 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt ABS 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm abs | ||
43 | .Nd integer absolute value function | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft int | ||
47 | .Fn abs "int j" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn abs | ||
51 | function | ||
52 | computes | ||
53 | the absolute value of the integer | ||
54 | .Ar j . | ||
55 | .Sh RETURN VALUES | ||
56 | The | ||
57 | .Fn abs | ||
58 | function | ||
59 | returns | ||
60 | the absolute value. | ||
61 | .Sh SEE ALSO | ||
62 | .Xr floor 3 , | ||
63 | .Xr labs 3 , | ||
64 | .Xr cabs 3 , | ||
65 | .Xr hypot 3 , | ||
66 | .Xr math 3 | ||
67 | .Sh STANDARDS | ||
68 | The | ||
69 | .Fn abs | ||
70 | function conforms to | ||
71 | .St -ansiC . | ||
72 | .Sh BUGS | ||
73 | The absolute value of the most negative integer remains negative. | ||
diff --git a/src/lib/libc/stdlib/abs.c b/src/lib/libc/stdlib/abs.c new file mode 100644 index 0000000000..7c79e4073c --- /dev/null +++ b/src/lib/libc/stdlib/abs.c | |||
@@ -0,0 +1,45 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1990 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: abs.c,v 1.2 1996/08/19 08:33:21 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | |||
40 | int | ||
41 | abs(j) | ||
42 | int j; | ||
43 | { | ||
44 | return(j < 0 ? -j : j); | ||
45 | } | ||
diff --git a/src/lib/libc/stdlib/alloca.3 b/src/lib/libc/stdlib/alloca.3 new file mode 100644 index 0000000000..ef87220772 --- /dev/null +++ b/src/lib/libc/stdlib/alloca.3 | |||
@@ -0,0 +1,75 @@ | |||
1 | .\" Copyright (c) 1980, 1991 Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" Redistribution and use in source and binary forms, with or without | ||
5 | .\" modification, are permitted provided that the following conditions | ||
6 | .\" are met: | ||
7 | .\" 1. Redistributions of source code must retain the above copyright | ||
8 | .\" notice, this list of conditions and the following disclaimer. | ||
9 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
10 | .\" notice, this list of conditions and the following disclaimer in the | ||
11 | .\" documentation and/or other materials provided with the distribution. | ||
12 | .\" 3. All advertising materials mentioning features or use of this software | ||
13 | .\" must display the following acknowledgement: | ||
14 | .\" This product includes software developed by the University of | ||
15 | .\" California, Berkeley and its contributors. | ||
16 | .\" 4. Neither the name of the University nor the names of its contributors | ||
17 | .\" may be used to endorse or promote products derived from this software | ||
18 | .\" without specific prior written permission. | ||
19 | .\" | ||
20 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
21 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
22 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
23 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
24 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
25 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
26 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
27 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
28 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
29 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
30 | .\" SUCH DAMAGE. | ||
31 | .\" | ||
32 | .\" $OpenBSD: alloca.3,v 1.3 1996/08/19 08:33:22 tholo Exp $ | ||
33 | .\" | ||
34 | .Dd May 2, 1991 | ||
35 | .Dt ALLOCA 3 | ||
36 | .Os BSD 4 | ||
37 | .Sh NAME | ||
38 | .Nm alloca | ||
39 | .Nd memory allocator | ||
40 | .Sh SYNOPSIS | ||
41 | .Fd #include <stdlib.h> | ||
42 | .Ft void * | ||
43 | .Fn alloca "size_t size" | ||
44 | .Sh DESCRIPTION | ||
45 | The | ||
46 | .Fn alloca | ||
47 | function | ||
48 | allocates | ||
49 | .Fa size | ||
50 | bytes of space in the stack frame of the caller. | ||
51 | This temporary space is automatically freed on | ||
52 | return. | ||
53 | .Sh RETURN VALUES | ||
54 | The | ||
55 | .Fn alloca | ||
56 | function returns a pointer to the beginning of the allocated space. | ||
57 | .Sh SEE ALSO | ||
58 | .Xr brk 2 , | ||
59 | .Xr pagesize 2 | ||
60 | .Xr calloc 3 , | ||
61 | .Xr malloc 3 , | ||
62 | .Xr realloc 3 , | ||
63 | .Sh BUGS | ||
64 | The | ||
65 | .Fn alloca | ||
66 | function | ||
67 | is machine dependent; its use is discouraged. | ||
68 | .\" .Sh HISTORY | ||
69 | .\" The | ||
70 | .\" .Fn alloca | ||
71 | .\" function appeared in | ||
72 | .\" .Bx ?? . | ||
73 | .\" The function appeared in 32v, pwb and pwb.2 and in 3bsd 4bsd | ||
74 | .\" The first man page (or link to a man page that I can find at the | ||
75 | .\" moment is 4.3... | ||
diff --git a/src/lib/libc/stdlib/atexit.3 b/src/lib/libc/stdlib/atexit.3 new file mode 100644 index 0000000000..0b10f010fa --- /dev/null +++ b/src/lib/libc/stdlib/atexit.3 | |||
@@ -0,0 +1,77 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" Chris Torek and the American National Standards Committee X3, | ||
6 | .\" on Information Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: atexit.3,v 1.2 1996/08/19 08:33:22 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt ATEXIT 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm atexit | ||
43 | .Nd register a function to be called on exit | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft int | ||
47 | .Fn atexit "void (*function)(void)" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn atexit | ||
51 | function | ||
52 | registers the given | ||
53 | .Ar function | ||
54 | to be called at program exit, whether via | ||
55 | .Xr exit 3 | ||
56 | or via return from the program's | ||
57 | .Em main . | ||
58 | Functions so registered are called in reverse order; | ||
59 | no arguments are passed. | ||
60 | At least 32 functions can always be registered, | ||
61 | and more are allowed as long as sufficient memory can be allocated. | ||
62 | .Sh RETURN VALUES | ||
63 | .Rv -std atexit | ||
64 | .Sh ERRORS | ||
65 | .Bl -tag -width Er | ||
66 | .It Bq Er ENOMEM | ||
67 | No memory was available to add the function to the list. | ||
68 | The existing list of functions is unmodified. | ||
69 | .El | ||
70 | .Sh SEE ALSO | ||
71 | .Xr exit 3 | ||
72 | .Sh STANDARDS | ||
73 | The | ||
74 | .Fn atexit | ||
75 | function | ||
76 | conforms to | ||
77 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/atexit.c b/src/lib/libc/stdlib/atexit.c new file mode 100644 index 0000000000..c0fb624141 --- /dev/null +++ b/src/lib/libc/stdlib/atexit.c | |||
@@ -0,0 +1,67 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1990 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * This code is derived from software contributed to Berkeley by | ||
6 | * Chris Torek. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * 1. Redistributions of source code must retain the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer. | ||
13 | * 2. Redistributions in binary form must reproduce the above copyright | ||
14 | * notice, this list of conditions and the following disclaimer in the | ||
15 | * documentation and/or other materials provided with the distribution. | ||
16 | * 3. All advertising materials mentioning features or use of this software | ||
17 | * must display the following acknowledgement: | ||
18 | * This product includes software developed by the University of | ||
19 | * California, Berkeley and its contributors. | ||
20 | * 4. Neither the name of the University nor the names of its contributors | ||
21 | * may be used to endorse or promote products derived from this software | ||
22 | * without specific prior written permission. | ||
23 | * | ||
24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | * SUCH DAMAGE. | ||
35 | */ | ||
36 | |||
37 | #if defined(LIBC_SCCS) && !defined(lint) | ||
38 | static char *rcsid = "$OpenBSD: atexit.c,v 1.2 1996/08/19 08:33:22 tholo Exp $"; | ||
39 | #endif /* LIBC_SCCS and not lint */ | ||
40 | |||
41 | #include <stdlib.h> | ||
42 | #include "atexit.h" | ||
43 | |||
44 | struct atexit *__atexit; | ||
45 | |||
46 | /* | ||
47 | * Register a function to be performed at exit. | ||
48 | */ | ||
49 | int | ||
50 | atexit(fn) | ||
51 | void (*fn)(); | ||
52 | { | ||
53 | static struct atexit __atexit0; /* one guaranteed table */ | ||
54 | register struct atexit *p; | ||
55 | |||
56 | if ((p = __atexit) == NULL) | ||
57 | __atexit = p = &__atexit0; | ||
58 | else if (p->ind >= ATEXIT_SIZE) { | ||
59 | if ((p = malloc(sizeof(*p))) == NULL) | ||
60 | return (-1); | ||
61 | p->ind = 0; | ||
62 | p->next = __atexit; | ||
63 | __atexit = p; | ||
64 | } | ||
65 | p->fns[p->ind++] = fn; | ||
66 | return (0); | ||
67 | } | ||
diff --git a/src/lib/libc/stdlib/atexit.h b/src/lib/libc/stdlib/atexit.h new file mode 100644 index 0000000000..e41a7cb86c --- /dev/null +++ b/src/lib/libc/stdlib/atexit.h | |||
@@ -0,0 +1,45 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1990 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | * | ||
33 | * $OpenBSD: atexit.h,v 1.2 1996/08/19 08:33:23 tholo Exp $ | ||
34 | */ | ||
35 | |||
36 | /* must be at least 32 to guarantee ANSI conformance */ | ||
37 | #define ATEXIT_SIZE 32 | ||
38 | |||
39 | struct atexit { | ||
40 | struct atexit *next; /* next in list */ | ||
41 | int ind; /* next index in this table */ | ||
42 | void (*fns[ATEXIT_SIZE])(); /* the table itself */ | ||
43 | }; | ||
44 | |||
45 | extern struct atexit *__atexit; /* points to head of LIFO stack */ | ||
diff --git a/src/lib/libc/stdlib/atof.3 b/src/lib/libc/stdlib/atof.3 new file mode 100644 index 0000000000..cc1b500b0f --- /dev/null +++ b/src/lib/libc/stdlib/atof.3 | |||
@@ -0,0 +1,73 @@ | |||
1 | .\" Copyright (c) 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: atof.3,v 1.2 1996/08/19 08:33:23 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt ATOF 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm atof | ||
43 | .Nd convert | ||
44 | .Tn ASCII | ||
45 | string to double | ||
46 | .Sh SYNOPSIS | ||
47 | .Fd #include <stdlib.h> | ||
48 | .Ft double | ||
49 | .Fn atof "const char *nptr" | ||
50 | .Sh DESCRIPTION | ||
51 | The | ||
52 | .Fn atof | ||
53 | function converts the initial portion of the string pointed to by | ||
54 | .Ar nptr | ||
55 | to | ||
56 | .Ar double | ||
57 | representation. | ||
58 | .Pp | ||
59 | It is equivalent to: | ||
60 | .Bd -literal -offset indent | ||
61 | strtod(nptr, (char **)NULL); | ||
62 | .Ed | ||
63 | .Sh SEE ALSO | ||
64 | .Xr atoi 3 , | ||
65 | .Xr atol 3 , | ||
66 | .Xr strtod 3 , | ||
67 | .Xr strtol 3 , | ||
68 | .Xr strtoul 3 | ||
69 | .Sh STANDARDS | ||
70 | The | ||
71 | .Fn atof | ||
72 | function conforms to | ||
73 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/atof.c b/src/lib/libc/stdlib/atof.c new file mode 100644 index 0000000000..30bac19899 --- /dev/null +++ b/src/lib/libc/stdlib/atof.c | |||
@@ -0,0 +1,45 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1988 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: atof.c,v 1.2 1996/08/19 08:33:24 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | |||
40 | double | ||
41 | atof(ascii) | ||
42 | const char *ascii; | ||
43 | { | ||
44 | return(strtod(ascii, (char **)NULL)); | ||
45 | } | ||
diff --git a/src/lib/libc/stdlib/atoi.3 b/src/lib/libc/stdlib/atoi.3 new file mode 100644 index 0000000000..280a989e8e --- /dev/null +++ b/src/lib/libc/stdlib/atoi.3 | |||
@@ -0,0 +1,73 @@ | |||
1 | .\" Copyright (c) 1990, 1991, 1993 | ||
2 | .\" The Regents of the University of California. All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: atoi.3,v 1.2 1996/08/10 04:51:31 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 4, 1993 | ||
39 | .Dt ATOI 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm atoi | ||
43 | .Nd convert | ||
44 | .Tn ASCII | ||
45 | string to integer | ||
46 | .Sh SYNOPSIS | ||
47 | .Fd #include <stdlib.h> | ||
48 | .Ft int | ||
49 | .Fn atoi "const char *nptr" | ||
50 | .Sh DESCRIPTION | ||
51 | The | ||
52 | .Fn atoi | ||
53 | function converts the initial portion of the string pointed to by | ||
54 | .Em nptr | ||
55 | to | ||
56 | .Em integer | ||
57 | representation. | ||
58 | .Pp | ||
59 | It is equivalent to: | ||
60 | .Bd -literal -offset indent | ||
61 | (int)strtol(nptr, (char **)NULL, 10); | ||
62 | .Ed | ||
63 | .Sh SEE ALSO | ||
64 | .Xr atof 3 , | ||
65 | .Xr atol 3 , | ||
66 | .Xr strtod 3 , | ||
67 | .Xr strtol 3 , | ||
68 | .Xr strtoul 3 | ||
69 | .Sh STANDARDS | ||
70 | The | ||
71 | .Fn atoi | ||
72 | function conforms to | ||
73 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/atoi.c b/src/lib/libc/stdlib/atoi.c new file mode 100644 index 0000000000..a74d6e1351 --- /dev/null +++ b/src/lib/libc/stdlib/atoi.c | |||
@@ -0,0 +1,45 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1988 Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: atoi.c,v 1.2 1996/08/19 08:33:24 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | |||
40 | int | ||
41 | atoi(str) | ||
42 | const char *str; | ||
43 | { | ||
44 | return((int)strtol(str, (char **)NULL, 10)); | ||
45 | } | ||
diff --git a/src/lib/libc/stdlib/atol.3 b/src/lib/libc/stdlib/atol.3 new file mode 100644 index 0000000000..2b49bd1f2c --- /dev/null +++ b/src/lib/libc/stdlib/atol.3 | |||
@@ -0,0 +1,74 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: atol.3,v 1.2 1996/08/19 08:33:25 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt ATOL 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm atol | ||
43 | .Nd convert | ||
44 | .Tn ASCII | ||
45 | string to long integer | ||
46 | .Sh SYNOPSIS | ||
47 | .Fd #include <stdlib.h> | ||
48 | .Ft long | ||
49 | .Fn atol "const char *nptr" | ||
50 | .Sh DESCRIPTION | ||
51 | The | ||
52 | .Fn atol | ||
53 | function converts the initial portion of the string pointed to by | ||
54 | .Ar nptr | ||
55 | to | ||
56 | .Em long integer | ||
57 | representation. | ||
58 | .Pp | ||
59 | It is equivalent to: | ||
60 | .Bd -literal -offset indent | ||
61 | strtol(nptr, (char **)NULL, 10); | ||
62 | .Ed | ||
63 | .Sh SEE ALSO | ||
64 | .Xr atof 3 , | ||
65 | .Xr atoi 3 , | ||
66 | .Xr strtod 3 , | ||
67 | .Xr strtol 3 , | ||
68 | .Xr strtoul 3 | ||
69 | .Sh STANDARDS | ||
70 | The | ||
71 | .Fn atol | ||
72 | function | ||
73 | conforms to | ||
74 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/atol.c b/src/lib/libc/stdlib/atol.c new file mode 100644 index 0000000000..528a932214 --- /dev/null +++ b/src/lib/libc/stdlib/atol.c | |||
@@ -0,0 +1,45 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1988 Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: atol.c,v 1.2 1996/08/19 08:33:26 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | |||
40 | long | ||
41 | atol(str) | ||
42 | const char *str; | ||
43 | { | ||
44 | return(strtol(str, (char **)NULL, 10)); | ||
45 | } | ||
diff --git a/src/lib/libc/stdlib/bsearch.3 b/src/lib/libc/stdlib/bsearch.3 new file mode 100644 index 0000000000..570a4227b4 --- /dev/null +++ b/src/lib/libc/stdlib/bsearch.3 | |||
@@ -0,0 +1,90 @@ | |||
1 | .\" Copyright (c) 1990, 1991, 1993, 1994 | ||
2 | .\" The Regents of the University of California. All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: bsearch.3,v 1.3 1997/06/13 23:41:35 deraadt Exp $ | ||
37 | .\" | ||
38 | .Dd April 19, 1994 | ||
39 | .Dt BSEARCH 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm bsearch | ||
43 | .Nd binary search of a sorted table | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft void * | ||
47 | .Fn bsearch "const void *key" "const void *base" "size_t nmemb" "size_t size" "int (*compar) (const void *, const void *)" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn bsearch | ||
51 | function searches an array of | ||
52 | .Fa nmemb | ||
53 | objects, the initial member of which is | ||
54 | pointed to by | ||
55 | .Fa base , | ||
56 | for a member that matches the object pointed to by | ||
57 | .Fa key . | ||
58 | The size of each member of the array is specified by | ||
59 | .Fa size . | ||
60 | .Pp | ||
61 | The contents of the array should be in ascending sorted order according | ||
62 | to the comparison function referenced by | ||
63 | .Fa compar . | ||
64 | The | ||
65 | .Fa compar | ||
66 | routine | ||
67 | is expected to have | ||
68 | two arguments which point to the | ||
69 | .Fa key | ||
70 | object and to an array member, in that order, and should return an integer | ||
71 | less than, equal to, or greater than zero if the | ||
72 | .Fa key | ||
73 | object is found, respectively, to be less than, to match, or be | ||
74 | greater than the array member. | ||
75 | .Sh RETURN VALUES | ||
76 | The | ||
77 | .Fn bsearch | ||
78 | function returns a pointer to a matching member of the array, or a null | ||
79 | pointer if no match is found. | ||
80 | If two members compare as equal, which member is matched is unspecified. | ||
81 | .Sh SEE ALSO | ||
82 | .Xr db 3 , | ||
83 | .Xr lsearch 3 , | ||
84 | .Xr qsort 3 , | ||
85 | .Xr tsearch 3 | ||
86 | .Sh STANDARDS | ||
87 | The | ||
88 | .Fn bsearch | ||
89 | function conforms to | ||
90 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/bsearch.c b/src/lib/libc/stdlib/bsearch.c new file mode 100644 index 0000000000..eeef9bffc6 --- /dev/null +++ b/src/lib/libc/stdlib/bsearch.c | |||
@@ -0,0 +1,79 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1990 Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: bsearch.c,v 1.2 1996/08/19 08:33:26 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | |||
40 | /* | ||
41 | * Perform a binary search. | ||
42 | * | ||
43 | * The code below is a bit sneaky. After a comparison fails, we | ||
44 | * divide the work in half by moving either left or right. If lim | ||
45 | * is odd, moving left simply involves halving lim: e.g., when lim | ||
46 | * is 5 we look at item 2, so we change lim to 2 so that we will | ||
47 | * look at items 0 & 1. If lim is even, the same applies. If lim | ||
48 | * is odd, moving right again involes halving lim, this time moving | ||
49 | * the base up one item past p: e.g., when lim is 5 we change base | ||
50 | * to item 3 and make lim 2 so that we will look at items 3 and 4. | ||
51 | * If lim is even, however, we have to shrink it by one before | ||
52 | * halving: e.g., when lim is 4, we still looked at item 2, so we | ||
53 | * have to make lim 3, then halve, obtaining 1, so that we will only | ||
54 | * look at item 3. | ||
55 | */ | ||
56 | void * | ||
57 | bsearch(key, base0, nmemb, size, compar) | ||
58 | register const void *key; | ||
59 | const void *base0; | ||
60 | size_t nmemb; | ||
61 | register size_t size; | ||
62 | register int (*compar) __P((const void *, const void *)); | ||
63 | { | ||
64 | register const char *base = base0; | ||
65 | register int lim, cmp; | ||
66 | register const void *p; | ||
67 | |||
68 | for (lim = nmemb; lim != 0; lim >>= 1) { | ||
69 | p = base + (lim >> 1) * size; | ||
70 | cmp = (*compar)(key, p); | ||
71 | if (cmp == 0) | ||
72 | return ((void *)p); | ||
73 | if (cmp > 0) { /* key > p: move right */ | ||
74 | base = (char *)p + size; | ||
75 | lim--; | ||
76 | } /* else move left */ | ||
77 | } | ||
78 | return (NULL); | ||
79 | } | ||
diff --git a/src/lib/libc/stdlib/calloc.3 b/src/lib/libc/stdlib/calloc.3 new file mode 100644 index 0000000000..13a912169c --- /dev/null +++ b/src/lib/libc/stdlib/calloc.3 | |||
@@ -0,0 +1,70 @@ | |||
1 | .\" Copyright (c) 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: calloc.3,v 1.3 1996/12/10 09:06:10 deraadt Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt CALLOC 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm calloc | ||
43 | .Nd allocate clean memory (zero initialized space) | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft void * | ||
47 | .Fn calloc "size_t nmemb" "size_t size" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn calloc | ||
51 | function allocates space for an array of | ||
52 | .Fa nmemb | ||
53 | objects, each of whose size is | ||
54 | .Fa size . | ||
55 | The space is initialized to all bits zero. | ||
56 | .Sh RETURN VALUES | ||
57 | The | ||
58 | .Fn calloc | ||
59 | function returns | ||
60 | a pointer to | ||
61 | the allocated space if successful; otherwise a null pointer is returned. | ||
62 | .Sh SEE ALSO | ||
63 | .Xr malloc 3 , | ||
64 | .Xr realloc 3 , | ||
65 | .Xr free 3 | ||
66 | .Sh STANDARDS | ||
67 | The | ||
68 | .Fn calloc | ||
69 | function conforms to | ||
70 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/calloc.c b/src/lib/libc/stdlib/calloc.c new file mode 100644 index 0000000000..a2c4f84493 --- /dev/null +++ b/src/lib/libc/stdlib/calloc.c | |||
@@ -0,0 +1,53 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1990 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: calloc.c,v 1.3 1996/08/20 17:42:33 downsj Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | #include <string.h> | ||
40 | |||
41 | void * | ||
42 | calloc(num, size) | ||
43 | size_t num; | ||
44 | register size_t size; | ||
45 | { | ||
46 | register void *p; | ||
47 | |||
48 | size *= num; | ||
49 | p = malloc(size); | ||
50 | if (p) | ||
51 | memset(p, '\0', size); | ||
52 | return(p); | ||
53 | } | ||
diff --git a/src/lib/libc/stdlib/cfree.c b/src/lib/libc/stdlib/cfree.c new file mode 100644 index 0000000000..3af32039a9 --- /dev/null +++ b/src/lib/libc/stdlib/cfree.c | |||
@@ -0,0 +1,49 @@ | |||
1 | /* $OpenBSD: cfree.c,v 1.1 1996/08/21 03:47:22 tholo Exp $ */ | ||
2 | |||
3 | /* | ||
4 | * Copyright (c) 1996 SigmaSoft, Th. Lockert <tholo@sigmasoft.com> | ||
5 | * All rights reserved. | ||
6 | * | ||
7 | * Redistribution and use in source and binary forms, with or without | ||
8 | * modification, are permitted provided that the following conditions | ||
9 | * are met: | ||
10 | * 1. Redistributions of source code must retain the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer. | ||
12 | * 2. Redistributions in binary form must reproduce the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer in the | ||
14 | * documentation and/or other materials provided with the distribution. | ||
15 | * 3. All advertising materials mentioning features or use of this software | ||
16 | * must display the following acknowledgement: | ||
17 | * This product includes software developed by SigmaSoft, Th. Lockert. | ||
18 | * 4. The name of the author may not be used to endorse or promote products | ||
19 | * derived from this software without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, | ||
22 | * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY | ||
23 | * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL | ||
24 | * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
25 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
26 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | ||
27 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | ||
28 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | ||
29 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | ||
30 | * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
31 | */ | ||
32 | |||
33 | #if defined(LIBC_SCCS) && !defined(lint) | ||
34 | static char rcsid[] = "$OpenBSD: cfree.c,v 1.1 1996/08/21 03:47:22 tholo Exp $"; | ||
35 | #endif /* LIBC_SCCS and not lint */ | ||
36 | |||
37 | #include <sys/cdefs.h> | ||
38 | |||
39 | #ifdef __indr_reference | ||
40 | __indr_reference(free, cfree); | ||
41 | #else | ||
42 | |||
43 | void | ||
44 | cfree(p) | ||
45 | void *p; | ||
46 | { | ||
47 | free(p); | ||
48 | } | ||
49 | #endif | ||
diff --git a/src/lib/libc/stdlib/div.3 b/src/lib/libc/stdlib/div.3 new file mode 100644 index 0000000000..0d8c56d86b --- /dev/null +++ b/src/lib/libc/stdlib/div.3 | |||
@@ -0,0 +1,69 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" Chris Torek. | ||
6 | .\" Redistribution and use in source and binary forms, with or without | ||
7 | .\" modification, are permitted provided that the following conditions | ||
8 | .\" are met: | ||
9 | .\" 1. Redistributions of source code must retain the above copyright | ||
10 | .\" notice, this list of conditions and the following disclaimer. | ||
11 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer in the | ||
13 | .\" documentation and/or other materials provided with the distribution. | ||
14 | .\" 3. All advertising materials mentioning features or use of this software | ||
15 | .\" must display the following acknowledgement: | ||
16 | .\" This product includes software developed by the University of | ||
17 | .\" California, Berkeley and its contributors. | ||
18 | .\" 4. Neither the name of the University nor the names of its contributors | ||
19 | .\" may be used to endorse or promote products derived from this software | ||
20 | .\" without specific prior written permission. | ||
21 | .\" | ||
22 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
23 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
24 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
25 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
26 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
27 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
28 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
29 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
30 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
31 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
32 | .\" SUCH DAMAGE. | ||
33 | .\" | ||
34 | .\" $OpenBSD: div.3,v 1.2 1996/08/19 08:33:28 tholo Exp $ | ||
35 | .\" | ||
36 | .Dd April 19, 1991 | ||
37 | .Dt DIV 3 | ||
38 | .Os | ||
39 | .Sh NAME | ||
40 | .Nm div | ||
41 | .Nd return quotient and remainder from division | ||
42 | .Sh SYNOPSIS | ||
43 | .Fd #include <stdlib.h> | ||
44 | .Ft div_t | ||
45 | .Fn div "int num" "int denom" | ||
46 | .Sh DESCRIPTION | ||
47 | The | ||
48 | .Fn div | ||
49 | function | ||
50 | computes the value | ||
51 | .Fa num/denom | ||
52 | and returns the quotient and remainder in a structure named | ||
53 | .Fa div_t | ||
54 | that contains two | ||
55 | .Em int | ||
56 | members named | ||
57 | .Fa quot | ||
58 | and | ||
59 | .Fa rem . | ||
60 | .Sh SEE ALSO | ||
61 | .Xr ldiv 3 , | ||
62 | .Xr qdiv 3 , | ||
63 | .Xr math 3 | ||
64 | .Sh STANDARDS | ||
65 | The | ||
66 | .Fn div | ||
67 | function | ||
68 | conforms to | ||
69 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/div.c b/src/lib/libc/stdlib/div.c new file mode 100644 index 0000000000..c1fae29008 --- /dev/null +++ b/src/lib/libc/stdlib/div.c | |||
@@ -0,0 +1,79 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1990 Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * This code is derived from software contributed to Berkeley by | ||
6 | * Chris Torek. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * 1. Redistributions of source code must retain the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer. | ||
13 | * 2. Redistributions in binary form must reproduce the above copyright | ||
14 | * notice, this list of conditions and the following disclaimer in the | ||
15 | * documentation and/or other materials provided with the distribution. | ||
16 | * 3. All advertising materials mentioning features or use of this software | ||
17 | * must display the following acknowledgement: | ||
18 | * This product includes software developed by the University of | ||
19 | * California, Berkeley and its contributors. | ||
20 | * 4. Neither the name of the University nor the names of its contributors | ||
21 | * may be used to endorse or promote products derived from this software | ||
22 | * without specific prior written permission. | ||
23 | * | ||
24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | * SUCH DAMAGE. | ||
35 | */ | ||
36 | |||
37 | #if defined(LIBC_SCCS) && !defined(lint) | ||
38 | static char *rcsid = "$OpenBSD: div.c,v 1.2 1996/08/19 08:33:29 tholo Exp $"; | ||
39 | #endif /* LIBC_SCCS and not lint */ | ||
40 | |||
41 | #include <stdlib.h> /* div_t */ | ||
42 | |||
43 | div_t | ||
44 | div(num, denom) | ||
45 | int num, denom; | ||
46 | { | ||
47 | div_t r; | ||
48 | |||
49 | r.quot = num / denom; | ||
50 | r.rem = num % denom; | ||
51 | /* | ||
52 | * The ANSI standard says that |r.quot| <= |n/d|, where | ||
53 | * n/d is to be computed in infinite precision. In other | ||
54 | * words, we should always truncate the quotient towards | ||
55 | * 0, never -infinity. | ||
56 | * | ||
57 | * Machine division and remainer may work either way when | ||
58 | * one or both of n or d is negative. If only one is | ||
59 | * negative and r.quot has been truncated towards -inf, | ||
60 | * r.rem will have the same sign as denom and the opposite | ||
61 | * sign of num; if both are negative and r.quot has been | ||
62 | * truncated towards -inf, r.rem will be positive (will | ||
63 | * have the opposite sign of num). These are considered | ||
64 | * `wrong'. | ||
65 | * | ||
66 | * If both are num and denom are positive, r will always | ||
67 | * be positive. | ||
68 | * | ||
69 | * This all boils down to: | ||
70 | * if num >= 0, but r.rem < 0, we got the wrong answer. | ||
71 | * In that case, to get the right answer, add 1 to r.quot and | ||
72 | * subtract denom from r.rem. | ||
73 | */ | ||
74 | if (num >= 0 && r.rem < 0) { | ||
75 | r.quot++; | ||
76 | r.rem -= denom; | ||
77 | } | ||
78 | return (r); | ||
79 | } | ||
diff --git a/src/lib/libc/stdlib/drand48.c b/src/lib/libc/stdlib/drand48.c new file mode 100644 index 0000000000..02886d5b62 --- /dev/null +++ b/src/lib/libc/stdlib/drand48.c | |||
@@ -0,0 +1,26 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | */ | ||
13 | |||
14 | #if defined(LIBC_SCCS) && !defined(lint) | ||
15 | static char rcsid[] = "$OpenBSD: drand48.c,v 1.2 1996/08/19 08:33:29 tholo Exp $"; | ||
16 | #endif /* LIBC_SCCS and not lint */ | ||
17 | |||
18 | #include "rand48.h" | ||
19 | |||
20 | extern unsigned short __rand48_seed[3]; | ||
21 | |||
22 | double | ||
23 | drand48(void) | ||
24 | { | ||
25 | return erand48(__rand48_seed); | ||
26 | } | ||
diff --git a/src/lib/libc/stdlib/erand48.c b/src/lib/libc/stdlib/erand48.c new file mode 100644 index 0000000000..b92dacffcc --- /dev/null +++ b/src/lib/libc/stdlib/erand48.c | |||
@@ -0,0 +1,27 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | */ | ||
13 | |||
14 | #if defined(LIBC_SCCS) && !defined(lint) | ||
15 | static char rcsid[] = "$OpenBSD: erand48.c,v 1.2 1996/08/19 08:33:29 tholo Exp $"; | ||
16 | #endif /* LIBC_SCCS and not lint */ | ||
17 | |||
18 | #include "rand48.h" | ||
19 | |||
20 | double | ||
21 | erand48(unsigned short xseed[3]) | ||
22 | { | ||
23 | __dorand48(xseed); | ||
24 | return ldexp((double) xseed[0], -48) + | ||
25 | ldexp((double) xseed[1], -32) + | ||
26 | ldexp((double) xseed[2], -16); | ||
27 | } | ||
diff --git a/src/lib/libc/stdlib/exit.3 b/src/lib/libc/stdlib/exit.3 new file mode 100644 index 0000000000..6dd2affef9 --- /dev/null +++ b/src/lib/libc/stdlib/exit.3 | |||
@@ -0,0 +1,83 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: exit.3,v 1.2 1996/08/19 08:33:30 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt EXIT 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm exit | ||
43 | .Nd perform normal program termination | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft void | ||
47 | .Fn exit "int status" | ||
48 | .Sh DESCRIPTION | ||
49 | .Fn Exit | ||
50 | terminates a process. | ||
51 | .Pp | ||
52 | Before termination it performs the following functions in the | ||
53 | order listed: | ||
54 | .Bl -enum -offset indent | ||
55 | .It | ||
56 | Call the functions registered with the | ||
57 | .Xr atexit 3 | ||
58 | function, in the reverse order of their registration. | ||
59 | .It | ||
60 | Flush all open output streams. | ||
61 | .It | ||
62 | Close all open streams. | ||
63 | .It | ||
64 | Unlink all files created with the | ||
65 | .Xr tmpfile 3 | ||
66 | function. | ||
67 | .El | ||
68 | .Sh RETURN VALUES | ||
69 | The | ||
70 | .Fn exit | ||
71 | function | ||
72 | never returns. | ||
73 | .Sh SEE ALSO | ||
74 | .Xr _exit 2 , | ||
75 | .Xr atexit 3 , | ||
76 | .Xr intro 3 , | ||
77 | .Xr tmpfile 3 | ||
78 | .Sh STANDARDS | ||
79 | The | ||
80 | .Fn exit | ||
81 | function | ||
82 | conforms to | ||
83 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/exit.c b/src/lib/libc/stdlib/exit.c new file mode 100644 index 0000000000..e358c94fd6 --- /dev/null +++ b/src/lib/libc/stdlib/exit.c | |||
@@ -0,0 +1,60 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1990 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: exit.c,v 1.2 1996/08/19 08:33:30 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | #include <unistd.h> | ||
40 | #include "atexit.h" | ||
41 | |||
42 | void (*__cleanup)(); | ||
43 | |||
44 | /* | ||
45 | * Exit, flushing stdio buffers if necessary. | ||
46 | */ | ||
47 | void | ||
48 | exit(status) | ||
49 | int status; | ||
50 | { | ||
51 | register struct atexit *p; | ||
52 | register int n; | ||
53 | |||
54 | for (p = __atexit; p; p = p->next) | ||
55 | for (n = p->ind; --n >= 0;) | ||
56 | (*p->fns[n])(); | ||
57 | if (__cleanup) | ||
58 | (*__cleanup)(); | ||
59 | _exit(status); | ||
60 | } | ||
diff --git a/src/lib/libc/stdlib/getenv.3 b/src/lib/libc/stdlib/getenv.3 new file mode 100644 index 0000000000..24a8d3d095 --- /dev/null +++ b/src/lib/libc/stdlib/getenv.3 | |||
@@ -0,0 +1,151 @@ | |||
1 | .\" Copyright (c) 1988, 1991, 1993 | ||
2 | .\" The Regents of the University of California. All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: getenv.3,v 1.2 1996/08/10 05:03:00 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd December 11, 1993 | ||
39 | .Dt GETENV 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm getenv , | ||
43 | .Nm putenv , | ||
44 | .Nm setenv , | ||
45 | .Nm unsetenv | ||
46 | .Nd environment variable functions | ||
47 | .Sh SYNOPSIS | ||
48 | .Fd #include <stdlib.h> | ||
49 | .Ft char * | ||
50 | .Fn getenv "const char *name" | ||
51 | .Ft int | ||
52 | .Fn setenv "const char *name" "const char *value" "int overwrite" | ||
53 | .Ft int | ||
54 | .Fn putenv "const char *string" | ||
55 | .Ft void | ||
56 | .Fn unsetenv "const char *name" | ||
57 | .Sh DESCRIPTION | ||
58 | These functions set, unset and fetch environment variables from the | ||
59 | host | ||
60 | .Em environment list . | ||
61 | For compatibility with differing environment conventions, | ||
62 | the given arguments | ||
63 | .Ar name | ||
64 | and | ||
65 | .Ar value | ||
66 | may be appended and prepended, | ||
67 | respectively, | ||
68 | with an equal sign | ||
69 | .Dq Li \&= . | ||
70 | .Pp | ||
71 | The | ||
72 | .Fn getenv | ||
73 | function obtains the current value of the environment variable, | ||
74 | .Ar name . | ||
75 | If the variable | ||
76 | .Ar name | ||
77 | is not in the current environment, | ||
78 | a null pointer is returned. | ||
79 | .Pp | ||
80 | The | ||
81 | .Fn setenv | ||
82 | function inserts or resets the environment variable | ||
83 | .Ar name | ||
84 | in the current environment list. | ||
85 | If the variable | ||
86 | .Ar name | ||
87 | does not exist in the list, | ||
88 | it is inserted with the given | ||
89 | .Ar value. | ||
90 | If the variable does exist, the argument | ||
91 | .Ar overwrite | ||
92 | is tested; if | ||
93 | .Ar overwrite is | ||
94 | zero, the | ||
95 | variable is not reset, otherwise it is reset | ||
96 | to the given | ||
97 | .Ar value . | ||
98 | .Pp | ||
99 | The | ||
100 | .Fn putenv | ||
101 | function takes an argument of the form ``name=value'' and is | ||
102 | equivalent to: | ||
103 | .Bd -literal -offset indent | ||
104 | setenv(name, value, 1); | ||
105 | .Ed | ||
106 | .Pp | ||
107 | The | ||
108 | .Fn unsetenv | ||
109 | function | ||
110 | deletes all instances of the variable name pointed to by | ||
111 | .Fa name | ||
112 | from the list. | ||
113 | .Sh RETURN VALUES | ||
114 | The functions | ||
115 | .Fn setenv | ||
116 | and | ||
117 | .Fn putenv | ||
118 | return zero if successful; otherwise the global variable | ||
119 | .Va errno | ||
120 | is set to indicate the error and a | ||
121 | \-1 is returned. | ||
122 | .Sh ERRORS | ||
123 | .Bl -tag -width [ENOMEM] | ||
124 | .It Bq Er ENOMEM | ||
125 | The function | ||
126 | .Fn setenv | ||
127 | or | ||
128 | .Fn putenv | ||
129 | failed because they were unable to allocate memory for the environment. | ||
130 | .El | ||
131 | .Sh SEE ALSO | ||
132 | .Xr csh 1 , | ||
133 | .Xr sh 1 , | ||
134 | .Xr execve 2 , | ||
135 | .Xr environ 7 | ||
136 | .Sh STANDARDS | ||
137 | The | ||
138 | .Fn getenv | ||
139 | function conforms to | ||
140 | .St -ansiC . | ||
141 | .Sh HISTORY | ||
142 | The functions | ||
143 | .Fn setenv | ||
144 | and | ||
145 | .Fn unsetenv | ||
146 | appeared in | ||
147 | .At v7 . | ||
148 | The | ||
149 | .Fn putenv | ||
150 | function appeared in | ||
151 | .Bx 4.3 Reno . | ||
diff --git a/src/lib/libc/stdlib/getenv.c b/src/lib/libc/stdlib/getenv.c new file mode 100644 index 0000000000..4db86df915 --- /dev/null +++ b/src/lib/libc/stdlib/getenv.c | |||
@@ -0,0 +1,89 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1987, 1993 | ||
3 | * The Regents of the University of California. All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: getenv.c,v 1.4 1998/07/16 18:02:33 deraadt Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | #include <string.h> | ||
40 | |||
41 | /* | ||
42 | * __findenv -- | ||
43 | * Returns pointer to value associated with name, if any, else NULL. | ||
44 | * Sets offset to be the offset of the name/value combination in the | ||
45 | * environmental array, for use by setenv(3) and unsetenv(3). | ||
46 | * Explicitly removes '=' in argument name. | ||
47 | * | ||
48 | * This routine *should* be a static; don't use it. | ||
49 | */ | ||
50 | char * | ||
51 | __findenv(name, offset) | ||
52 | register const char *name; | ||
53 | int *offset; | ||
54 | { | ||
55 | extern char **environ; | ||
56 | register int len, i; | ||
57 | register const char *np; | ||
58 | register char **p, *cp; | ||
59 | |||
60 | if (name == NULL || environ == NULL) | ||
61 | return (NULL); | ||
62 | for (np = name; *np && *np != '='; ++np) | ||
63 | ; | ||
64 | len = np - name; | ||
65 | for (p = environ; (cp = *p) != NULL; ++p) { | ||
66 | for (np = name, i = len; i && *cp; i--) | ||
67 | if (*cp++ != *np++) | ||
68 | break; | ||
69 | if (i == 0 && *cp++ == '=') { | ||
70 | *offset = p - environ; | ||
71 | return (cp); | ||
72 | } | ||
73 | } | ||
74 | return (NULL); | ||
75 | } | ||
76 | |||
77 | /* | ||
78 | * getenv -- | ||
79 | * Returns ptr to value associated with name, if any, else NULL. | ||
80 | */ | ||
81 | char * | ||
82 | getenv(name) | ||
83 | const char *name; | ||
84 | { | ||
85 | int offset; | ||
86 | char *__findenv(); | ||
87 | |||
88 | return(__findenv(name, &offset)); | ||
89 | } | ||
diff --git a/src/lib/libc/stdlib/getopt.3 b/src/lib/libc/stdlib/getopt.3 new file mode 100644 index 0000000000..4340ff54fd --- /dev/null +++ b/src/lib/libc/stdlib/getopt.3 | |||
@@ -0,0 +1,261 @@ | |||
1 | .\" Copyright (c) 1988, 1991, 1993 | ||
2 | .\" The Regents of the University of California. All rights reserved. | ||
3 | .\" | ||
4 | .\" Redistribution and use in source and binary forms, with or without | ||
5 | .\" modification, are permitted provided that the following conditions | ||
6 | .\" are met: | ||
7 | .\" 1. Redistributions of source code must retain the above copyright | ||
8 | .\" notice, this list of conditions and the following disclaimer. | ||
9 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
10 | .\" notice, this list of conditions and the following disclaimer in the | ||
11 | .\" documentation and/or other materials provided with the distribution. | ||
12 | .\" 3. All advertising materials mentioning features or use of this software | ||
13 | .\" must display the following acknowledgement: | ||
14 | .\" This product includes software developed by the University of | ||
15 | .\" California, Berkeley and its contributors. | ||
16 | .\" 4. Neither the name of the University nor the names of its contributors | ||
17 | .\" may be used to endorse or promote products derived from this software | ||
18 | .\" without specific prior written permission. | ||
19 | .\" | ||
20 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
21 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
22 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
23 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
24 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
25 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
26 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
27 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
28 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
29 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
30 | .\" SUCH DAMAGE. | ||
31 | .\" | ||
32 | .\" $OpenBSD: getopt.3,v 1.6 1998/05/05 19:36:03 deraadt Exp $ | ||
33 | .\" | ||
34 | .Dd April 19, 1994 | ||
35 | .Dt GETOPT 3 | ||
36 | .Os BSD 4.3 | ||
37 | .Sh NAME | ||
38 | .Nm getopt | ||
39 | .Nd get option character from command line argument list | ||
40 | .Sh SYNOPSIS | ||
41 | .Fd #include <unistd.h> | ||
42 | .Vt extern char *optarg; | ||
43 | .Vt extern int optind; | ||
44 | .Vt extern int optopt; | ||
45 | .Vt extern int opterr; | ||
46 | .Vt extern int optreset; | ||
47 | .Ft int | ||
48 | .Fn getopt "int argc" "char * const *argv" "const char *optstring" | ||
49 | .Sh DESCRIPTION | ||
50 | The | ||
51 | .Fn getopt | ||
52 | function incrementally parses a command line argument list | ||
53 | .Fa argv | ||
54 | and returns the next | ||
55 | .Em known | ||
56 | option character. | ||
57 | An option character is | ||
58 | .Em known | ||
59 | if it has been specified in the string of accepted option characters, | ||
60 | .Fa optstring . | ||
61 | .Pp | ||
62 | The option string | ||
63 | .Fa optstring | ||
64 | may contain the following elements: individual characters, and | ||
65 | characters followed by a colon to indicate an option argument | ||
66 | is to follow. | ||
67 | For example, an option string | ||
68 | .Li "\&""x"" | ||
69 | recognizes an option | ||
70 | .Dq Fl x , | ||
71 | and an option string | ||
72 | .Li "\&""x:"" | ||
73 | recognizes an option and argument | ||
74 | .Dq Fl x Ar argument . | ||
75 | It does not matter to | ||
76 | .Fn getopt | ||
77 | if a following argument has leading white space. | ||
78 | .Pp | ||
79 | On return from | ||
80 | .Fn getopt , | ||
81 | .Va optarg | ||
82 | points to an option argument, if it is anticipated, | ||
83 | and the variable | ||
84 | .Va optind | ||
85 | contains the index to the next | ||
86 | .Fa argv | ||
87 | argument for a subsequent call | ||
88 | to | ||
89 | .Fn getopt . | ||
90 | The variable | ||
91 | .Va optopt | ||
92 | saves the last | ||
93 | .Em known | ||
94 | option character returned by | ||
95 | .Fn getopt . | ||
96 | .Pp | ||
97 | The variable | ||
98 | .Va opterr | ||
99 | and | ||
100 | .Va optind | ||
101 | are both initialized to 1. | ||
102 | The | ||
103 | .Va optind | ||
104 | variable may be set to another value before a set of calls to | ||
105 | .Fn getopt | ||
106 | in order to skip over more or less argv entries. | ||
107 | .Pp | ||
108 | In order to use | ||
109 | .Fn getopt | ||
110 | to evaluate multiple sets of arguments, or to evaluate a single set of | ||
111 | arguments multiple times, | ||
112 | the variable | ||
113 | .Va optreset | ||
114 | must be set to 1 before the second and each additional set of calls to | ||
115 | .Fn getopt , | ||
116 | and the variable | ||
117 | .Va optind | ||
118 | must be reinitialized. | ||
119 | .Pp | ||
120 | The | ||
121 | .Fn getopt | ||
122 | function | ||
123 | returns \-1 | ||
124 | when the argument list is exhausted, or a non-recognized | ||
125 | option is encountered. | ||
126 | The interpretation of options in the argument list may be cancelled | ||
127 | by the option | ||
128 | .Ql -- | ||
129 | (double dash) which causes | ||
130 | .Fn getopt | ||
131 | to signal the end of argument processing and returns \-1. | ||
132 | When all options have been processed (i.e., up to the first non-option | ||
133 | argument), | ||
134 | .Fn getopt | ||
135 | returns \-1. | ||
136 | .Sh DIAGNOSTICS | ||
137 | If the | ||
138 | .Fn getopt | ||
139 | function encounters a character not found in the string | ||
140 | .Va optstring | ||
141 | or detects | ||
142 | a missing option argument it writes an error message to | ||
143 | .Em stderr | ||
144 | and returns | ||
145 | .Ql ? . | ||
146 | Setting | ||
147 | .Va opterr | ||
148 | to a zero will disable these error messages. | ||
149 | If | ||
150 | .Va optstring | ||
151 | has a leading | ||
152 | .Ql \&: | ||
153 | then a missing option argument causes a | ||
154 | .Ql \&: | ||
155 | to be returned in addition to suppressing any error messages. | ||
156 | .Pp | ||
157 | Option arguments are allowed to begin with | ||
158 | .Dq Li \- ; | ||
159 | this is reasonable but | ||
160 | reduces the amount of error checking possible. | ||
161 | .Sh EXTENSIONS | ||
162 | The | ||
163 | .Va optreset | ||
164 | variable was added to make it possible to call the | ||
165 | .Fn getopt | ||
166 | function multiple times. | ||
167 | This is an extension to the | ||
168 | .St -p1003.2 | ||
169 | specification. | ||
170 | .Sh EXAMPLE | ||
171 | .Bd -literal -compact | ||
172 | extern char *optarg; | ||
173 | extern int optind; | ||
174 | int bflag, ch, fd; | ||
175 | |||
176 | bflag = 0; | ||
177 | while ((ch = getopt(argc, argv, "bf:")) != -1) { | ||
178 | switch (ch) { | ||
179 | case 'b': | ||
180 | bflag = 1; | ||
181 | break; | ||
182 | case 'f': | ||
183 | if ((fd = open(optarg, O_RDONLY, 0)) < 0) { | ||
184 | (void)fprintf(stderr, | ||
185 | "myname: %s: %s\en", optarg, strerror(errno)); | ||
186 | exit(1); | ||
187 | } | ||
188 | break; | ||
189 | case '?': | ||
190 | default: | ||
191 | usage(); | ||
192 | } | ||
193 | } | ||
194 | argc -= optind; | ||
195 | argv += optind; | ||
196 | .Ed | ||
197 | .Sh HISTORY | ||
198 | The | ||
199 | .Fn getopt | ||
200 | function appeared | ||
201 | .Bx 4.3 . | ||
202 | .Sh BUGS | ||
203 | The | ||
204 | .Fn getopt | ||
205 | function was once specified to return | ||
206 | .Dv EOF | ||
207 | instead of \-1. | ||
208 | This was changed by | ||
209 | .St -p1003.2-92 | ||
210 | to decouple | ||
211 | .Fn getopt | ||
212 | from | ||
213 | .Pa <stdio.h> . | ||
214 | .Pp | ||
215 | A single dash | ||
216 | .Dq Li - | ||
217 | may be specified as a character in | ||
218 | .Fa optstring , | ||
219 | however it should | ||
220 | .Em never | ||
221 | have an argument associated with it. | ||
222 | This allows | ||
223 | .Fn getopt | ||
224 | to be used with programs that expect | ||
225 | .Dq Li - | ||
226 | as an option flag. | ||
227 | This practice is wrong, and should not be used in any current development. | ||
228 | It is provided for backward compatibility | ||
229 | .Em only . | ||
230 | By default, a single dash causes | ||
231 | .Fn getopt | ||
232 | to return \-1. | ||
233 | This is, we believe, compatible with System V. | ||
234 | .Pp | ||
235 | It is also possible to handle digits as option letters. | ||
236 | This allows | ||
237 | .Fn getopt | ||
238 | to be used with programs that expect a number | ||
239 | .Pq Dq Li \&-\&3 | ||
240 | as an option. | ||
241 | This practice is wrong, and should not be used in any current development. | ||
242 | It is provided for backward compatibility | ||
243 | .Em only . | ||
244 | The following code fragment works in most cases. | ||
245 | .Bd -literal -offset indent | ||
246 | int length; | ||
247 | char *p; | ||
248 | |||
249 | while ((c = getopt(argc, argv, "0123456789")) != -1) | ||
250 | switch (c) { | ||
251 | case '0': case '1': case '2': case '3': case '4': | ||
252 | case '5': case '6': case '7': case '8': case '9': | ||
253 | p = argv[optind - 1]; | ||
254 | if (p[0] == '-' && p[1] == ch && !p[2]) | ||
255 | length = atoi(++p); | ||
256 | else | ||
257 | length = atoi(argv[optind] + 1); | ||
258 | break; | ||
259 | } | ||
260 | } | ||
261 | .Ed | ||
diff --git a/src/lib/libc/stdlib/getopt.c b/src/lib/libc/stdlib/getopt.c new file mode 100644 index 0000000000..b7f6163662 --- /dev/null +++ b/src/lib/libc/stdlib/getopt.c | |||
@@ -0,0 +1,117 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1987, 1993, 1994 | ||
3 | * The Regents of the University of California. All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: getopt.c,v 1.2 1996/08/19 08:33:32 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdio.h> | ||
39 | #include <stdlib.h> | ||
40 | #include <string.h> | ||
41 | |||
42 | int opterr = 1, /* if error message should be printed */ | ||
43 | optind = 1, /* index into parent argv vector */ | ||
44 | optopt, /* character checked for validity */ | ||
45 | optreset; /* reset getopt */ | ||
46 | char *optarg; /* argument associated with option */ | ||
47 | |||
48 | #define BADCH (int)'?' | ||
49 | #define BADARG (int)':' | ||
50 | #define EMSG "" | ||
51 | |||
52 | /* | ||
53 | * getopt -- | ||
54 | * Parse argc/argv argument vector. | ||
55 | */ | ||
56 | int | ||
57 | getopt(nargc, nargv, ostr) | ||
58 | int nargc; | ||
59 | char * const *nargv; | ||
60 | const char *ostr; | ||
61 | { | ||
62 | extern char *__progname; | ||
63 | static char *place = EMSG; /* option letter processing */ | ||
64 | char *oli; /* option letter list index */ | ||
65 | |||
66 | if (optreset || !*place) { /* update scanning pointer */ | ||
67 | optreset = 0; | ||
68 | if (optind >= nargc || *(place = nargv[optind]) != '-') { | ||
69 | place = EMSG; | ||
70 | return (-1); | ||
71 | } | ||
72 | if (place[1] && *++place == '-') { /* found "--" */ | ||
73 | ++optind; | ||
74 | place = EMSG; | ||
75 | return (-1); | ||
76 | } | ||
77 | } /* option letter okay? */ | ||
78 | if ((optopt = (int)*place++) == (int)':' || | ||
79 | !(oli = strchr(ostr, optopt))) { | ||
80 | /* | ||
81 | * if the user didn't specify '-' as an option, | ||
82 | * assume it means -1. | ||
83 | */ | ||
84 | if (optopt == (int)'-') | ||
85 | return (-1); | ||
86 | if (!*place) | ||
87 | ++optind; | ||
88 | if (opterr && *ostr != ':') | ||
89 | (void)fprintf(stderr, | ||
90 | "%s: illegal option -- %c\n", __progname, optopt); | ||
91 | return (BADCH); | ||
92 | } | ||
93 | if (*++oli != ':') { /* don't need argument */ | ||
94 | optarg = NULL; | ||
95 | if (!*place) | ||
96 | ++optind; | ||
97 | } | ||
98 | else { /* need an argument */ | ||
99 | if (*place) /* no white space */ | ||
100 | optarg = place; | ||
101 | else if (nargc <= ++optind) { /* no arg */ | ||
102 | place = EMSG; | ||
103 | if (*ostr == ':') | ||
104 | return (BADARG); | ||
105 | if (opterr) | ||
106 | (void)fprintf(stderr, | ||
107 | "%s: option requires an argument -- %c\n", | ||
108 | __progname, optopt); | ||
109 | return (BADCH); | ||
110 | } | ||
111 | else /* white space */ | ||
112 | optarg = nargv[optind]; | ||
113 | place = EMSG; | ||
114 | ++optind; | ||
115 | } | ||
116 | return (optopt); /* dump back option letter */ | ||
117 | } | ||
diff --git a/src/lib/libc/stdlib/getsubopt.3 b/src/lib/libc/stdlib/getsubopt.3 new file mode 100644 index 0000000000..8acc91bdd1 --- /dev/null +++ b/src/lib/libc/stdlib/getsubopt.3 | |||
@@ -0,0 +1,148 @@ | |||
1 | .\" $OpenBSD: getsubopt.3,v 1.2 1998/06/15 17:55:07 mickey Exp $ | ||
2 | .\" | ||
3 | .\" Copyright (c) 1990, 1991, 1993 | ||
4 | .\" The Regents of the University of California. All rights reserved. | ||
5 | .\" | ||
6 | .\" Redistribution and use in source and binary forms, with or without | ||
7 | .\" modification, are permitted provided that the following conditions | ||
8 | .\" are met: | ||
9 | .\" 1. Redistributions of source code must retain the above copyright | ||
10 | .\" notice, this list of conditions and the following disclaimer. | ||
11 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer in the | ||
13 | .\" documentation and/or other materials provided with the distribution. | ||
14 | .\" 3. All advertising materials mentioning features or use of this software | ||
15 | .\" must display the following acknowledgement: | ||
16 | .\" This product includes software developed by the University of | ||
17 | .\" California, Berkeley and its contributors. | ||
18 | .\" 4. Neither the name of the University nor the names of its contributors | ||
19 | .\" may be used to endorse or promote products derived from this software | ||
20 | .\" without specific prior written permission. | ||
21 | .\" | ||
22 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
23 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
24 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
25 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
26 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
27 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
28 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
29 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
30 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
31 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
32 | .\" SUCH DAMAGE. | ||
33 | .\" | ||
34 | .\" @(#)getsubopt.3 8.1 (Berkeley) 6/9/93 | ||
35 | .\" | ||
36 | .Dd June 9, 1993 | ||
37 | .Dt GETSUBOPT 3 | ||
38 | .Os | ||
39 | .Sh NAME | ||
40 | .Nm getsubopt | ||
41 | .Nd get sub options from an argument | ||
42 | .Sh SYNOPSIS | ||
43 | .Fd #include <stdlib.h> | ||
44 | .Vt extern char *suboptarg | ||
45 | .Ft int | ||
46 | .Fn getsubopt "char **optionp" "char * const *tokens" "char **valuep" | ||
47 | .Sh DESCRIPTION | ||
48 | The | ||
49 | .Fn getsubopt | ||
50 | function | ||
51 | parses a string containing tokens delimited by one or more tab, space or | ||
52 | comma | ||
53 | .Pq Ql \&, | ||
54 | characters. | ||
55 | It is intended for use in parsing groups of option arguments provided | ||
56 | as part of a utility command line. | ||
57 | .Pp | ||
58 | The argument | ||
59 | .Fa optionp | ||
60 | is a pointer to a pointer to the string. | ||
61 | The argument | ||
62 | .Fa tokens | ||
63 | is a pointer to a | ||
64 | .Dv NULL Ns -terminated | ||
65 | array of pointers to strings. | ||
66 | .Pp | ||
67 | The | ||
68 | .Fn getsubopt | ||
69 | function | ||
70 | returns the zero-based offset of the pointer in the | ||
71 | .Fa tokens | ||
72 | array referencing a string which matches the first token | ||
73 | in the string, or, \-1 if the string contains no tokens or | ||
74 | .Fa tokens | ||
75 | does not contain a matching string. | ||
76 | .Pp | ||
77 | If the token is of the form ``name=value'', the location referenced by | ||
78 | .Fa valuep | ||
79 | will be set to point to the start of the ``value'' portion of the token. | ||
80 | .Pp | ||
81 | On return from | ||
82 | .Fn getsubopt , | ||
83 | .Fa optionp | ||
84 | will be set to point to the start of the next token in the string, | ||
85 | or the null at the end of the string if no more tokens are present. | ||
86 | The external variable | ||
87 | .Fa suboptarg | ||
88 | will be set to point to the start of the current token, or | ||
89 | .Dv NULL | ||
90 | if no | ||
91 | tokens were present. | ||
92 | The argument | ||
93 | .Fa valuep | ||
94 | will be set to point to the ``value'' portion of the token, or | ||
95 | .Dv NULL | ||
96 | if no ``value'' portion was present. | ||
97 | .Sh EXAMPLE | ||
98 | .Bd -literal -compact | ||
99 | char *tokens[] = { | ||
100 | #define ONE 0 | ||
101 | "one", | ||
102 | #define TWO 1 | ||
103 | "two", | ||
104 | NULL | ||
105 | }; | ||
106 | |||
107 | \&... | ||
108 | |||
109 | extern char *optarg, *suboptarg; | ||
110 | char *options, *value; | ||
111 | |||
112 | while ((ch = getopt(argc, argv, "ab:")) != \-1) { | ||
113 | switch(ch) { | ||
114 | case 'a': | ||
115 | /* process ``a'' option */ | ||
116 | break; | ||
117 | case 'b': | ||
118 | options = optarg; | ||
119 | while (*options) { | ||
120 | switch(getsubopt(&options, tokens, &value)) { | ||
121 | case ONE: | ||
122 | /* process ``one'' sub option */ | ||
123 | break; | ||
124 | case TWO: | ||
125 | /* process ``two'' sub option */ | ||
126 | if (!value) | ||
127 | error("no value for two"); | ||
128 | i = atoi(value); | ||
129 | break; | ||
130 | case \-1: | ||
131 | if (suboptarg) | ||
132 | error("illegal sub option %s", | ||
133 | suboptarg); | ||
134 | else | ||
135 | error("missing sub option"); | ||
136 | break; | ||
137 | } | ||
138 | break; | ||
139 | } | ||
140 | .Ed | ||
141 | .Sh SEE ALSO | ||
142 | .Xr getopt 3 , | ||
143 | .Xr strsep 3 | ||
144 | .Sh HISTORY | ||
145 | The | ||
146 | .Fn getsubopt | ||
147 | function first appeared in | ||
148 | .Bx 4.4 . | ||
diff --git a/src/lib/libc/stdlib/getsubopt.c b/src/lib/libc/stdlib/getsubopt.c new file mode 100644 index 0000000000..1667a31d7d --- /dev/null +++ b/src/lib/libc/stdlib/getsubopt.c | |||
@@ -0,0 +1,106 @@ | |||
1 | /* $OpenBSD: getsubopt.c,v 1.1 1997/08/20 04:02:17 millert Exp $ */ | ||
2 | |||
3 | /*- | ||
4 | * Copyright (c) 1990, 1993 | ||
5 | * The Regents of the University of California. All rights reserved. | ||
6 | * | ||
7 | * Redistribution and use in source and binary forms, with or without | ||
8 | * modification, are permitted provided that the following conditions | ||
9 | * are met: | ||
10 | * 1. Redistributions of source code must retain the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer. | ||
12 | * 2. Redistributions in binary form must reproduce the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer in the | ||
14 | * documentation and/or other materials provided with the distribution. | ||
15 | * 3. All advertising materials mentioning features or use of this software | ||
16 | * must display the following acknowledgement: | ||
17 | * This product includes software developed by the University of | ||
18 | * California, Berkeley and its contributors. | ||
19 | * 4. Neither the name of the University nor the names of its contributors | ||
20 | * may be used to endorse or promote products derived from this software | ||
21 | * without specific prior written permission. | ||
22 | * | ||
23 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
24 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
25 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
26 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
27 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
28 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
29 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
30 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
31 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
32 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
33 | * SUCH DAMAGE. | ||
34 | */ | ||
35 | |||
36 | #ifndef lint | ||
37 | #if 0 | ||
38 | static char sccsid[] = "@(#)getsubopt.c 8.1 (Berkeley) 6/4/93"; | ||
39 | #else | ||
40 | static char rcsid[] = "$OpenBSD: getsubopt.c,v 1.1 1997/08/20 04:02:17 millert Exp $"; | ||
41 | #endif | ||
42 | #endif /* not lint */ | ||
43 | |||
44 | #include <unistd.h> | ||
45 | #include <stdlib.h> | ||
46 | #include <string.h> | ||
47 | |||
48 | /* | ||
49 | * The SVID interface to getsubopt provides no way of figuring out which | ||
50 | * part of the suboptions list wasn't matched. This makes error messages | ||
51 | * tricky... The extern variable suboptarg is a pointer to the token | ||
52 | * which didn't match. | ||
53 | */ | ||
54 | char *suboptarg; | ||
55 | |||
56 | int | ||
57 | getsubopt(optionp, tokens, valuep) | ||
58 | register char **optionp, **valuep; | ||
59 | register char * const *tokens; | ||
60 | { | ||
61 | register int cnt; | ||
62 | register char *p; | ||
63 | |||
64 | suboptarg = *valuep = NULL; | ||
65 | |||
66 | if (!optionp || !*optionp) | ||
67 | return(-1); | ||
68 | |||
69 | /* skip leading white-space, commas */ | ||
70 | for (p = *optionp; *p && (*p == ',' || *p == ' ' || *p == '\t'); ++p); | ||
71 | |||
72 | if (!*p) { | ||
73 | *optionp = p; | ||
74 | return(-1); | ||
75 | } | ||
76 | |||
77 | /* save the start of the token, and skip the rest of the token. */ | ||
78 | for (suboptarg = p; | ||
79 | *++p && *p != ',' && *p != '=' && *p != ' ' && *p != '\t';); | ||
80 | |||
81 | if (*p) { | ||
82 | /* | ||
83 | * If there's an equals sign, set the value pointer, and | ||
84 | * skip over the value part of the token. Terminate the | ||
85 | * token. | ||
86 | */ | ||
87 | if (*p == '=') { | ||
88 | *p = '\0'; | ||
89 | for (*valuep = ++p; | ||
90 | *p && *p != ',' && *p != ' ' && *p != '\t'; ++p); | ||
91 | if (*p) | ||
92 | *p++ = '\0'; | ||
93 | } else | ||
94 | *p++ = '\0'; | ||
95 | /* Skip any whitespace or commas after this token. */ | ||
96 | for (; *p && (*p == ',' || *p == ' ' || *p == '\t'); ++p); | ||
97 | } | ||
98 | |||
99 | /* set optionp for next round. */ | ||
100 | *optionp = p; | ||
101 | |||
102 | for (cnt = 0; *tokens; ++tokens, ++cnt) | ||
103 | if (!strcmp(suboptarg, *tokens)) | ||
104 | return(cnt); | ||
105 | return(-1); | ||
106 | } | ||
diff --git a/src/lib/libc/stdlib/heapsort.c b/src/lib/libc/stdlib/heapsort.c new file mode 100644 index 0000000000..e3e4392e05 --- /dev/null +++ b/src/lib/libc/stdlib/heapsort.c | |||
@@ -0,0 +1,183 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1991, 1993 | ||
3 | * The Regents of the University of California. All rights reserved. | ||
4 | * | ||
5 | * This code is derived from software contributed to Berkeley by | ||
6 | * Ronnie Kon at Mindcraft Inc., Kevin Lew and Elmer Yglesias. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * 1. Redistributions of source code must retain the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer. | ||
13 | * 2. Redistributions in binary form must reproduce the above copyright | ||
14 | * notice, this list of conditions and the following disclaimer in the | ||
15 | * documentation and/or other materials provided with the distribution. | ||
16 | * 3. All advertising materials mentioning features or use of this software | ||
17 | * must display the following acknowledgement: | ||
18 | * This product includes software developed by the University of | ||
19 | * California, Berkeley and its contributors. | ||
20 | * 4. Neither the name of the University nor the names of its contributors | ||
21 | * may be used to endorse or promote products derived from this software | ||
22 | * without specific prior written permission. | ||
23 | * | ||
24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | * SUCH DAMAGE. | ||
35 | */ | ||
36 | |||
37 | #if defined(LIBC_SCCS) && !defined(lint) | ||
38 | static char *rcsid = "$OpenBSD: heapsort.c,v 1.2 1996/08/19 08:33:32 tholo Exp $"; | ||
39 | #endif /* LIBC_SCCS and not lint */ | ||
40 | |||
41 | #include <sys/types.h> | ||
42 | #include <errno.h> | ||
43 | #include <stdlib.h> | ||
44 | |||
45 | /* | ||
46 | * Swap two areas of size number of bytes. Although qsort(3) permits random | ||
47 | * blocks of memory to be sorted, sorting pointers is almost certainly the | ||
48 | * common case (and, were it not, could easily be made so). Regardless, it | ||
49 | * isn't worth optimizing; the SWAP's get sped up by the cache, and pointer | ||
50 | * arithmetic gets lost in the time required for comparison function calls. | ||
51 | */ | ||
52 | #define SWAP(a, b, count, size, tmp) { \ | ||
53 | count = size; \ | ||
54 | do { \ | ||
55 | tmp = *a; \ | ||
56 | *a++ = *b; \ | ||
57 | *b++ = tmp; \ | ||
58 | } while (--count); \ | ||
59 | } | ||
60 | |||
61 | /* Copy one block of size size to another. */ | ||
62 | #define COPY(a, b, count, size, tmp1, tmp2) { \ | ||
63 | count = size; \ | ||
64 | tmp1 = a; \ | ||
65 | tmp2 = b; \ | ||
66 | do { \ | ||
67 | *tmp1++ = *tmp2++; \ | ||
68 | } while (--count); \ | ||
69 | } | ||
70 | |||
71 | /* | ||
72 | * Build the list into a heap, where a heap is defined such that for | ||
73 | * the records K1 ... KN, Kj/2 >= Kj for 1 <= j/2 <= j <= N. | ||
74 | * | ||
75 | * There two cases. If j == nmemb, select largest of Ki and Kj. If | ||
76 | * j < nmemb, select largest of Ki, Kj and Kj+1. | ||
77 | */ | ||
78 | #define CREATE(initval, nmemb, par_i, child_i, par, child, size, count, tmp) { \ | ||
79 | for (par_i = initval; (child_i = par_i * 2) <= nmemb; \ | ||
80 | par_i = child_i) { \ | ||
81 | child = base + child_i * size; \ | ||
82 | if (child_i < nmemb && compar(child, child + size) < 0) { \ | ||
83 | child += size; \ | ||
84 | ++child_i; \ | ||
85 | } \ | ||
86 | par = base + par_i * size; \ | ||
87 | if (compar(child, par) <= 0) \ | ||
88 | break; \ | ||
89 | SWAP(par, child, count, size, tmp); \ | ||
90 | } \ | ||
91 | } | ||
92 | |||
93 | /* | ||
94 | * Select the top of the heap and 'heapify'. Since by far the most expensive | ||
95 | * action is the call to the compar function, a considerable optimization | ||
96 | * in the average case can be achieved due to the fact that k, the displaced | ||
97 | * elememt, is ususally quite small, so it would be preferable to first | ||
98 | * heapify, always maintaining the invariant that the larger child is copied | ||
99 | * over its parent's record. | ||
100 | * | ||
101 | * Then, starting from the *bottom* of the heap, finding k's correct place, | ||
102 | * again maintianing the invariant. As a result of the invariant no element | ||
103 | * is 'lost' when k is assigned its correct place in the heap. | ||
104 | * | ||
105 | * The time savings from this optimization are on the order of 15-20% for the | ||
106 | * average case. See Knuth, Vol. 3, page 158, problem 18. | ||
107 | * | ||
108 | * XXX Don't break the #define SELECT line, below. Reiser cpp gets upset. | ||
109 | */ | ||
110 | #define SELECT(par_i, child_i, nmemb, par, child, size, k, count, tmp1, tmp2) { \ | ||
111 | for (par_i = 1; (child_i = par_i * 2) <= nmemb; par_i = child_i) { \ | ||
112 | child = base + child_i * size; \ | ||
113 | if (child_i < nmemb && compar(child, child + size) < 0) { \ | ||
114 | child += size; \ | ||
115 | ++child_i; \ | ||
116 | } \ | ||
117 | par = base + par_i * size; \ | ||
118 | COPY(par, child, count, size, tmp1, tmp2); \ | ||
119 | } \ | ||
120 | for (;;) { \ | ||
121 | child_i = par_i; \ | ||
122 | par_i = child_i / 2; \ | ||
123 | child = base + child_i * size; \ | ||
124 | par = base + par_i * size; \ | ||
125 | if (child_i == 1 || compar(k, par) < 0) { \ | ||
126 | COPY(child, k, count, size, tmp1, tmp2); \ | ||
127 | break; \ | ||
128 | } \ | ||
129 | COPY(child, par, count, size, tmp1, tmp2); \ | ||
130 | } \ | ||
131 | } | ||
132 | |||
133 | /* | ||
134 | * Heapsort -- Knuth, Vol. 3, page 145. Runs in O (N lg N), both average | ||
135 | * and worst. While heapsort is faster than the worst case of quicksort, | ||
136 | * the BSD quicksort does median selection so that the chance of finding | ||
137 | * a data set that will trigger the worst case is nonexistent. Heapsort's | ||
138 | * only advantage over quicksort is that it requires little additional memory. | ||
139 | */ | ||
140 | int | ||
141 | heapsort(vbase, nmemb, size, compar) | ||
142 | void *vbase; | ||
143 | size_t nmemb, size; | ||
144 | int (*compar) __P((const void *, const void *)); | ||
145 | { | ||
146 | register int cnt, i, j, l; | ||
147 | register char tmp, *tmp1, *tmp2; | ||
148 | char *base, *k, *p, *t; | ||
149 | |||
150 | if (nmemb <= 1) | ||
151 | return (0); | ||
152 | |||
153 | if (!size) { | ||
154 | errno = EINVAL; | ||
155 | return (-1); | ||
156 | } | ||
157 | |||
158 | if ((k = malloc(size)) == NULL) | ||
159 | return (-1); | ||
160 | |||
161 | /* | ||
162 | * Items are numbered from 1 to nmemb, so offset from size bytes | ||
163 | * below the starting address. | ||
164 | */ | ||
165 | base = (char *)vbase - size; | ||
166 | |||
167 | for (l = nmemb / 2 + 1; --l;) | ||
168 | CREATE(l, nmemb, i, j, t, p, size, cnt, tmp); | ||
169 | |||
170 | /* | ||
171 | * For each element of the heap, save the largest element into its | ||
172 | * final slot, save the displaced element (k), then recreate the | ||
173 | * heap. | ||
174 | */ | ||
175 | while (nmemb > 1) { | ||
176 | COPY(k, base + nmemb * size, cnt, size, tmp1, tmp2); | ||
177 | COPY(base + nmemb * size, base + size, cnt, size, tmp1, tmp2); | ||
178 | --nmemb; | ||
179 | SELECT(i, j, nmemb, t, p, size, k, cnt, tmp1, tmp2); | ||
180 | } | ||
181 | free(k); | ||
182 | return (0); | ||
183 | } | ||
diff --git a/src/lib/libc/stdlib/jrand48.c b/src/lib/libc/stdlib/jrand48.c new file mode 100644 index 0000000000..99cddb71e5 --- /dev/null +++ b/src/lib/libc/stdlib/jrand48.c | |||
@@ -0,0 +1,25 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | */ | ||
13 | |||
14 | #if defined(LIBC_SCCS) && !defined(lint) | ||
15 | static char rcsid[] = "$OpenBSD: jrand48.c,v 1.2 1996/08/19 08:33:33 tholo Exp $"; | ||
16 | #endif /* LIBC_SCCS and not lint */ | ||
17 | |||
18 | #include "rand48.h" | ||
19 | |||
20 | long | ||
21 | jrand48(unsigned short xseed[3]) | ||
22 | { | ||
23 | __dorand48(xseed); | ||
24 | return ((long) xseed[2] << 16) + (long) xseed[1]; | ||
25 | } | ||
diff --git a/src/lib/libc/stdlib/l64a.c b/src/lib/libc/stdlib/l64a.c new file mode 100644 index 0000000000..4e99391254 --- /dev/null +++ b/src/lib/libc/stdlib/l64a.c | |||
@@ -0,0 +1,46 @@ | |||
1 | /* | ||
2 | * Written by J.T. Conklin <jtc@netbsd.org>. | ||
3 | * Public domain. | ||
4 | */ | ||
5 | |||
6 | #if defined(LIBC_SCCS) && !defined(lint) | ||
7 | static char *rcsid = "$OpenBSD: l64a.c,v 1.3 1997/08/17 22:58:34 millert Exp $"; | ||
8 | #endif /* LIBC_SCCS and not lint */ | ||
9 | |||
10 | #include <errno.h> | ||
11 | #include <stdlib.h> | ||
12 | |||
13 | char * | ||
14 | l64a(value) | ||
15 | long value; | ||
16 | { | ||
17 | static char buf[8]; | ||
18 | char *s = buf; | ||
19 | int digit; | ||
20 | int i; | ||
21 | |||
22 | if (value < 0) { | ||
23 | errno = EINVAL; | ||
24 | return(NULL); | ||
25 | } | ||
26 | |||
27 | for (i = 0; value != 0 && i < 6; i++) { | ||
28 | digit = value & 0x3f; | ||
29 | |||
30 | if (digit < 2) | ||
31 | *s = digit + '.'; | ||
32 | else if (digit < 12) | ||
33 | *s = digit + '0' - 2; | ||
34 | else if (digit < 38) | ||
35 | *s = digit + 'A' - 12; | ||
36 | else | ||
37 | *s = digit + 'a' - 38; | ||
38 | |||
39 | value >>= 6; | ||
40 | s++; | ||
41 | } | ||
42 | |||
43 | *s = '\0'; | ||
44 | |||
45 | return(buf); | ||
46 | } | ||
diff --git a/src/lib/libc/stdlib/labs.3 b/src/lib/libc/stdlib/labs.3 new file mode 100644 index 0000000000..05eae329df --- /dev/null +++ b/src/lib/libc/stdlib/labs.3 | |||
@@ -0,0 +1,66 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: labs.3,v 1.2 1996/08/19 08:33:34 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt LABS 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm labs | ||
43 | .Nd return the absolute value of a long integer | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft long | ||
47 | .Fn labs "long j" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn labs | ||
51 | function | ||
52 | returns the absolute value of the long integer | ||
53 | .Ar j . | ||
54 | .Sh SEE ALSO | ||
55 | .Xr abs 3 , | ||
56 | .Xr floor 3 , | ||
57 | .Xr cabs 3 , | ||
58 | .Xr math 3 | ||
59 | .Sh STANDARDS | ||
60 | The | ||
61 | .Fn labs | ||
62 | function | ||
63 | conforms to | ||
64 | .St -ansiC . | ||
65 | .Sh BUGS | ||
66 | The absolute value of the most negative integer remains negative. | ||
diff --git a/src/lib/libc/stdlib/labs.c b/src/lib/libc/stdlib/labs.c new file mode 100644 index 0000000000..f20e2c29be --- /dev/null +++ b/src/lib/libc/stdlib/labs.c | |||
@@ -0,0 +1,45 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1990 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: labs.c,v 1.2 1996/08/19 08:33:34 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | |||
40 | long | ||
41 | labs(j) | ||
42 | long j; | ||
43 | { | ||
44 | return(j < 0 ? -j : j); | ||
45 | } | ||
diff --git a/src/lib/libc/stdlib/lcong48.c b/src/lib/libc/stdlib/lcong48.c new file mode 100644 index 0000000000..44bd74e48a --- /dev/null +++ b/src/lib/libc/stdlib/lcong48.c | |||
@@ -0,0 +1,34 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | */ | ||
13 | |||
14 | #if defined(LIBC_SCCS) && !defined(lint) | ||
15 | static char rcsid[] = "$OpenBSD: lcong48.c,v 1.2 1996/08/19 08:33:35 tholo Exp $"; | ||
16 | #endif /* LIBC_SCCS and not lint */ | ||
17 | |||
18 | #include "rand48.h" | ||
19 | |||
20 | extern unsigned short __rand48_seed[3]; | ||
21 | extern unsigned short __rand48_mult[3]; | ||
22 | extern unsigned short __rand48_add; | ||
23 | |||
24 | void | ||
25 | lcong48(unsigned short p[7]) | ||
26 | { | ||
27 | __rand48_seed[0] = p[0]; | ||
28 | __rand48_seed[1] = p[1]; | ||
29 | __rand48_seed[2] = p[2]; | ||
30 | __rand48_mult[0] = p[3]; | ||
31 | __rand48_mult[1] = p[4]; | ||
32 | __rand48_mult[2] = p[5]; | ||
33 | __rand48_add = p[6]; | ||
34 | } | ||
diff --git a/src/lib/libc/stdlib/ldiv.3 b/src/lib/libc/stdlib/ldiv.3 new file mode 100644 index 0000000000..8757f4ddd5 --- /dev/null +++ b/src/lib/libc/stdlib/ldiv.3 | |||
@@ -0,0 +1,71 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" Chris Torek and the American National Standards Committee X3, | ||
6 | .\" on Information Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: ldiv.3,v 1.2 1996/08/19 08:33:35 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt LDIV 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm ldiv | ||
43 | .Nd return quotient and remainder from division | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft ldiv_t | ||
47 | .Fn ldiv "long num" "long denom" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn ldiv | ||
51 | function | ||
52 | computes the value | ||
53 | .Ar num/denom | ||
54 | and returns the quotient and remainder in a structure named | ||
55 | .Ar ldiv_t | ||
56 | that contains two | ||
57 | .Em long integer | ||
58 | members named | ||
59 | .Ar quot | ||
60 | and | ||
61 | .Ar rem . | ||
62 | .Sh SEE ALSO | ||
63 | .Xr div 3 , | ||
64 | .Xr qdiv 3 , | ||
65 | .Xr math 3 | ||
66 | .Sh STANDARDS | ||
67 | The | ||
68 | .Fn ldiv | ||
69 | function | ||
70 | conforms to | ||
71 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/ldiv.c b/src/lib/libc/stdlib/ldiv.c new file mode 100644 index 0000000000..908c2bf0aa --- /dev/null +++ b/src/lib/libc/stdlib/ldiv.c | |||
@@ -0,0 +1,58 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1990 Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * This code is derived from software contributed to Berkeley by | ||
6 | * Chris Torek. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * 1. Redistributions of source code must retain the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer. | ||
13 | * 2. Redistributions in binary form must reproduce the above copyright | ||
14 | * notice, this list of conditions and the following disclaimer in the | ||
15 | * documentation and/or other materials provided with the distribution. | ||
16 | * 3. All advertising materials mentioning features or use of this software | ||
17 | * must display the following acknowledgement: | ||
18 | * This product includes software developed by the University of | ||
19 | * California, Berkeley and its contributors. | ||
20 | * 4. Neither the name of the University nor the names of its contributors | ||
21 | * may be used to endorse or promote products derived from this software | ||
22 | * without specific prior written permission. | ||
23 | * | ||
24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | * SUCH DAMAGE. | ||
35 | */ | ||
36 | |||
37 | #if defined(LIBC_SCCS) && !defined(lint) | ||
38 | static char *rcsid = "$OpenBSD: ldiv.c,v 1.2 1996/08/19 08:33:35 tholo Exp $"; | ||
39 | #endif /* LIBC_SCCS and not lint */ | ||
40 | |||
41 | #include <stdlib.h> /* ldiv_t */ | ||
42 | |||
43 | ldiv_t | ||
44 | ldiv(num, denom) | ||
45 | long num, denom; | ||
46 | { | ||
47 | ldiv_t r; | ||
48 | |||
49 | /* see div.c for comments */ | ||
50 | |||
51 | r.quot = num / denom; | ||
52 | r.rem = num % denom; | ||
53 | if (num >= 0 && r.rem < 0) { | ||
54 | r.quot++; | ||
55 | r.rem -= denom; | ||
56 | } | ||
57 | return (r); | ||
58 | } | ||
diff --git a/src/lib/libc/stdlib/lrand48.c b/src/lib/libc/stdlib/lrand48.c new file mode 100644 index 0000000000..6b7524a51b --- /dev/null +++ b/src/lib/libc/stdlib/lrand48.c | |||
@@ -0,0 +1,27 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | */ | ||
13 | |||
14 | #if defined(LIBC_SCCS) && !defined(lint) | ||
15 | static char rcsid[] = "$OpenBSD: lrand48.c,v 1.2 1996/08/19 08:33:36 tholo Exp $"; | ||
16 | #endif /* LIBC_SCCS and not lint */ | ||
17 | |||
18 | #include "rand48.h" | ||
19 | |||
20 | extern unsigned short __rand48_seed[3]; | ||
21 | |||
22 | long | ||
23 | lrand48(void) | ||
24 | { | ||
25 | __dorand48(__rand48_seed); | ||
26 | return ((long) __rand48_seed[2] << 15) + ((long) __rand48_seed[1] >> 1); | ||
27 | } | ||
diff --git a/src/lib/libc/stdlib/malloc.3 b/src/lib/libc/stdlib/malloc.3 new file mode 100644 index 0000000000..d5f8837ec2 --- /dev/null +++ b/src/lib/libc/stdlib/malloc.3 | |||
@@ -0,0 +1,350 @@ | |||
1 | .\" Copyright (c) 1980, 1991, 1993 | ||
2 | .\" The Regents of the University of California. All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: malloc.3,v 1.9 1998/08/15 20:32:02 deraadt Exp $ | ||
37 | .\" | ||
38 | .Dd August 27, 1996 | ||
39 | .Dt MALLOC 3 | ||
40 | .Os OpenBSD | ||
41 | .Sh NAME | ||
42 | .Nm malloc , | ||
43 | .Nd general memory allocation function | ||
44 | .Pp | ||
45 | .Nm free , | ||
46 | .Nm cfree | ||
47 | .Nd free up memory allocated with malloc, calloc or realloc | ||
48 | .Pp | ||
49 | .Nm realloc | ||
50 | .Nd reallocation of memory function | ||
51 | .Sh SYNOPSIS | ||
52 | .Fd #include <stdlib.h> | ||
53 | .Ft void * | ||
54 | .Fn malloc "size_t size" | ||
55 | .Ft void | ||
56 | .Fn free "void *ptr" | ||
57 | .Ft void | ||
58 | .Fn cfree "void *ptr" | ||
59 | .Ft void * | ||
60 | .Fn realloc "void *ptr" "size_t size" | ||
61 | .Ft char * | ||
62 | .Va malloc_options | ||
63 | .Sh DESCRIPTION | ||
64 | The | ||
65 | .Fn malloc | ||
66 | function allocates uninitialized space for an object whose | ||
67 | size is specified by | ||
68 | .Fa size . | ||
69 | The | ||
70 | .Fn malloc | ||
71 | function maintains multiple lists of free blocks according to size, allocating | ||
72 | space from the appropriate list. | ||
73 | .Pp | ||
74 | The allocated space is | ||
75 | suitably aligned (after possible pointer | ||
76 | coercion) for storage of any type of object. If the space is of | ||
77 | .Em pagesize | ||
78 | or larger, the memory returned will be page-aligned. | ||
79 | .Pp | ||
80 | Allocation of a zero size object returns a pointer to a zero size object. | ||
81 | .Pp | ||
82 | The | ||
83 | .Fn free | ||
84 | function causes the space pointed to by | ||
85 | .Fa ptr | ||
86 | to be deallocated, that is, at least made available for further allocation, | ||
87 | but if possible, it will passed back to the kernel with | ||
88 | .Xr sbrk 2 . | ||
89 | If | ||
90 | .Fa ptr | ||
91 | is a null pointer, no action occurs. | ||
92 | .Pp | ||
93 | A | ||
94 | .Fn cfree | ||
95 | function is also provided for compatibility with old systems and other | ||
96 | .Nm malloc | ||
97 | libraries; it is simply an alias for | ||
98 | .Fn free . | ||
99 | .Pp | ||
100 | The | ||
101 | .Fn realloc | ||
102 | function changes the size of the object pointed to by | ||
103 | .Fa ptr | ||
104 | to the size specified by | ||
105 | .Fa size . | ||
106 | The contents of the object are unchanged up to the lesser | ||
107 | of the new and old sizes. | ||
108 | If the new size is larger, the value of the newly allocated portion | ||
109 | of the object is indeterminate and uninitialized. | ||
110 | If | ||
111 | .Fa ptr | ||
112 | is a null pointer, the | ||
113 | .Fn realloc | ||
114 | function behaves like the | ||
115 | .Fn malloc | ||
116 | function for the specified size. | ||
117 | If the space cannot be allocated, the object | ||
118 | pointed to by | ||
119 | .Fa ptr | ||
120 | is unchanged. | ||
121 | If | ||
122 | .Fa size | ||
123 | is zero and | ||
124 | .Fa ptr | ||
125 | is not a null pointer, the object it points to is freed and a new zero size | ||
126 | object is returned. | ||
127 | .Pp | ||
128 | When using | ||
129 | .Fn realloc | ||
130 | one must be careful to avoid the following idiom: | ||
131 | .Pp | ||
132 | .Bd -literal -offset indent | ||
133 | if ((p = realloc(p, nsize)) == NULL) | ||
134 | return NULL; | ||
135 | .Ed | ||
136 | .Pp | ||
137 | In most cases, this will result in a leak of memory. | ||
138 | As stated earlier, a return value of | ||
139 | .Fa NULL | ||
140 | indicates that the old object still remains allocated. | ||
141 | Better code looks like this: | ||
142 | .Bd -literal -offset indent | ||
143 | if ((p2 = realloc(p, nsize)) == NULL) { | ||
144 | if (p) | ||
145 | free(p); | ||
146 | p = NULL; | ||
147 | return NULL; | ||
148 | } | ||
149 | p = p2; | ||
150 | .Ed | ||
151 | .Pp | ||
152 | Malloc will first look for a symbolic link called | ||
153 | .Pa /etc/malloc.conf | ||
154 | and next check the environment for a variable called | ||
155 | .Ev MALLOC_OPTIONS | ||
156 | and finally for the global variable | ||
157 | .Va malloc_options | ||
158 | and scan them for flags in that order. | ||
159 | Flags are single letters, uppercase means on, lowercase means off. | ||
160 | .Bl -tag -width indent | ||
161 | .It A | ||
162 | ``abort'' malloc will coredump the process, rather than tolerate failure. | ||
163 | This is a very handy debugging aid, since the core file will represent the | ||
164 | time of failure, | ||
165 | rather than when the NULL pointer was accessed. | ||
166 | |||
167 | .It D | ||
168 | ``dump'' malloc will dump statistics in a file called ``malloc.out'' at exit. | ||
169 | This option requires the library to have been compiled with -DMALLOC_STATS in | ||
170 | order to have any effect. | ||
171 | |||
172 | .It J | ||
173 | ``junk'' fill some junk into the area allocated. | ||
174 | Currently junk is bytes of 0xd0, this is pronounced ``Duh'' :-) | ||
175 | |||
176 | .It H | ||
177 | ``hint'' pass a hint to the kernel about pages we don't use. If the | ||
178 | machine is paging a lot this may help a bit. | ||
179 | |||
180 | .It N | ||
181 | Do not output warning messages when encountering possible corruption | ||
182 | or bad pointers. | ||
183 | |||
184 | .It R | ||
185 | ``realloc'' always reallocate when | ||
186 | .Fn realloc | ||
187 | is called, even if the initial allocation was big enough. | ||
188 | This can substantially aid in compacting memory. | ||
189 | |||
190 | .It U | ||
191 | ``utrace'' generate entries for | ||
192 | .Xr ktrace 1 | ||
193 | for all operations. | ||
194 | Consult the source for this one. | ||
195 | |||
196 | .It X | ||
197 | ``xmalloc'' | ||
198 | rather than return failure, | ||
199 | .Xr abort 3 | ||
200 | the program with a diagnostic message on stderr. | ||
201 | It is the intention that this option be set at compile time by | ||
202 | including in the source: | ||
203 | .Bd -literal -offset indent | ||
204 | extern char *malloc_options; | ||
205 | malloc_options = "X"; | ||
206 | .Ed | ||
207 | |||
208 | .It Z | ||
209 | ``zero'' fill some junk into the area allocated (see ``J''), | ||
210 | except for the exact length the user asked for, which is zeroed. | ||
211 | |||
212 | .It < | ||
213 | ``Half the cache size'' Reduce the size of the cache by a factor of two. | ||
214 | |||
215 | .It > | ||
216 | ``Double the cache size'' Double the size of the cache by a factor of two. | ||
217 | .El | ||
218 | .Pp | ||
219 | So to set a systemwide reduction of cache size and coredumps on problems | ||
220 | one would: | ||
221 | .Li ln -s 'A<' /etc/malloc.conf | ||
222 | .Pp | ||
223 | The ``J'' and ``Z'' is mostly for testing and debugging, | ||
224 | if a program changes behavior if either of these options are used, | ||
225 | it is buggy. | ||
226 | .Pp | ||
227 | The default cache size is 16 pages. | ||
228 | .Sh ENVIRONMENT | ||
229 | See above. | ||
230 | .Sh RETURN VALUES | ||
231 | The | ||
232 | .Fn malloc | ||
233 | function returns | ||
234 | a pointer to the allocated space if successful; otherwise | ||
235 | a null pointer is returned. | ||
236 | .Pp | ||
237 | The | ||
238 | .Fn free | ||
239 | function returns no value. | ||
240 | .Pp | ||
241 | The | ||
242 | .Fn realloc | ||
243 | function a pointer to the possibly moved allocated space; | ||
244 | otherwise a null pointer is returned. | ||
245 | .Sh MESSAGES | ||
246 | If | ||
247 | .Fn malloc , | ||
248 | .Fn free | ||
249 | or | ||
250 | .Fn realloc | ||
251 | detects an error or warning condition, | ||
252 | a message will be printed to filedescriptor | ||
253 | 2 (not using stdio). | ||
254 | Errors will always result in the process being | ||
255 | .Xr abort 2 'ed, | ||
256 | If the ``A'' option has been specified, also warnings will | ||
257 | .Xr abort 2 | ||
258 | the process. | ||
259 | .Pp | ||
260 | Here is a brief description of the error messages and what they mean: | ||
261 | .Pp | ||
262 | ``(ES): mumble mumble mumble'': | ||
263 | malloc have been compiled with -DEXTRA_SANITY and something looks | ||
264 | fishy in there. Consult sources and or wizards. | ||
265 | .Pp | ||
266 | ``allocation failed'' | ||
267 | if the ``A'' option is specified it is an error for | ||
268 | .Fn malloc | ||
269 | or | ||
270 | .Fn realloc | ||
271 | to return NULL. | ||
272 | .Pp | ||
273 | ``mmap(2) failed, check limits.'' | ||
274 | This is a rather weird condition that is most likely to mean that | ||
275 | the system is seriously overloaded or that your ulimits are sick. | ||
276 | .Pp | ||
277 | ``freelist is destroyed.'' | ||
278 | mallocs internal freelist has been stomped on. | ||
279 | .Pp | ||
280 | Here is a brief description of the warning messages and what they mean: | ||
281 | .Pp | ||
282 | ``chunk/page is already free.'' | ||
283 | A pointer to a free chunk is attempted freed again. | ||
284 | .Pp | ||
285 | ``junk pointer, too high to make sense.'' | ||
286 | The pointer doesn't make sense. It's above the area of memory that | ||
287 | malloc knows something about. | ||
288 | This could be a pointer from some | ||
289 | .Xr mmap 2 'ed | ||
290 | memory. | ||
291 | .Pp | ||
292 | ``junk pointer, too low to make sense.'' | ||
293 | The pointer doesn't make sense. It's below the area of memory that | ||
294 | malloc knows something about. | ||
295 | This pointer probably came from your data or bss segments. | ||
296 | .Pp | ||
297 | ``malloc() has never been called.'' | ||
298 | Nothing has ever been allocated, yet something is being freed or | ||
299 | realloc'ed. | ||
300 | .Pp | ||
301 | ``modified (chunk-/page-) pointer.'' | ||
302 | The pointer passed to free or realloc has been modified. | ||
303 | .Pp | ||
304 | ``pointer to wrong page.'' | ||
305 | The pointer that malloc is trying to free is not pointing to | ||
306 | a sensible page. | ||
307 | .Pp | ||
308 | ``recursive call.'' | ||
309 | You have tried to call recursively into these functions. | ||
310 | I can only imagine this as happening if you call one of these | ||
311 | functions from a signal function, which happens to be called | ||
312 | while you're already in here. | ||
313 | Well, sorry to say: that's not supported. | ||
314 | If this is a problem for you I'd like to hear about it. It | ||
315 | would be possible to add a sigblock() around this package, | ||
316 | but it would have a performance penalty that is not acceptable | ||
317 | as the default. | ||
318 | .Pp | ||
319 | ``unknown char in MALLOC_OPTIONS'' | ||
320 | we found something we didn't understand. | ||
321 | .Sh SEE ALSO | ||
322 | .Xr brk 2 , | ||
323 | .Xr alloca 3 , | ||
324 | .Xr calloc 3 , | ||
325 | .Xr getpagesize 3 , | ||
326 | .Xr memory 3 | ||
327 | .Pa /usr/share/doc/papers/malloc.ascii.gz | ||
328 | .Sh STANDARDS | ||
329 | The | ||
330 | .Fn malloc | ||
331 | function conforms to | ||
332 | .St -ansiC . | ||
333 | .Sh HISTORY | ||
334 | The present implementation of malloc started out as a filesystem on a drum | ||
335 | attached to a 20bit binary challenged computer built with discrete germanium | ||
336 | transistors, and it has since graduated to handle primary storage rather than | ||
337 | secondary. | ||
338 | .Pp | ||
339 | The main difference from other malloc implementations are believed to be that | ||
340 | the free pages are not accessed until allocated. | ||
341 | Most malloc implementations will store a data structure containing a, | ||
342 | possibly double-, linked list in the free chunks of memory, used to tie | ||
343 | all the free memory together. | ||
344 | That is a quite suboptimal thing to do. | ||
345 | Every time the free-list is traversed, all the otherwise unused, and very | ||
346 | likely paged out, pages get faulted into primary memory, just to see what | ||
347 | lies after them in the list. | ||
348 | .Pp | ||
349 | On systems which are paging, this can make a factor five in difference on the | ||
350 | page-faults of a process. | ||
diff --git a/src/lib/libc/stdlib/malloc.c b/src/lib/libc/stdlib/malloc.c new file mode 100644 index 0000000000..d1d8759791 --- /dev/null +++ b/src/lib/libc/stdlib/malloc.c | |||
@@ -0,0 +1,1242 @@ | |||
1 | /* | ||
2 | * ---------------------------------------------------------------------------- | ||
3 | * "THE BEER-WARE LICENSE" (Revision 42): | ||
4 | * <phk@FreeBSD.ORG> wrote this file. As long as you retain this notice you | ||
5 | * can do whatever you want with this stuff. If we meet some day, and you think | ||
6 | * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp | ||
7 | * ---------------------------------------------------------------------------- | ||
8 | */ | ||
9 | |||
10 | #if defined(LIBC_SCCS) && !defined(lint) | ||
11 | static char rcsid[] = "$OpenBSD: malloc.c,v 1.32 1998/08/06 16:26:32 millert Exp $"; | ||
12 | #endif /* LIBC_SCCS and not lint */ | ||
13 | |||
14 | /* | ||
15 | * Defining MALLOC_EXTRA_SANITY will enable extra checks which are | ||
16 | * related to internal conditions and consistency in malloc.c. This has | ||
17 | * a noticeable runtime performance hit, and generally will not do you | ||
18 | * any good unless you fiddle with the internals of malloc or want | ||
19 | * to catch random pointer corruption as early as possible. | ||
20 | */ | ||
21 | #ifndef MALLOC_EXTRA_SANITY | ||
22 | #undef MALLOC_EXTRA_SANITY | ||
23 | #endif | ||
24 | |||
25 | /* | ||
26 | * Defining MALLOC_STATS will enable you to call malloc_dump() and set | ||
27 | * the [dD] options in the MALLOC_OPTIONS environment variable. | ||
28 | * It has no run-time performance hit, but does pull in stdio... | ||
29 | */ | ||
30 | #ifndef MALLOC_STATS | ||
31 | #undef MALLOC_STATS | ||
32 | #endif | ||
33 | |||
34 | /* | ||
35 | * What to use for Junk. This is the byte value we use to fill with | ||
36 | * when the 'J' option is enabled. | ||
37 | */ | ||
38 | #define SOME_JUNK 0xd0 /* as in "Duh" :-) */ | ||
39 | |||
40 | #include <stdio.h> | ||
41 | #include <stdlib.h> | ||
42 | #include <string.h> | ||
43 | #include <unistd.h> | ||
44 | #include <fcntl.h> | ||
45 | #include <errno.h> | ||
46 | #include <sys/types.h> | ||
47 | #include <sys/param.h> | ||
48 | #include <sys/mman.h> | ||
49 | |||
50 | /* | ||
51 | * The basic parameters you can tweak. | ||
52 | * | ||
53 | * malloc_pageshift pagesize = 1 << malloc_pageshift | ||
54 | * It's probably best if this is the native | ||
55 | * page size, but it shouldn't have to be. | ||
56 | * | ||
57 | * malloc_minsize minimum size of an allocation in bytes. | ||
58 | * If this is too small it's too much work | ||
59 | * to manage them. This is also the smallest | ||
60 | * unit of alignment used for the storage | ||
61 | * returned by malloc/realloc. | ||
62 | * | ||
63 | */ | ||
64 | |||
65 | #if defined(__i386__) && defined(__FreeBSD__) | ||
66 | # define malloc_pageshift 12U | ||
67 | # define malloc_minsize 16U | ||
68 | #endif /* __i386__ && __FreeBSD__ */ | ||
69 | |||
70 | #if defined(__sparc__) && !defined(__OpenBSD__) | ||
71 | # define malloc_pageshirt 12U | ||
72 | # define malloc_minsize 16U | ||
73 | # define MAP_ANON (0) | ||
74 | # define USE_DEV_ZERO | ||
75 | # define MADV_FREE MADV_DONTNEED | ||
76 | #endif /* __sparc__ */ | ||
77 | |||
78 | /* Insert your combination here... */ | ||
79 | #if defined(__FOOCPU__) && defined(__BAROS__) | ||
80 | # define malloc_pageshift 12U | ||
81 | # define malloc_minsize 16U | ||
82 | #endif /* __FOOCPU__ && __BAROS__ */ | ||
83 | |||
84 | #if defined(__OpenBSD__) && !defined(__sparc__) | ||
85 | # define malloc_pageshift (PGSHIFT) | ||
86 | # define malloc_minsize 16U | ||
87 | #endif /* __OpenBSD__ */ | ||
88 | |||
89 | #ifdef _THREAD_SAFE | ||
90 | #include <pthread.h> | ||
91 | static pthread_mutex_t malloc_lock; | ||
92 | #define THREAD_LOCK() pthread_mutex_lock(&malloc_lock) | ||
93 | #define THREAD_UNLOCK() pthread_mutex_unlock(&malloc_lock) | ||
94 | #define THREAD_LOCK_INIT() pthread_mutex_init(&malloc_lock, 0); | ||
95 | #else | ||
96 | #define THREAD_LOCK() | ||
97 | #define THREAD_UNLOCK() | ||
98 | #define THREAD_LOCK_INIT() | ||
99 | #endif | ||
100 | |||
101 | /* | ||
102 | * No user serviceable parts behind this point. | ||
103 | * | ||
104 | * This structure describes a page worth of chunks. | ||
105 | */ | ||
106 | |||
107 | struct pginfo { | ||
108 | struct pginfo *next; /* next on the free list */ | ||
109 | void *page; /* Pointer to the page */ | ||
110 | u_short size; /* size of this page's chunks */ | ||
111 | u_short shift; /* How far to shift for this size chunks */ | ||
112 | u_short free; /* How many free chunks */ | ||
113 | u_short total; /* How many chunk */ | ||
114 | u_long bits[1]; /* Which chunks are free */ | ||
115 | }; | ||
116 | |||
117 | /* | ||
118 | * This structure describes a number of free pages. | ||
119 | */ | ||
120 | |||
121 | struct pgfree { | ||
122 | struct pgfree *next; /* next run of free pages */ | ||
123 | struct pgfree *prev; /* prev run of free pages */ | ||
124 | void *page; /* pointer to free pages */ | ||
125 | void *end; /* pointer to end of free pages */ | ||
126 | u_long size; /* number of bytes free */ | ||
127 | }; | ||
128 | |||
129 | /* | ||
130 | * How many bits per u_long in the bitmap. | ||
131 | * Change only if not 8 bits/byte | ||
132 | */ | ||
133 | #define MALLOC_BITS (8*sizeof(u_long)) | ||
134 | |||
135 | /* | ||
136 | * Magic values to put in the page_directory | ||
137 | */ | ||
138 | #define MALLOC_NOT_MINE ((struct pginfo*) 0) | ||
139 | #define MALLOC_FREE ((struct pginfo*) 1) | ||
140 | #define MALLOC_FIRST ((struct pginfo*) 2) | ||
141 | #define MALLOC_FOLLOW ((struct pginfo*) 3) | ||
142 | #define MALLOC_MAGIC ((struct pginfo*) 4) | ||
143 | |||
144 | #ifndef malloc_pageshift | ||
145 | #define malloc_pageshift 12U | ||
146 | #endif | ||
147 | |||
148 | #ifndef malloc_minsize | ||
149 | #define malloc_minsize 16U | ||
150 | #endif | ||
151 | |||
152 | #ifndef malloc_pageshift | ||
153 | #error "malloc_pageshift undefined" | ||
154 | #endif | ||
155 | |||
156 | #if !defined(malloc_pagesize) | ||
157 | #define malloc_pagesize (1UL<<malloc_pageshift) | ||
158 | #endif | ||
159 | |||
160 | #if ((1UL<<malloc_pageshift) != malloc_pagesize) | ||
161 | #error "(1UL<<malloc_pageshift) != malloc_pagesize" | ||
162 | #endif | ||
163 | |||
164 | #ifndef malloc_maxsize | ||
165 | #define malloc_maxsize ((malloc_pagesize)>>1) | ||
166 | #endif | ||
167 | |||
168 | /* A mask for the offset inside a page. */ | ||
169 | #define malloc_pagemask ((malloc_pagesize)-1) | ||
170 | |||
171 | #define pageround(foo) (((foo) + (malloc_pagemask))&(~(malloc_pagemask))) | ||
172 | #define ptr2index(foo) (((u_long)(foo) >> malloc_pageshift)-malloc_origo) | ||
173 | |||
174 | /* fd of /dev/zero */ | ||
175 | #ifdef USE_DEV_ZERO | ||
176 | static int fdzero; | ||
177 | #define MMAP_FD fdzero | ||
178 | #define INIT_MMAP() \ | ||
179 | { if ((fdzero=open("/dev/zero", O_RDWR, 0000)) == -1) \ | ||
180 | wrterror("open of /dev/zero"); } | ||
181 | #else | ||
182 | #define MMAP_FD (-1) | ||
183 | #define INIT_MMAP() | ||
184 | #endif | ||
185 | |||
186 | /* Set when initialization has been done */ | ||
187 | static unsigned malloc_started; | ||
188 | |||
189 | /* Number of free pages we cache */ | ||
190 | static unsigned malloc_cache = 16; | ||
191 | |||
192 | /* The offset from pagenumber to index into the page directory */ | ||
193 | static u_long malloc_origo; | ||
194 | |||
195 | /* The last index in the page directory we care about */ | ||
196 | static u_long last_index; | ||
197 | |||
198 | /* Pointer to page directory. Allocated "as if with" malloc */ | ||
199 | static struct pginfo **page_dir; | ||
200 | |||
201 | /* How many slots in the page directory */ | ||
202 | static size_t malloc_ninfo; | ||
203 | |||
204 | /* Free pages line up here */ | ||
205 | static struct pgfree free_list; | ||
206 | |||
207 | /* Abort(), user doesn't handle problems. */ | ||
208 | static int malloc_abort; | ||
209 | |||
210 | /* Are we trying to die ? */ | ||
211 | static int suicide; | ||
212 | |||
213 | #ifdef MALLOC_STATS | ||
214 | /* dump statistics */ | ||
215 | static int malloc_stats; | ||
216 | #endif | ||
217 | |||
218 | /* avoid outputting warnings? */ | ||
219 | static int malloc_silent; | ||
220 | |||
221 | /* always realloc ? */ | ||
222 | static int malloc_realloc; | ||
223 | |||
224 | #ifdef __FreeBSD__ | ||
225 | /* pass the kernel a hint on free pages ? */ | ||
226 | static int malloc_hint; | ||
227 | #endif | ||
228 | |||
229 | /* xmalloc behaviour ? */ | ||
230 | static int malloc_xmalloc; | ||
231 | |||
232 | /* zero fill ? */ | ||
233 | static int malloc_zero; | ||
234 | |||
235 | /* junk fill ? */ | ||
236 | static int malloc_junk; | ||
237 | |||
238 | #ifdef __FreeBSD__ | ||
239 | /* utrace ? */ | ||
240 | static int malloc_utrace; | ||
241 | |||
242 | struct ut { void *p; size_t s; void *r; }; | ||
243 | |||
244 | void utrace __P((struct ut *, int)); | ||
245 | |||
246 | #define UTRACE(a, b, c) \ | ||
247 | if (malloc_utrace) \ | ||
248 | {struct ut u; u.p=a; u.s = b; u.r=c; utrace(&u, sizeof u);} | ||
249 | #else /* !__FreeBSD__ */ | ||
250 | #define UTRACE(a,b,c) | ||
251 | #endif | ||
252 | |||
253 | /* my last break. */ | ||
254 | static void *malloc_brk; | ||
255 | |||
256 | /* one location cache for free-list holders */ | ||
257 | static struct pgfree *px; | ||
258 | |||
259 | /* compile-time options */ | ||
260 | char *malloc_options; | ||
261 | |||
262 | /* Name of the current public function */ | ||
263 | static char *malloc_func; | ||
264 | |||
265 | /* Macro for mmap */ | ||
266 | #define MMAP(size) \ | ||
267 | mmap((void *)0, (size), PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, \ | ||
268 | MMAP_FD, (off_t)0); | ||
269 | |||
270 | /* | ||
271 | * Necessary function declarations | ||
272 | */ | ||
273 | static int extend_pgdir(u_long index); | ||
274 | static void *imalloc(size_t size); | ||
275 | static void ifree(void *ptr); | ||
276 | static void *irealloc(void *ptr, size_t size); | ||
277 | static void *malloc_bytes(size_t size); | ||
278 | |||
279 | #ifdef MALLOC_STATS | ||
280 | void | ||
281 | malloc_dump(fd) | ||
282 | FILE *fd; | ||
283 | { | ||
284 | struct pginfo **pd; | ||
285 | struct pgfree *pf; | ||
286 | int j; | ||
287 | |||
288 | pd = page_dir; | ||
289 | |||
290 | /* print out all the pages */ | ||
291 | for(j=0;j<=last_index;j++) { | ||
292 | fprintf(fd, "%08lx %5d ", (j+malloc_origo) << malloc_pageshift, j); | ||
293 | if (pd[j] == MALLOC_NOT_MINE) { | ||
294 | for(j++;j<=last_index && pd[j] == MALLOC_NOT_MINE;j++) | ||
295 | ; | ||
296 | j--; | ||
297 | fprintf(fd, ".. %5d not mine\n", j); | ||
298 | } else if (pd[j] == MALLOC_FREE) { | ||
299 | for(j++;j<=last_index && pd[j] == MALLOC_FREE;j++) | ||
300 | ; | ||
301 | j--; | ||
302 | fprintf(fd, ".. %5d free\n", j); | ||
303 | } else if (pd[j] == MALLOC_FIRST) { | ||
304 | for(j++;j<=last_index && pd[j] == MALLOC_FOLLOW;j++) | ||
305 | ; | ||
306 | j--; | ||
307 | fprintf(fd, ".. %5d in use\n", j); | ||
308 | } else if (pd[j] < MALLOC_MAGIC) { | ||
309 | fprintf(fd, "(%p)\n", pd[j]); | ||
310 | } else { | ||
311 | fprintf(fd, "%p %d (of %d) x %d @ %p --> %p\n", | ||
312 | pd[j], pd[j]->free, pd[j]->total, | ||
313 | pd[j]->size, pd[j]->page, pd[j]->next); | ||
314 | } | ||
315 | } | ||
316 | |||
317 | for(pf=free_list.next; pf; pf=pf->next) { | ||
318 | fprintf(fd, "Free: @%p [%p...%p[ %ld ->%p <-%p\n", | ||
319 | pf, pf->page, pf->end, pf->size, pf->prev, pf->next); | ||
320 | if (pf == pf->next) { | ||
321 | fprintf(fd, "Free_list loops.\n"); | ||
322 | break; | ||
323 | } | ||
324 | } | ||
325 | |||
326 | /* print out various info */ | ||
327 | fprintf(fd, "Minsize\t%d\n", malloc_minsize); | ||
328 | fprintf(fd, "Maxsize\t%d\n", malloc_maxsize); | ||
329 | fprintf(fd, "Pagesize\t%lu\n", (u_long)malloc_pagesize); | ||
330 | fprintf(fd, "Pageshift\t%d\n", malloc_pageshift); | ||
331 | fprintf(fd, "FirstPage\t%ld\n", malloc_origo); | ||
332 | fprintf(fd, "LastPage\t%ld %lx\n", last_index+malloc_pageshift, | ||
333 | (last_index + malloc_pageshift) << malloc_pageshift); | ||
334 | fprintf(fd, "Break\t%ld\n", (u_long)sbrk(0) >> malloc_pageshift); | ||
335 | } | ||
336 | #endif /* MALLOC_STATS */ | ||
337 | |||
338 | extern char *__progname; | ||
339 | |||
340 | static void | ||
341 | wrterror(p) | ||
342 | char *p; | ||
343 | { | ||
344 | char *q = " error: "; | ||
345 | write(2, __progname, strlen(__progname)); | ||
346 | write(2, malloc_func, strlen(malloc_func)); | ||
347 | write(2, q, strlen(q)); | ||
348 | write(2, p, strlen(p)); | ||
349 | suicide = 1; | ||
350 | #ifdef MALLOC_STATS | ||
351 | if (malloc_stats) | ||
352 | malloc_dump(stderr); | ||
353 | #endif /* MALLOC_STATS */ | ||
354 | abort(); | ||
355 | } | ||
356 | |||
357 | static void | ||
358 | wrtwarning(p) | ||
359 | char *p; | ||
360 | { | ||
361 | char *q = " warning: "; | ||
362 | if (malloc_abort) | ||
363 | wrterror(p); | ||
364 | else if (malloc_silent) | ||
365 | return; | ||
366 | write(2, __progname, strlen(__progname)); | ||
367 | write(2, malloc_func, strlen(malloc_func)); | ||
368 | write(2, q, strlen(q)); | ||
369 | write(2, p, strlen(p)); | ||
370 | } | ||
371 | |||
372 | #ifdef MALLOC_STATS | ||
373 | static void | ||
374 | malloc_exit() | ||
375 | { | ||
376 | FILE *fd = fopen("malloc.out", "a"); | ||
377 | char *q = "malloc() warning: Couldn't dump stats.\n"; | ||
378 | if (fd) { | ||
379 | malloc_dump(fd); | ||
380 | fclose(fd); | ||
381 | } else | ||
382 | write(2, q, strlen(q)); | ||
383 | } | ||
384 | #endif /* MALLOC_STATS */ | ||
385 | |||
386 | |||
387 | /* | ||
388 | * Allocate a number of pages from the OS | ||
389 | */ | ||
390 | static void * | ||
391 | map_pages(pages) | ||
392 | int pages; | ||
393 | { | ||
394 | caddr_t result, tail; | ||
395 | |||
396 | result = (caddr_t)pageround((u_long)sbrk(0)); | ||
397 | tail = result + (pages << malloc_pageshift); | ||
398 | |||
399 | if (brk(tail)) { | ||
400 | #ifdef MALLOC_EXTRA_SANITY | ||
401 | wrterror("(ES): map_pages fails\n"); | ||
402 | #endif /* MALLOC_EXTRA_SANITY */ | ||
403 | return 0; | ||
404 | } | ||
405 | |||
406 | last_index = ptr2index(tail) - 1; | ||
407 | malloc_brk = tail; | ||
408 | |||
409 | if ((last_index+1) >= malloc_ninfo && !extend_pgdir(last_index)) | ||
410 | return 0; | ||
411 | |||
412 | return result; | ||
413 | } | ||
414 | |||
415 | /* | ||
416 | * Extend page directory | ||
417 | */ | ||
418 | static int | ||
419 | extend_pgdir(index) | ||
420 | u_long index; | ||
421 | { | ||
422 | struct pginfo **new, **old; | ||
423 | size_t i, oldlen; | ||
424 | |||
425 | /* Make it this many pages */ | ||
426 | i = index * sizeof *page_dir; | ||
427 | i /= malloc_pagesize; | ||
428 | i += 2; | ||
429 | |||
430 | /* remember the old mapping size */ | ||
431 | oldlen = malloc_ninfo * sizeof *page_dir; | ||
432 | |||
433 | /* | ||
434 | * NOTE: we allocate new pages and copy the directory rather than tempt | ||
435 | * fate by trying to "grow" the region.. There is nothing to prevent | ||
436 | * us from accidently re-mapping space that's been allocated by our caller | ||
437 | * via dlopen() or other mmap(). | ||
438 | * | ||
439 | * The copy problem is not too bad, as there is 4K of page index per | ||
440 | * 4MB of malloc arena. | ||
441 | * | ||
442 | * We can totally avoid the copy if we open a file descriptor to associate | ||
443 | * the anon mappings with. Then, when we remap the pages at the new | ||
444 | * address, the old pages will be "magically" remapped.. But this means | ||
445 | * keeping open a "secret" file descriptor..... | ||
446 | */ | ||
447 | |||
448 | /* Get new pages */ | ||
449 | new = (struct pginfo**) MMAP(i * malloc_pagesize); | ||
450 | if (new == (struct pginfo **)-1) | ||
451 | return 0; | ||
452 | |||
453 | /* Copy the old stuff */ | ||
454 | memcpy(new, page_dir, | ||
455 | malloc_ninfo * sizeof *page_dir); | ||
456 | |||
457 | /* register the new size */ | ||
458 | malloc_ninfo = i * malloc_pagesize / sizeof *page_dir; | ||
459 | |||
460 | /* swap the pointers */ | ||
461 | old = page_dir; | ||
462 | page_dir = new; | ||
463 | |||
464 | /* Now free the old stuff */ | ||
465 | munmap(old, oldlen); | ||
466 | return 1; | ||
467 | } | ||
468 | |||
469 | /* | ||
470 | * Initialize the world | ||
471 | */ | ||
472 | static void | ||
473 | malloc_init () | ||
474 | { | ||
475 | char *p, b[64]; | ||
476 | int i, j; | ||
477 | int save_errno = errno; | ||
478 | |||
479 | THREAD_LOCK_INIT(); | ||
480 | |||
481 | INIT_MMAP(); | ||
482 | |||
483 | #ifdef MALLOC_EXTRA_SANITY | ||
484 | malloc_junk = 1; | ||
485 | #endif /* MALLOC_EXTRA_SANITY */ | ||
486 | |||
487 | for (i = 0; i < 3; i++) { | ||
488 | if (i == 0) { | ||
489 | j = readlink("/etc/malloc.conf", b, sizeof b - 1); | ||
490 | if (j <= 0) | ||
491 | continue; | ||
492 | b[j] = '\0'; | ||
493 | p = b; | ||
494 | } else if (i == 1) { | ||
495 | if (issetugid() == 0) | ||
496 | p = getenv("MALLOC_OPTIONS"); | ||
497 | else | ||
498 | continue; | ||
499 | } else if (i == 2) { | ||
500 | p = malloc_options; | ||
501 | } | ||
502 | for (; p && *p; p++) { | ||
503 | switch (*p) { | ||
504 | case '>': malloc_cache <<= 1; break; | ||
505 | case '<': malloc_cache >>= 1; break; | ||
506 | case 'a': malloc_abort = 0; break; | ||
507 | case 'A': malloc_abort = 1; break; | ||
508 | #ifdef MALLOC_STATS | ||
509 | case 'd': malloc_stats = 0; break; | ||
510 | case 'D': malloc_stats = 1; break; | ||
511 | #endif /* MALLOC_STATS */ | ||
512 | #ifdef __FreeBSD__ | ||
513 | case 'h': malloc_hint = 0; break; | ||
514 | case 'H': malloc_hint = 1; break; | ||
515 | #endif /* __FreeBSD__ */ | ||
516 | case 'r': malloc_realloc = 0; break; | ||
517 | case 'R': malloc_realloc = 1; break; | ||
518 | case 'j': malloc_junk = 0; break; | ||
519 | case 'J': malloc_junk = 1; break; | ||
520 | case 'n': malloc_silent = 0; break; | ||
521 | case 'N': malloc_silent = 1; break; | ||
522 | #ifdef __FreeBSD__ | ||
523 | case 'u': malloc_utrace = 0; break; | ||
524 | case 'U': malloc_utrace = 1; break; | ||
525 | #endif /* __FreeBSD__ */ | ||
526 | case 'x': malloc_xmalloc = 0; break; | ||
527 | case 'X': malloc_xmalloc = 1; break; | ||
528 | case 'z': malloc_zero = 0; break; | ||
529 | case 'Z': malloc_zero = 1; break; | ||
530 | default: | ||
531 | j = malloc_abort; | ||
532 | malloc_abort = 0; | ||
533 | wrtwarning("unknown char in MALLOC_OPTIONS\n"); | ||
534 | malloc_abort = j; | ||
535 | break; | ||
536 | } | ||
537 | } | ||
538 | } | ||
539 | |||
540 | UTRACE(0, 0, 0); | ||
541 | |||
542 | /* | ||
543 | * We want junk in the entire allocation, and zero only in the part | ||
544 | * the user asked for. | ||
545 | */ | ||
546 | if (malloc_zero) | ||
547 | malloc_junk=1; | ||
548 | |||
549 | #ifdef MALLOC_STATS | ||
550 | if (malloc_stats) | ||
551 | atexit(malloc_exit); | ||
552 | #endif /* MALLOC_STATS */ | ||
553 | |||
554 | /* Allocate one page for the page directory */ | ||
555 | page_dir = (struct pginfo **) MMAP(malloc_pagesize); | ||
556 | |||
557 | if (page_dir == (struct pginfo **) -1) | ||
558 | wrterror("mmap(2) failed, check limits.\n"); | ||
559 | |||
560 | /* | ||
561 | * We need a maximum of malloc_pageshift buckets, steal these from the | ||
562 | * front of the page_directory; | ||
563 | */ | ||
564 | malloc_origo = ((u_long)pageround((u_long)sbrk(0))) >> malloc_pageshift; | ||
565 | malloc_origo -= malloc_pageshift; | ||
566 | |||
567 | malloc_ninfo = malloc_pagesize / sizeof *page_dir; | ||
568 | |||
569 | /* Been here, done that */ | ||
570 | malloc_started++; | ||
571 | |||
572 | /* Recalculate the cache size in bytes, and make sure it's nonzero */ | ||
573 | |||
574 | if (!malloc_cache) | ||
575 | malloc_cache++; | ||
576 | |||
577 | malloc_cache <<= malloc_pageshift; | ||
578 | |||
579 | /* | ||
580 | * This is a nice hack from Kaleb Keithly (kaleb@x.org). | ||
581 | * We can sbrk(2) further back when we keep this on a low address. | ||
582 | */ | ||
583 | px = (struct pgfree *) imalloc (sizeof *px); | ||
584 | errno = save_errno; | ||
585 | } | ||
586 | |||
587 | /* | ||
588 | * Allocate a number of complete pages | ||
589 | */ | ||
590 | static void * | ||
591 | malloc_pages(size) | ||
592 | size_t size; | ||
593 | { | ||
594 | void *p, *delay_free = 0; | ||
595 | int i; | ||
596 | struct pgfree *pf; | ||
597 | u_long index; | ||
598 | |||
599 | size = pageround(size); | ||
600 | |||
601 | p = 0; | ||
602 | /* Look for free pages before asking for more */ | ||
603 | for(pf = free_list.next; pf; pf = pf->next) { | ||
604 | |||
605 | #ifdef MALLOC_EXTRA_SANITY | ||
606 | if (pf->size & malloc_pagemask) | ||
607 | wrterror("(ES): junk length entry on free_list\n"); | ||
608 | if (!pf->size) | ||
609 | wrterror("(ES): zero length entry on free_list\n"); | ||
610 | if (pf->page == pf->end) | ||
611 | wrterror("(ES): zero entry on free_list\n"); | ||
612 | if (pf->page > pf->end) | ||
613 | wrterror("(ES): sick entry on free_list\n"); | ||
614 | if ((void*)pf->page >= (void*)sbrk(0)) | ||
615 | wrterror("(ES): entry on free_list past brk\n"); | ||
616 | if (page_dir[ptr2index(pf->page)] != MALLOC_FREE) | ||
617 | wrterror("(ES): non-free first page on free-list\n"); | ||
618 | if (page_dir[ptr2index(pf->end)-1] != MALLOC_FREE) | ||
619 | wrterror("(ES): non-free last page on free-list\n"); | ||
620 | #endif /* MALLOC_EXTRA_SANITY */ | ||
621 | |||
622 | if (pf->size < size) | ||
623 | continue; | ||
624 | |||
625 | if (pf->size == size) { | ||
626 | p = pf->page; | ||
627 | if (pf->next) | ||
628 | pf->next->prev = pf->prev; | ||
629 | pf->prev->next = pf->next; | ||
630 | delay_free = pf; | ||
631 | break; | ||
632 | } | ||
633 | |||
634 | p = pf->page; | ||
635 | pf->page = (char *)pf->page + size; | ||
636 | pf->size -= size; | ||
637 | break; | ||
638 | } | ||
639 | |||
640 | #ifdef MALLOC_EXTRA_SANITY | ||
641 | if (p && page_dir[ptr2index(p)] != MALLOC_FREE) | ||
642 | wrterror("(ES): allocated non-free page on free-list\n"); | ||
643 | #endif /* MALLOC_EXTRA_SANITY */ | ||
644 | |||
645 | size >>= malloc_pageshift; | ||
646 | |||
647 | /* Map new pages */ | ||
648 | if (!p) | ||
649 | p = map_pages(size); | ||
650 | |||
651 | if (p) { | ||
652 | |||
653 | index = ptr2index(p); | ||
654 | page_dir[index] = MALLOC_FIRST; | ||
655 | for (i=1;i<size;i++) | ||
656 | page_dir[index+i] = MALLOC_FOLLOW; | ||
657 | |||
658 | if (malloc_junk) | ||
659 | memset(p, SOME_JUNK, size << malloc_pageshift); | ||
660 | } | ||
661 | |||
662 | if (delay_free) { | ||
663 | if (!px) | ||
664 | px = delay_free; | ||
665 | else | ||
666 | ifree(delay_free); | ||
667 | } | ||
668 | |||
669 | return p; | ||
670 | } | ||
671 | |||
672 | /* | ||
673 | * Allocate a page of fragments | ||
674 | */ | ||
675 | |||
676 | static __inline__ int | ||
677 | malloc_make_chunks(bits) | ||
678 | int bits; | ||
679 | { | ||
680 | struct pginfo *bp; | ||
681 | void *pp; | ||
682 | int i, k, l; | ||
683 | |||
684 | /* Allocate a new bucket */ | ||
685 | pp = malloc_pages((size_t)malloc_pagesize); | ||
686 | if (!pp) | ||
687 | return 0; | ||
688 | |||
689 | /* Find length of admin structure */ | ||
690 | l = sizeof *bp - sizeof(u_long); | ||
691 | l += sizeof(u_long) * | ||
692 | (((malloc_pagesize >> bits)+MALLOC_BITS-1) / MALLOC_BITS); | ||
693 | |||
694 | /* Don't waste more than two chunks on this */ | ||
695 | if ((1UL<<(bits)) <= l+l) { | ||
696 | bp = (struct pginfo *)pp; | ||
697 | } else { | ||
698 | bp = (struct pginfo *)imalloc(l); | ||
699 | if (!bp) { | ||
700 | ifree(pp); | ||
701 | return 0; | ||
702 | } | ||
703 | } | ||
704 | |||
705 | bp->size = (1UL<<bits); | ||
706 | bp->shift = bits; | ||
707 | bp->total = bp->free = malloc_pagesize >> bits; | ||
708 | bp->page = pp; | ||
709 | |||
710 | /* set all valid bits in the bitmap */ | ||
711 | k = bp->total; | ||
712 | i = 0; | ||
713 | |||
714 | /* Do a bunch at a time */ | ||
715 | for(;k-i >= MALLOC_BITS; i += MALLOC_BITS) | ||
716 | bp->bits[i / MALLOC_BITS] = ~0UL; | ||
717 | |||
718 | for(; i < k; i++) | ||
719 | bp->bits[i/MALLOC_BITS] |= 1UL<<(i%MALLOC_BITS); | ||
720 | |||
721 | if (bp == bp->page) { | ||
722 | /* Mark the ones we stole for ourselves */ | ||
723 | for(i=0;l > 0;i++) { | ||
724 | bp->bits[i/MALLOC_BITS] &= ~(1UL<<(i%MALLOC_BITS)); | ||
725 | bp->free--; | ||
726 | bp->total--; | ||
727 | l -= (1 << bits); | ||
728 | } | ||
729 | } | ||
730 | |||
731 | /* MALLOC_LOCK */ | ||
732 | |||
733 | page_dir[ptr2index(pp)] = bp; | ||
734 | |||
735 | bp->next = page_dir[bits]; | ||
736 | page_dir[bits] = bp; | ||
737 | |||
738 | /* MALLOC_UNLOCK */ | ||
739 | |||
740 | return 1; | ||
741 | } | ||
742 | |||
743 | /* | ||
744 | * Allocate a fragment | ||
745 | */ | ||
746 | static void * | ||
747 | malloc_bytes(size) | ||
748 | size_t size; | ||
749 | { | ||
750 | int i,j; | ||
751 | u_long u; | ||
752 | struct pginfo *bp; | ||
753 | int k; | ||
754 | u_long *lp; | ||
755 | |||
756 | /* Don't bother with anything less than this */ | ||
757 | if (size < malloc_minsize) | ||
758 | size = malloc_minsize; | ||
759 | |||
760 | /* Find the right bucket */ | ||
761 | j = 1; | ||
762 | i = size-1; | ||
763 | while (i >>= 1) | ||
764 | j++; | ||
765 | |||
766 | /* If it's empty, make a page more of that size chunks */ | ||
767 | if (!page_dir[j] && !malloc_make_chunks(j)) | ||
768 | return 0; | ||
769 | |||
770 | bp = page_dir[j]; | ||
771 | |||
772 | /* Find first word of bitmap which isn't empty */ | ||
773 | for (lp = bp->bits; !*lp; lp++) | ||
774 | ; | ||
775 | |||
776 | /* Find that bit, and tweak it */ | ||
777 | u = 1; | ||
778 | k = 0; | ||
779 | while (!(*lp & u)) { | ||
780 | u += u; | ||
781 | k++; | ||
782 | } | ||
783 | *lp ^= u; | ||
784 | |||
785 | /* If there are no more free, remove from free-list */ | ||
786 | if (!--bp->free) { | ||
787 | page_dir[j] = bp->next; | ||
788 | bp->next = 0; | ||
789 | } | ||
790 | |||
791 | /* Adjust to the real offset of that chunk */ | ||
792 | k += (lp-bp->bits)*MALLOC_BITS; | ||
793 | k <<= bp->shift; | ||
794 | |||
795 | if (malloc_junk) | ||
796 | memset((char *)bp->page + k, SOME_JUNK, bp->size); | ||
797 | |||
798 | return (u_char *)bp->page + k; | ||
799 | } | ||
800 | |||
801 | /* | ||
802 | * Allocate a piece of memory | ||
803 | */ | ||
804 | static void * | ||
805 | imalloc(size) | ||
806 | size_t size; | ||
807 | { | ||
808 | void *result; | ||
809 | |||
810 | if (!malloc_started) | ||
811 | malloc_init(); | ||
812 | |||
813 | if (suicide) | ||
814 | abort(); | ||
815 | |||
816 | if ((size + malloc_pagesize) < size) /* Check for overflow */ | ||
817 | result = 0; | ||
818 | else if (size <= malloc_maxsize) | ||
819 | result = malloc_bytes(size); | ||
820 | else | ||
821 | result = malloc_pages(size); | ||
822 | |||
823 | if (malloc_abort && !result) | ||
824 | wrterror("allocation failed.\n"); | ||
825 | |||
826 | if (malloc_zero && result) | ||
827 | memset(result, 0, size); | ||
828 | |||
829 | return result; | ||
830 | } | ||
831 | |||
832 | /* | ||
833 | * Change the size of an allocation. | ||
834 | */ | ||
835 | static void * | ||
836 | irealloc(ptr, size) | ||
837 | void *ptr; | ||
838 | size_t size; | ||
839 | { | ||
840 | void *p; | ||
841 | u_long osize, index; | ||
842 | struct pginfo **mp; | ||
843 | int i; | ||
844 | |||
845 | if (suicide) | ||
846 | abort(); | ||
847 | |||
848 | if (!malloc_started) { | ||
849 | wrtwarning("malloc() has never been called.\n"); | ||
850 | return 0; | ||
851 | } | ||
852 | |||
853 | index = ptr2index(ptr); | ||
854 | |||
855 | if (index < malloc_pageshift) { | ||
856 | wrtwarning("junk pointer, too low to make sense.\n"); | ||
857 | return 0; | ||
858 | } | ||
859 | |||
860 | if (index > last_index) { | ||
861 | wrtwarning("junk pointer, too high to make sense.\n"); | ||
862 | return 0; | ||
863 | } | ||
864 | |||
865 | mp = &page_dir[index]; | ||
866 | |||
867 | if (*mp == MALLOC_FIRST) { /* Page allocation */ | ||
868 | |||
869 | /* Check the pointer */ | ||
870 | if ((u_long)ptr & malloc_pagemask) { | ||
871 | wrtwarning("modified (page-) pointer.\n"); | ||
872 | return 0; | ||
873 | } | ||
874 | |||
875 | /* Find the size in bytes */ | ||
876 | for (osize = malloc_pagesize; *++mp == MALLOC_FOLLOW;) | ||
877 | osize += malloc_pagesize; | ||
878 | |||
879 | if (!malloc_realloc && /* unless we have to, */ | ||
880 | size <= osize && /* .. or are too small, */ | ||
881 | size > (osize - malloc_pagesize)) { /* .. or can free a page, */ | ||
882 | return ptr; /* don't do anything. */ | ||
883 | } | ||
884 | |||
885 | } else if (*mp >= MALLOC_MAGIC) { /* Chunk allocation */ | ||
886 | |||
887 | /* Check the pointer for sane values */ | ||
888 | if (((u_long)ptr & ((*mp)->size-1))) { | ||
889 | wrtwarning("modified (chunk-) pointer.\n"); | ||
890 | return 0; | ||
891 | } | ||
892 | |||
893 | /* Find the chunk index in the page */ | ||
894 | i = ((u_long)ptr & malloc_pagemask) >> (*mp)->shift; | ||
895 | |||
896 | /* Verify that it isn't a free chunk already */ | ||
897 | if ((*mp)->bits[i/MALLOC_BITS] & (1UL<<(i%MALLOC_BITS))) { | ||
898 | wrtwarning("chunk is already free.\n"); | ||
899 | return 0; | ||
900 | } | ||
901 | |||
902 | osize = (*mp)->size; | ||
903 | |||
904 | if (!malloc_realloc && /* Unless we have to, */ | ||
905 | size < osize && /* ..or are too small, */ | ||
906 | (size > osize/2 || /* ..or could use a smaller size, */ | ||
907 | osize == malloc_minsize)) { /* ..(if there is one) */ | ||
908 | return ptr; /* ..Don't do anything */ | ||
909 | } | ||
910 | |||
911 | } else { | ||
912 | wrtwarning("pointer to wrong page.\n"); | ||
913 | return 0; | ||
914 | } | ||
915 | |||
916 | p = imalloc(size); | ||
917 | |||
918 | if (p) { | ||
919 | /* copy the lesser of the two sizes, and free the old one */ | ||
920 | if (osize < size) | ||
921 | memcpy(p, ptr, osize); | ||
922 | else | ||
923 | memcpy(p, ptr, size); | ||
924 | ifree(ptr); | ||
925 | } | ||
926 | return p; | ||
927 | } | ||
928 | |||
929 | /* | ||
930 | * Free a sequence of pages | ||
931 | */ | ||
932 | |||
933 | static __inline__ void | ||
934 | free_pages(ptr, index, info) | ||
935 | void *ptr; | ||
936 | int index; | ||
937 | struct pginfo *info; | ||
938 | { | ||
939 | int i; | ||
940 | struct pgfree *pf, *pt=0; | ||
941 | u_long l; | ||
942 | void *tail; | ||
943 | |||
944 | if (info == MALLOC_FREE) { | ||
945 | wrtwarning("page is already free.\n"); | ||
946 | return; | ||
947 | } | ||
948 | |||
949 | if (info != MALLOC_FIRST) { | ||
950 | wrtwarning("pointer to wrong page.\n"); | ||
951 | return; | ||
952 | } | ||
953 | |||
954 | if ((u_long)ptr & malloc_pagemask) { | ||
955 | wrtwarning("modified (page-) pointer.\n"); | ||
956 | return; | ||
957 | } | ||
958 | |||
959 | /* Count how many pages and mark them free at the same time */ | ||
960 | page_dir[index] = MALLOC_FREE; | ||
961 | for (i = 1; page_dir[index+i] == MALLOC_FOLLOW; i++) | ||
962 | page_dir[index + i] = MALLOC_FREE; | ||
963 | |||
964 | l = i << malloc_pageshift; | ||
965 | |||
966 | if (malloc_junk) | ||
967 | memset(ptr, SOME_JUNK, l); | ||
968 | |||
969 | #ifdef __FreeBSD__ | ||
970 | if (malloc_hint) | ||
971 | madvise(ptr, l, MADV_FREE); | ||
972 | #endif | ||
973 | |||
974 | tail = (char *)ptr+l; | ||
975 | |||
976 | /* add to free-list */ | ||
977 | if (!px) | ||
978 | px = imalloc(sizeof *px); /* This cannot fail... */ | ||
979 | px->page = ptr; | ||
980 | px->end = tail; | ||
981 | px->size = l; | ||
982 | if (!free_list.next) { | ||
983 | |||
984 | /* Nothing on free list, put this at head */ | ||
985 | px->next = free_list.next; | ||
986 | px->prev = &free_list; | ||
987 | free_list.next = px; | ||
988 | pf = px; | ||
989 | px = 0; | ||
990 | |||
991 | } else { | ||
992 | |||
993 | /* Find the right spot, leave pf pointing to the modified entry. */ | ||
994 | tail = (char *)ptr+l; | ||
995 | |||
996 | for(pf = free_list.next; pf->end < ptr && pf->next; pf = pf->next) | ||
997 | ; /* Race ahead here */ | ||
998 | |||
999 | if (pf->page > tail) { | ||
1000 | /* Insert before entry */ | ||
1001 | px->next = pf; | ||
1002 | px->prev = pf->prev; | ||
1003 | pf->prev = px; | ||
1004 | px->prev->next = px; | ||
1005 | pf = px; | ||
1006 | px = 0; | ||
1007 | } else if (pf->end == ptr ) { | ||
1008 | /* Append to the previous entry */ | ||
1009 | pf->end = (char *)pf->end + l; | ||
1010 | pf->size += l; | ||
1011 | if (pf->next && pf->end == pf->next->page ) { | ||
1012 | /* And collapse the next too. */ | ||
1013 | pt = pf->next; | ||
1014 | pf->end = pt->end; | ||
1015 | pf->size += pt->size; | ||
1016 | pf->next = pt->next; | ||
1017 | if (pf->next) | ||
1018 | pf->next->prev = pf; | ||
1019 | } | ||
1020 | } else if (pf->page == tail) { | ||
1021 | /* Prepend to entry */ | ||
1022 | pf->size += l; | ||
1023 | pf->page = ptr; | ||
1024 | } else if (!pf->next) { | ||
1025 | /* Append at tail of chain */ | ||
1026 | px->next = 0; | ||
1027 | px->prev = pf; | ||
1028 | pf->next = px; | ||
1029 | pf = px; | ||
1030 | px = 0; | ||
1031 | } else { | ||
1032 | wrterror("freelist is destroyed.\n"); | ||
1033 | } | ||
1034 | } | ||
1035 | |||
1036 | /* Return something to OS ? */ | ||
1037 | if (!pf->next && /* If we're the last one, */ | ||
1038 | pf->size > malloc_cache && /* ..and the cache is full, */ | ||
1039 | pf->end == malloc_brk && /* ..and none behind us, */ | ||
1040 | malloc_brk == sbrk(0)) { /* ..and it's OK to do... */ | ||
1041 | |||
1042 | /* | ||
1043 | * Keep the cache intact. Notice that the '>' above guarantees that | ||
1044 | * the pf will always have at least one page afterwards. | ||
1045 | */ | ||
1046 | pf->end = (char *)pf->page + malloc_cache; | ||
1047 | pf->size = malloc_cache; | ||
1048 | |||
1049 | brk(pf->end); | ||
1050 | malloc_brk = pf->end; | ||
1051 | |||
1052 | index = ptr2index(pf->end); | ||
1053 | last_index = index - 1; | ||
1054 | |||
1055 | for(i=index;i <= last_index;) | ||
1056 | page_dir[i++] = MALLOC_NOT_MINE; | ||
1057 | |||
1058 | /* XXX: We could realloc/shrink the pagedir here I guess. */ | ||
1059 | } | ||
1060 | if (pt) | ||
1061 | ifree(pt); | ||
1062 | } | ||
1063 | |||
1064 | /* | ||
1065 | * Free a chunk, and possibly the page it's on, if the page becomes empty. | ||
1066 | */ | ||
1067 | |||
1068 | /* ARGSUSED */ | ||
1069 | static __inline__ void | ||
1070 | free_bytes(ptr, index, info) | ||
1071 | void *ptr; | ||
1072 | int index; | ||
1073 | struct pginfo *info; | ||
1074 | { | ||
1075 | int i; | ||
1076 | struct pginfo **mp; | ||
1077 | void *vp; | ||
1078 | |||
1079 | /* Find the chunk number on the page */ | ||
1080 | i = ((u_long)ptr & malloc_pagemask) >> info->shift; | ||
1081 | |||
1082 | if (((u_long)ptr & (info->size-1))) { | ||
1083 | wrtwarning("modified (chunk-) pointer.\n"); | ||
1084 | return; | ||
1085 | } | ||
1086 | |||
1087 | if (info->bits[i/MALLOC_BITS] & (1UL<<(i%MALLOC_BITS))) { | ||
1088 | wrtwarning("chunk is already free.\n"); | ||
1089 | return; | ||
1090 | } | ||
1091 | |||
1092 | if (malloc_junk) | ||
1093 | memset(ptr, SOME_JUNK, info->size); | ||
1094 | |||
1095 | info->bits[i/MALLOC_BITS] |= 1UL<<(i%MALLOC_BITS); | ||
1096 | info->free++; | ||
1097 | |||
1098 | mp = page_dir + info->shift; | ||
1099 | |||
1100 | if (info->free == 1) { | ||
1101 | |||
1102 | /* Page became non-full */ | ||
1103 | |||
1104 | mp = page_dir + info->shift; | ||
1105 | /* Insert in address order */ | ||
1106 | while (*mp && (*mp)->next && (*mp)->next->page < info->page) | ||
1107 | mp = &(*mp)->next; | ||
1108 | info->next = *mp; | ||
1109 | *mp = info; | ||
1110 | return; | ||
1111 | } | ||
1112 | |||
1113 | if (info->free != info->total) | ||
1114 | return; | ||
1115 | |||
1116 | /* Find & remove this page in the queue */ | ||
1117 | while (*mp != info) { | ||
1118 | mp = &((*mp)->next); | ||
1119 | #ifdef MALLOC_EXTRA_SANITY | ||
1120 | if (!*mp) | ||
1121 | wrterror("(ES): Not on queue\n"); | ||
1122 | #endif /* MALLOC_EXTRA_SANITY */ | ||
1123 | } | ||
1124 | *mp = info->next; | ||
1125 | |||
1126 | /* Free the page & the info structure if need be */ | ||
1127 | page_dir[ptr2index(info->page)] = MALLOC_FIRST; | ||
1128 | vp = info->page; /* Order is important ! */ | ||
1129 | if(vp != (void*)info) | ||
1130 | ifree(info); | ||
1131 | ifree(vp); | ||
1132 | } | ||
1133 | |||
1134 | static void | ||
1135 | ifree(ptr) | ||
1136 | void *ptr; | ||
1137 | { | ||
1138 | struct pginfo *info; | ||
1139 | int index; | ||
1140 | |||
1141 | /* This is legal */ | ||
1142 | if (!ptr) | ||
1143 | return; | ||
1144 | |||
1145 | if (!malloc_started) { | ||
1146 | wrtwarning("malloc() has never been called.\n"); | ||
1147 | return; | ||
1148 | } | ||
1149 | |||
1150 | /* If we're already sinking, don't make matters any worse. */ | ||
1151 | if (suicide) | ||
1152 | return; | ||
1153 | |||
1154 | index = ptr2index(ptr); | ||
1155 | |||
1156 | if (index < malloc_pageshift) { | ||
1157 | wrtwarning("junk pointer, too low to make sense.\n"); | ||
1158 | return; | ||
1159 | } | ||
1160 | |||
1161 | if (index > last_index) { | ||
1162 | wrtwarning("junk pointer, too high to make sense.\n"); | ||
1163 | return; | ||
1164 | } | ||
1165 | |||
1166 | info = page_dir[index]; | ||
1167 | |||
1168 | if (info < MALLOC_MAGIC) | ||
1169 | free_pages(ptr, index, info); | ||
1170 | else | ||
1171 | free_bytes(ptr, index, info); | ||
1172 | return; | ||
1173 | } | ||
1174 | |||
1175 | /* | ||
1176 | * These are the public exported interface routines. | ||
1177 | */ | ||
1178 | |||
1179 | static int malloc_active; | ||
1180 | |||
1181 | void * | ||
1182 | malloc(size_t size) | ||
1183 | { | ||
1184 | register void *r; | ||
1185 | |||
1186 | malloc_func = " in malloc():"; | ||
1187 | THREAD_LOCK(); | ||
1188 | if (malloc_active++) { | ||
1189 | wrtwarning("recursive call.\n"); | ||
1190 | malloc_active--; | ||
1191 | return (0); | ||
1192 | } | ||
1193 | r = imalloc(size); | ||
1194 | UTRACE(0, size, r); | ||
1195 | malloc_active--; | ||
1196 | THREAD_UNLOCK(); | ||
1197 | if (malloc_xmalloc && !r) | ||
1198 | wrterror("out of memory.\n"); | ||
1199 | return (r); | ||
1200 | } | ||
1201 | |||
1202 | void | ||
1203 | free(void *ptr) | ||
1204 | { | ||
1205 | malloc_func = " in free():"; | ||
1206 | THREAD_LOCK(); | ||
1207 | if (malloc_active++) { | ||
1208 | wrtwarning("recursive call.\n"); | ||
1209 | malloc_active--; | ||
1210 | return; | ||
1211 | } | ||
1212 | ifree(ptr); | ||
1213 | UTRACE(ptr, 0, 0); | ||
1214 | malloc_active--; | ||
1215 | THREAD_UNLOCK(); | ||
1216 | return; | ||
1217 | } | ||
1218 | |||
1219 | void * | ||
1220 | realloc(void *ptr, size_t size) | ||
1221 | { | ||
1222 | register void *r; | ||
1223 | |||
1224 | malloc_func = " in realloc():"; | ||
1225 | THREAD_LOCK(); | ||
1226 | if (malloc_active++) { | ||
1227 | wrtwarning("recursive call.\n"); | ||
1228 | malloc_active--; | ||
1229 | return (0); | ||
1230 | } | ||
1231 | if (!ptr) { | ||
1232 | r = imalloc(size); | ||
1233 | } else { | ||
1234 | r = irealloc(ptr, size); | ||
1235 | } | ||
1236 | UTRACE(ptr, size, r); | ||
1237 | malloc_active--; | ||
1238 | THREAD_UNLOCK(); | ||
1239 | if (malloc_xmalloc && !r) | ||
1240 | wrterror("out of memory.\n"); | ||
1241 | return (r); | ||
1242 | } | ||
diff --git a/src/lib/libc/stdlib/memory.3 b/src/lib/libc/stdlib/memory.3 new file mode 100644 index 0000000000..712c7c45d2 --- /dev/null +++ b/src/lib/libc/stdlib/memory.3 | |||
@@ -0,0 +1,70 @@ | |||
1 | .\" Copyright (c) 1991 Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" Redistribution and use in source and binary forms, with or without | ||
5 | .\" modification, are permitted provided that the following conditions | ||
6 | .\" are met: | ||
7 | .\" 1. Redistributions of source code must retain the above copyright | ||
8 | .\" notice, this list of conditions and the following disclaimer. | ||
9 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
10 | .\" notice, this list of conditions and the following disclaimer in the | ||
11 | .\" documentation and/or other materials provided with the distribution. | ||
12 | .\" 3. All advertising materials mentioning features or use of this software | ||
13 | .\" must display the following acknowledgement: | ||
14 | .\" This product includes software developed by the University of | ||
15 | .\" California, Berkeley and its contributors. | ||
16 | .\" 4. Neither the name of the University nor the names of its contributors | ||
17 | .\" may be used to endorse or promote products derived from this software | ||
18 | .\" without specific prior written permission. | ||
19 | .\" | ||
20 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
21 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
22 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
23 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
24 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
25 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
26 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
27 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
28 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
29 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
30 | .\" SUCH DAMAGE. | ||
31 | .\" | ||
32 | .\" $OpenBSD: memory.3,v 1.2 1996/08/19 08:33:37 tholo Exp $ | ||
33 | .\" | ||
34 | .Dd May 2, 1991 | ||
35 | .Dt MEMORY 3 | ||
36 | .Os BSD 4 | ||
37 | .Sh NAME | ||
38 | .Nm malloc , | ||
39 | .Nm free , | ||
40 | .Nm realloc , | ||
41 | .Nm calloc , | ||
42 | .Nm alloca | ||
43 | .Nd general memory allocation operations | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft void * | ||
47 | .Fn malloc "size_t size" | ||
48 | .Ft void | ||
49 | .Fn free "void *ptr" | ||
50 | .Ft void * | ||
51 | .Fn realloc "void *ptr" "size_t size" | ||
52 | .Ft void * | ||
53 | .Fn calloc "size_t nelem" "size_t elsize" | ||
54 | .Ft void * | ||
55 | .Fn alloca "size_t size" | ||
56 | .Sh DESCRIPTION | ||
57 | These functions allocate and free memory for the calling process. | ||
58 | They are described in the | ||
59 | individual manual pages. | ||
60 | .Sh SEE ALSO | ||
61 | .Xr calloc 3 , | ||
62 | .Xr free 3 , | ||
63 | .Xr malloc 3 , | ||
64 | .Xr realloc 3 , | ||
65 | .Xr alloca 3 , | ||
66 | .Sh STANDARDS | ||
67 | These functions, with the exception of | ||
68 | .Fn alloca | ||
69 | conform to | ||
70 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/merge.c b/src/lib/libc/stdlib/merge.c new file mode 100644 index 0000000000..0a1015ad9d --- /dev/null +++ b/src/lib/libc/stdlib/merge.c | |||
@@ -0,0 +1,347 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1992, 1993 | ||
3 | * The Regents of the University of California. All rights reserved. | ||
4 | * | ||
5 | * This code is derived from software contributed to Berkeley by | ||
6 | * Peter McIlroy. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * 1. Redistributions of source code must retain the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer. | ||
13 | * 2. Redistributions in binary form must reproduce the above copyright | ||
14 | * notice, this list of conditions and the following disclaimer in the | ||
15 | * documentation and/or other materials provided with the distribution. | ||
16 | * 3. All advertising materials mentioning features or use of this software | ||
17 | * must display the following acknowledgement: | ||
18 | * This product includes software developed by the University of | ||
19 | * California, Berkeley and its contributors. | ||
20 | * 4. Neither the name of the University nor the names of its contributors | ||
21 | * may be used to endorse or promote products derived from this software | ||
22 | * without specific prior written permission. | ||
23 | * | ||
24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | * SUCH DAMAGE. | ||
35 | */ | ||
36 | |||
37 | #if defined(LIBC_SCCS) && !defined(lint) | ||
38 | static char *rcsid = "$OpenBSD: merge.c,v 1.3 1996/09/15 09:31:50 tholo Exp $"; | ||
39 | #endif /* LIBC_SCCS and not lint */ | ||
40 | |||
41 | /* | ||
42 | * Hybrid exponential search/linear search merge sort with hybrid | ||
43 | * natural/pairwise first pass. Requires about .3% more comparisons | ||
44 | * for random data than LSMS with pairwise first pass alone. | ||
45 | * It works for objects as small as two bytes. | ||
46 | */ | ||
47 | |||
48 | #define NATURAL | ||
49 | #define THRESHOLD 16 /* Best choice for natural merge cut-off. */ | ||
50 | |||
51 | /* #define NATURAL to get hybrid natural merge. | ||
52 | * (The default is pairwise merging.) | ||
53 | */ | ||
54 | |||
55 | #include <sys/types.h> | ||
56 | |||
57 | #include <errno.h> | ||
58 | #include <stdlib.h> | ||
59 | #include <string.h> | ||
60 | |||
61 | static void setup __P((u_char *, u_char *, size_t, size_t, int (*)())); | ||
62 | static void insertionsort __P((u_char *, size_t, size_t, int (*)())); | ||
63 | |||
64 | #define ISIZE sizeof(int) | ||
65 | #define PSIZE sizeof(u_char *) | ||
66 | #define ICOPY_LIST(src, dst, last) \ | ||
67 | do \ | ||
68 | *(int*)dst = *(int*)src, src += ISIZE, dst += ISIZE; \ | ||
69 | while(src < last) | ||
70 | #define ICOPY_ELT(src, dst, i) \ | ||
71 | do \ | ||
72 | *(int*) dst = *(int*) src, src += ISIZE, dst += ISIZE; \ | ||
73 | while (i -= ISIZE) | ||
74 | |||
75 | #define CCOPY_LIST(src, dst, last) \ | ||
76 | do \ | ||
77 | *dst++ = *src++; \ | ||
78 | while (src < last) | ||
79 | #define CCOPY_ELT(src, dst, i) \ | ||
80 | do \ | ||
81 | *dst++ = *src++; \ | ||
82 | while (i -= 1) | ||
83 | |||
84 | /* | ||
85 | * Find the next possible pointer head. (Trickery for forcing an array | ||
86 | * to do double duty as a linked list when objects do not align with word | ||
87 | * boundaries. | ||
88 | */ | ||
89 | /* Assumption: PSIZE is a power of 2. */ | ||
90 | #define EVAL(p) (u_char **) \ | ||
91 | ((u_char *)0 + \ | ||
92 | (((u_char *)p + PSIZE - 1 - (u_char *) 0) & ~(PSIZE - 1))) | ||
93 | |||
94 | /* | ||
95 | * Arguments are as for qsort. | ||
96 | */ | ||
97 | int | ||
98 | mergesort(base, nmemb, size, cmp) | ||
99 | void *base; | ||
100 | size_t nmemb; | ||
101 | register size_t size; | ||
102 | int (*cmp) __P((const void *, const void *)); | ||
103 | { | ||
104 | register int i, sense; | ||
105 | int big, iflag; | ||
106 | register u_char *f1, *f2, *t, *b, *tp2, *q, *l1, *l2; | ||
107 | u_char *list2, *list1, *p2, *p, *last, **p1; | ||
108 | |||
109 | if (size < PSIZE / 2) { /* Pointers must fit into 2 * size. */ | ||
110 | errno = EINVAL; | ||
111 | return (-1); | ||
112 | } | ||
113 | |||
114 | /* | ||
115 | * XXX | ||
116 | * Stupid subtraction for the Cray. | ||
117 | */ | ||
118 | iflag = 0; | ||
119 | if (!(size % ISIZE) && !(((char *)base - (char *)0) % ISIZE)) | ||
120 | iflag = 1; | ||
121 | |||
122 | if ((list2 = malloc(nmemb * size + PSIZE)) == NULL) | ||
123 | return (-1); | ||
124 | |||
125 | list1 = base; | ||
126 | setup(list1, list2, nmemb, size, cmp); | ||
127 | last = list2 + nmemb * size; | ||
128 | i = big = 0; | ||
129 | while (*EVAL(list2) != last) { | ||
130 | l2 = list1; | ||
131 | p1 = EVAL(list1); | ||
132 | for (tp2 = p2 = list2; p2 != last; p1 = EVAL(l2)) { | ||
133 | p2 = *EVAL(p2); | ||
134 | f1 = l2; | ||
135 | f2 = l1 = list1 + (p2 - list2); | ||
136 | if (p2 != last) | ||
137 | p2 = *EVAL(p2); | ||
138 | l2 = list1 + (p2 - list2); | ||
139 | while (f1 < l1 && f2 < l2) { | ||
140 | if ((*cmp)(f1, f2) <= 0) { | ||
141 | q = f2; | ||
142 | b = f1, t = l1; | ||
143 | sense = -1; | ||
144 | } else { | ||
145 | q = f1; | ||
146 | b = f2, t = l2; | ||
147 | sense = 0; | ||
148 | } | ||
149 | if (!big) { /* here i = 0 */ | ||
150 | while ((b += size) < t && cmp(q, b) >sense) | ||
151 | if (++i == 6) { | ||
152 | big = 1; | ||
153 | goto EXPONENTIAL; | ||
154 | } | ||
155 | } else { | ||
156 | EXPONENTIAL: for (i = size; ; i <<= 1) | ||
157 | if ((p = (b + i)) >= t) { | ||
158 | if ((p = t - size) > b && | ||
159 | (*cmp)(q, p) <= sense) | ||
160 | t = p; | ||
161 | else | ||
162 | b = p; | ||
163 | break; | ||
164 | } else if ((*cmp)(q, p) <= sense) { | ||
165 | t = p; | ||
166 | if (i == size) | ||
167 | big = 0; | ||
168 | goto FASTCASE; | ||
169 | } else | ||
170 | b = p; | ||
171 | while (t > b+size) { | ||
172 | i = (((t - b) / size) >> 1) * size; | ||
173 | if ((*cmp)(q, p = b + i) <= sense) | ||
174 | t = p; | ||
175 | else | ||
176 | b = p; | ||
177 | } | ||
178 | goto COPY; | ||
179 | FASTCASE: while (i > size) | ||
180 | if ((*cmp)(q, | ||
181 | p = b + (i >>= 1)) <= sense) | ||
182 | t = p; | ||
183 | else | ||
184 | b = p; | ||
185 | COPY: b = t; | ||
186 | } | ||
187 | i = size; | ||
188 | if (q == f1) { | ||
189 | if (iflag) { | ||
190 | ICOPY_LIST(f2, tp2, b); | ||
191 | ICOPY_ELT(f1, tp2, i); | ||
192 | } else { | ||
193 | CCOPY_LIST(f2, tp2, b); | ||
194 | CCOPY_ELT(f1, tp2, i); | ||
195 | } | ||
196 | } else { | ||
197 | if (iflag) { | ||
198 | ICOPY_LIST(f1, tp2, b); | ||
199 | ICOPY_ELT(f2, tp2, i); | ||
200 | } else { | ||
201 | CCOPY_LIST(f1, tp2, b); | ||
202 | CCOPY_ELT(f2, tp2, i); | ||
203 | } | ||
204 | } | ||
205 | } | ||
206 | if (f2 < l2) { | ||
207 | if (iflag) | ||
208 | ICOPY_LIST(f2, tp2, l2); | ||
209 | else | ||
210 | CCOPY_LIST(f2, tp2, l2); | ||
211 | } else if (f1 < l1) { | ||
212 | if (iflag) | ||
213 | ICOPY_LIST(f1, tp2, l1); | ||
214 | else | ||
215 | CCOPY_LIST(f1, tp2, l1); | ||
216 | } | ||
217 | *p1 = l2; | ||
218 | } | ||
219 | tp2 = list1; /* swap list1, list2 */ | ||
220 | list1 = list2; | ||
221 | list2 = tp2; | ||
222 | last = list2 + nmemb*size; | ||
223 | } | ||
224 | if (base == list2) { | ||
225 | memmove(list2, list1, nmemb*size); | ||
226 | list2 = list1; | ||
227 | } | ||
228 | free(list2); | ||
229 | return (0); | ||
230 | } | ||
231 | |||
232 | #define swap(a, b) { \ | ||
233 | s = b; \ | ||
234 | i = size; \ | ||
235 | do { \ | ||
236 | tmp = *a; *a++ = *s; *s++ = tmp; \ | ||
237 | } while (--i); \ | ||
238 | a -= size; \ | ||
239 | } | ||
240 | #define reverse(bot, top) { \ | ||
241 | s = top; \ | ||
242 | do { \ | ||
243 | i = size; \ | ||
244 | do { \ | ||
245 | tmp = *bot; *bot++ = *s; *s++ = tmp; \ | ||
246 | } while (--i); \ | ||
247 | s -= size2; \ | ||
248 | } while(bot < s); \ | ||
249 | } | ||
250 | |||
251 | /* | ||
252 | * Optional hybrid natural/pairwise first pass. Eats up list1 in runs of | ||
253 | * increasing order, list2 in a corresponding linked list. Checks for runs | ||
254 | * when THRESHOLD/2 pairs compare with same sense. (Only used when NATURAL | ||
255 | * is defined. Otherwise simple pairwise merging is used.) | ||
256 | */ | ||
257 | void | ||
258 | setup(list1, list2, n, size, cmp) | ||
259 | size_t n, size; | ||
260 | int (*cmp) __P((const void *, const void *)); | ||
261 | u_char *list1, *list2; | ||
262 | { | ||
263 | int i, length, size2, tmp, sense; | ||
264 | u_char *f1, *f2, *s, *l2, *last, *p2; | ||
265 | |||
266 | size2 = size*2; | ||
267 | if (n <= 5) { | ||
268 | insertionsort(list1, n, size, cmp); | ||
269 | *EVAL(list2) = (u_char*) list2 + n*size; | ||
270 | return; | ||
271 | } | ||
272 | /* | ||
273 | * Avoid running pointers out of bounds; limit n to evens | ||
274 | * for simplicity. | ||
275 | */ | ||
276 | i = 4 + (n & 1); | ||
277 | insertionsort(list1 + (n - i) * size, i, size, cmp); | ||
278 | last = list1 + size * (n - i); | ||
279 | *EVAL(list2 + (last - list1)) = list2 + n * size; | ||
280 | |||
281 | #ifdef NATURAL | ||
282 | p2 = list2; | ||
283 | f1 = list1; | ||
284 | sense = (cmp(f1, f1 + size) > 0); | ||
285 | for (; f1 < last; sense = !sense) { | ||
286 | length = 2; | ||
287 | /* Find pairs with same sense. */ | ||
288 | for (f2 = f1 + size2; f2 < last; f2 += size2) { | ||
289 | if ((cmp(f2, f2+ size) > 0) != sense) | ||
290 | break; | ||
291 | length += 2; | ||
292 | } | ||
293 | if (length < THRESHOLD) { /* Pairwise merge */ | ||
294 | do { | ||
295 | p2 = *EVAL(p2) = f1 + size2 - list1 + list2; | ||
296 | if (sense > 0) | ||
297 | swap (f1, f1 + size); | ||
298 | } while ((f1 += size2) < f2); | ||
299 | } else { /* Natural merge */ | ||
300 | l2 = f2; | ||
301 | for (f2 = f1 + size2; f2 < l2; f2 += size2) { | ||
302 | if ((cmp(f2-size, f2) > 0) != sense) { | ||
303 | p2 = *EVAL(p2) = f2 - list1 + list2; | ||
304 | if (sense > 0) | ||
305 | reverse(f1, f2-size); | ||
306 | f1 = f2; | ||
307 | } | ||
308 | } | ||
309 | if (sense > 0) | ||
310 | reverse (f1, f2-size); | ||
311 | f1 = f2; | ||
312 | if (f2 < last || cmp(f2 - size, f2) > 0) | ||
313 | p2 = *EVAL(p2) = f2 - list1 + list2; | ||
314 | else | ||
315 | p2 = *EVAL(p2) = list2 + n*size; | ||
316 | } | ||
317 | } | ||
318 | #else /* pairwise merge only. */ | ||
319 | for (f1 = list1, p2 = list2; f1 < last; f1 += size2) { | ||
320 | p2 = *EVAL(p2) = p2 + size2; | ||
321 | if (cmp (f1, f1 + size) > 0) | ||
322 | swap(f1, f1 + size); | ||
323 | } | ||
324 | #endif /* NATURAL */ | ||
325 | } | ||
326 | |||
327 | /* | ||
328 | * This is to avoid out-of-bounds addresses in sorting the | ||
329 | * last 4 elements. | ||
330 | */ | ||
331 | static void | ||
332 | insertionsort(a, n, size, cmp) | ||
333 | u_char *a; | ||
334 | size_t n, size; | ||
335 | int (*cmp) __P((const void *, const void *)); | ||
336 | { | ||
337 | u_char *ai, *s, *t, *u, tmp; | ||
338 | int i; | ||
339 | |||
340 | for (ai = a+size; --n >= 1; ai += size) | ||
341 | for (t = ai; t > a; t -= size) { | ||
342 | u = t - size; | ||
343 | if (cmp(u, t) <= 0) | ||
344 | break; | ||
345 | swap(u, t); | ||
346 | } | ||
347 | } | ||
diff --git a/src/lib/libc/stdlib/mrand48.c b/src/lib/libc/stdlib/mrand48.c new file mode 100644 index 0000000000..cd34260b5c --- /dev/null +++ b/src/lib/libc/stdlib/mrand48.c | |||
@@ -0,0 +1,27 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | */ | ||
13 | |||
14 | #if defined(LIBC_SCCS) && !defined(lint) | ||
15 | static char rcsid[] = "$OpenBSD: mrand48.c,v 1.2 1996/08/19 08:33:39 tholo Exp $"; | ||
16 | #endif /* LIBC_SCCS and not lint */ | ||
17 | |||
18 | #include "rand48.h" | ||
19 | |||
20 | extern unsigned short __rand48_seed[3]; | ||
21 | |||
22 | long | ||
23 | mrand48(void) | ||
24 | { | ||
25 | __dorand48(__rand48_seed); | ||
26 | return ((long) __rand48_seed[2] << 16) + (long) __rand48_seed[1]; | ||
27 | } | ||
diff --git a/src/lib/libc/stdlib/multibyte.c b/src/lib/libc/stdlib/multibyte.c new file mode 100644 index 0000000000..12e70c4a2c --- /dev/null +++ b/src/lib/libc/stdlib/multibyte.c | |||
@@ -0,0 +1,130 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1991 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: multibyte.c,v 1.2 1996/08/19 08:33:39 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | |||
40 | /* | ||
41 | * Stub multibyte character functions. | ||
42 | * This cheezy implementation is fixed to the native single-byte | ||
43 | * character set. | ||
44 | */ | ||
45 | |||
46 | int | ||
47 | mblen(s, n) | ||
48 | const char *s; | ||
49 | size_t n; | ||
50 | { | ||
51 | if (s == NULL || *s == '\0') | ||
52 | return 0; | ||
53 | if (n == 0) | ||
54 | return -1; | ||
55 | return 1; | ||
56 | } | ||
57 | |||
58 | /*ARGSUSED*/ | ||
59 | int | ||
60 | mbtowc(pwc, s, n) | ||
61 | wchar_t *pwc; | ||
62 | const char *s; | ||
63 | size_t n; | ||
64 | { | ||
65 | if (s == NULL) | ||
66 | return 0; | ||
67 | if (n == 0) | ||
68 | return -1; | ||
69 | if (pwc) | ||
70 | *pwc = (wchar_t) *s; | ||
71 | return (*s != '\0'); | ||
72 | } | ||
73 | |||
74 | /*ARGSUSED*/ | ||
75 | int | ||
76 | #ifdef __STDC__ | ||
77 | wctomb(char *s, wchar_t wchar) | ||
78 | #else | ||
79 | wctomb(s, wchar) | ||
80 | char *s; | ||
81 | wchar_t wchar; | ||
82 | #endif | ||
83 | { | ||
84 | if (s == NULL) | ||
85 | return 0; | ||
86 | |||
87 | *s = (char) wchar; | ||
88 | return 1; | ||
89 | } | ||
90 | |||
91 | /*ARGSUSED*/ | ||
92 | size_t | ||
93 | mbstowcs(pwcs, s, n) | ||
94 | wchar_t *pwcs; | ||
95 | const char *s; | ||
96 | size_t n; | ||
97 | { | ||
98 | int count = 0; | ||
99 | |||
100 | if (n != 0) { | ||
101 | do { | ||
102 | if ((*pwcs++ = (wchar_t) *s++) == 0) | ||
103 | break; | ||
104 | count++; | ||
105 | } while (--n != 0); | ||
106 | } | ||
107 | |||
108 | return count; | ||
109 | } | ||
110 | |||
111 | /*ARGSUSED*/ | ||
112 | size_t | ||
113 | wcstombs(s, pwcs, n) | ||
114 | char *s; | ||
115 | const wchar_t *pwcs; | ||
116 | size_t n; | ||
117 | { | ||
118 | int count = 0; | ||
119 | |||
120 | if (n != 0) { | ||
121 | do { | ||
122 | if ((*s++ = (char) *pwcs++) == 0) | ||
123 | break; | ||
124 | count++; | ||
125 | } while (--n != 0); | ||
126 | } | ||
127 | |||
128 | return count; | ||
129 | } | ||
130 | |||
diff --git a/src/lib/libc/stdlib/nrand48.c b/src/lib/libc/stdlib/nrand48.c new file mode 100644 index 0000000000..b1ec2cebb1 --- /dev/null +++ b/src/lib/libc/stdlib/nrand48.c | |||
@@ -0,0 +1,25 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | */ | ||
13 | |||
14 | #if defined(LIBC_SCCS) && !defined(lint) | ||
15 | static char rcsid[] = "$OpenBSD: nrand48.c,v 1.2 1996/08/19 08:33:40 tholo Exp $"; | ||
16 | #endif /* LIBC_SCCS and not lint */ | ||
17 | |||
18 | #include "rand48.h" | ||
19 | |||
20 | long | ||
21 | nrand48(unsigned short xseed[3]) | ||
22 | { | ||
23 | __dorand48(xseed); | ||
24 | return ((long) xseed[2] << 15) + ((long) xseed[1] >> 1); | ||
25 | } | ||
diff --git a/src/lib/libc/stdlib/putenv.c b/src/lib/libc/stdlib/putenv.c new file mode 100644 index 0000000000..d8c4886d4b --- /dev/null +++ b/src/lib/libc/stdlib/putenv.c | |||
@@ -0,0 +1,58 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1988, 1993 | ||
3 | * The Regents of the University of California. All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: putenv.c,v 1.2 1996/08/10 05:03:00 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | #include <string.h> | ||
40 | |||
41 | int | ||
42 | putenv(str) | ||
43 | const char *str; | ||
44 | { | ||
45 | char *p, *equal; | ||
46 | int rval; | ||
47 | |||
48 | if ((p = strdup(str)) == NULL) | ||
49 | return (-1); | ||
50 | if ((equal = strchr(p, '=')) == NULL) { | ||
51 | (void)free(p); | ||
52 | return (-1); | ||
53 | } | ||
54 | *equal = '\0'; | ||
55 | rval = setenv(p, equal + 1, 1); | ||
56 | (void)free(p); | ||
57 | return (rval); | ||
58 | } | ||
diff --git a/src/lib/libc/stdlib/qabs.3 b/src/lib/libc/stdlib/qabs.3 new file mode 100644 index 0000000000..92a8bdc4b9 --- /dev/null +++ b/src/lib/libc/stdlib/qabs.3 | |||
@@ -0,0 +1,61 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: qabs.3,v 1.2 1996/08/19 08:33:40 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt QABS 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm qabs | ||
43 | .Nd return the absolute value of a quad integer | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft quad_t | ||
47 | .Fn qabs "quad_t j" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn qabs | ||
51 | function | ||
52 | returns the absolute value of the quad integer | ||
53 | .Ar j . | ||
54 | .Sh SEE ALSO | ||
55 | .Xr abs 3 , | ||
56 | .Xr labs 3 , | ||
57 | .Xr floor 3 , | ||
58 | .Xr cabs 3 , | ||
59 | .Xr math 3 | ||
60 | .Sh BUGS | ||
61 | The absolute value of the most negative integer remains negative. | ||
diff --git a/src/lib/libc/stdlib/qabs.c b/src/lib/libc/stdlib/qabs.c new file mode 100644 index 0000000000..ccc42cbec6 --- /dev/null +++ b/src/lib/libc/stdlib/qabs.c | |||
@@ -0,0 +1,45 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1990 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: qabs.c,v 1.2 1996/08/19 08:33:40 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | |||
40 | quad_t | ||
41 | qabs(j) | ||
42 | quad_t j; | ||
43 | { | ||
44 | return(j < 0 ? -j : j); | ||
45 | } | ||
diff --git a/src/lib/libc/stdlib/qdiv.3 b/src/lib/libc/stdlib/qdiv.3 new file mode 100644 index 0000000000..12aca0b1ea --- /dev/null +++ b/src/lib/libc/stdlib/qdiv.3 | |||
@@ -0,0 +1,65 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" Chris Torek and the American National Standards Committee X3, | ||
6 | .\" on Information Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: qdiv.3,v 1.2 1996/08/19 08:33:41 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt QDIV 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm qdiv | ||
43 | .Nd return quotient and remainder from division | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft qdiv_t | ||
47 | .Fn qdiv "quad_t num" "quad_t denom" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn qdiv | ||
51 | function | ||
52 | computes the value | ||
53 | .Ar num/denom | ||
54 | and returns the quotient and remainder in a structure named | ||
55 | .Ar qdiv_t | ||
56 | that contains two | ||
57 | .Em quad integer | ||
58 | members named | ||
59 | .Ar quot | ||
60 | and | ||
61 | .Ar rem . | ||
62 | .Sh SEE ALSO | ||
63 | .Xr div 3 , | ||
64 | .Xr ldiv 3 , | ||
65 | .Xr math 3 | ||
diff --git a/src/lib/libc/stdlib/qdiv.c b/src/lib/libc/stdlib/qdiv.c new file mode 100644 index 0000000000..07e84cd649 --- /dev/null +++ b/src/lib/libc/stdlib/qdiv.c | |||
@@ -0,0 +1,58 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1990 Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * This code is derived from software contributed to Berkeley by | ||
6 | * Chris Torek. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * 1. Redistributions of source code must retain the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer. | ||
13 | * 2. Redistributions in binary form must reproduce the above copyright | ||
14 | * notice, this list of conditions and the following disclaimer in the | ||
15 | * documentation and/or other materials provided with the distribution. | ||
16 | * 3. All advertising materials mentioning features or use of this software | ||
17 | * must display the following acknowledgement: | ||
18 | * This product includes software developed by the University of | ||
19 | * California, Berkeley and its contributors. | ||
20 | * 4. Neither the name of the University nor the names of its contributors | ||
21 | * may be used to endorse or promote products derived from this software | ||
22 | * without specific prior written permission. | ||
23 | * | ||
24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | * SUCH DAMAGE. | ||
35 | */ | ||
36 | |||
37 | #if defined(LIBC_SCCS) && !defined(lint) | ||
38 | static char *rcsid = "$OpenBSD: qdiv.c,v 1.2 1996/08/19 08:33:41 tholo Exp $"; | ||
39 | #endif /* LIBC_SCCS and not lint */ | ||
40 | |||
41 | #include <stdlib.h> /* qdiv_t */ | ||
42 | |||
43 | qdiv_t | ||
44 | qdiv(num, denom) | ||
45 | quad_t num, denom; | ||
46 | { | ||
47 | qdiv_t r; | ||
48 | |||
49 | /* see div.c for comments */ | ||
50 | |||
51 | r.quot = num / denom; | ||
52 | r.rem = num % denom; | ||
53 | if (num >= 0 && r.rem < 0) { | ||
54 | r.quot++; | ||
55 | r.rem -= denom; | ||
56 | } | ||
57 | return (r); | ||
58 | } | ||
diff --git a/src/lib/libc/stdlib/qsort.3 b/src/lib/libc/stdlib/qsort.3 new file mode 100644 index 0000000000..a65c5819d0 --- /dev/null +++ b/src/lib/libc/stdlib/qsort.3 | |||
@@ -0,0 +1,233 @@ | |||
1 | .\" Copyright (c) 1990, 1991, 1993 | ||
2 | .\" The Regents of the University of California. All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: qsort.3,v 1.2 1996/08/19 08:33:42 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 4, 1993 | ||
39 | .Dt QSORT 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm qsort, heapsort, mergesort | ||
43 | .Nd sort functions | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft void | ||
47 | .Fn qsort "void *base" "size_t nmemb" "size_t size" "int (*compar)(const void *, const void *)" | ||
48 | .Ft int | ||
49 | .Fn heapsort "void *base" "size_t nmemb" "size_t size" "int (*compar)(const void *, const void *)" | ||
50 | .Ft int | ||
51 | .Fn mergesort "void *base" "size_t nmemb" "size_t size" "int (*compar)(const void *, const void *)" | ||
52 | .Sh DESCRIPTION | ||
53 | The | ||
54 | .Fn qsort | ||
55 | function is a modified partition-exchange sort, or quicksort. | ||
56 | The | ||
57 | .Fn heapsort | ||
58 | function is a modified selection sort. | ||
59 | The | ||
60 | .Fn mergesort | ||
61 | function is a modified merge sort with exponential search | ||
62 | intended for sorting data with pre-existing order. | ||
63 | .Pp | ||
64 | The | ||
65 | .Fn qsort | ||
66 | and | ||
67 | .Fn heapsort | ||
68 | functions sort an array of | ||
69 | .Fa nmemb | ||
70 | objects, the initial member of which is pointed to by | ||
71 | .Fa base . | ||
72 | The size of each object is specified by | ||
73 | .Fa size . | ||
74 | .Fn Mergesort | ||
75 | behaves similarly, but | ||
76 | .Em requires | ||
77 | that | ||
78 | .Fa size | ||
79 | be greater than | ||
80 | .Dq "sizeof(void *) / 2" . | ||
81 | .Pp | ||
82 | The contents of the array | ||
83 | .Fa base | ||
84 | are sorted in ascending order according to | ||
85 | a comparison function pointed to by | ||
86 | .Fa compar , | ||
87 | which requires two arguments pointing to the objects being | ||
88 | compared. | ||
89 | .Pp | ||
90 | The comparison function must return an integer less than, equal to, or | ||
91 | greater than zero if the first argument is considered to be respectively | ||
92 | less than, equal to, or greater than the second. | ||
93 | .Pp | ||
94 | The functions | ||
95 | .Fn qsort | ||
96 | and | ||
97 | .Fn heapsort | ||
98 | are | ||
99 | .Em not | ||
100 | stable, that is, if two members compare as equal, their order in | ||
101 | the sorted array is undefined. | ||
102 | The function | ||
103 | .Fn mergesort | ||
104 | is stable. | ||
105 | .Pp | ||
106 | The | ||
107 | .Fn qsort | ||
108 | function is an implementation of C.A.R. Hoare's ``quicksort'' algorithm, | ||
109 | a variant of partition-exchange sorting; in particular, see D.E. Knuth's | ||
110 | Algorithm Q. | ||
111 | .Fn Qsort | ||
112 | takes O N lg N average time. | ||
113 | This implementation uses median selection to avoid its | ||
114 | O N**2 worst-case behavior. | ||
115 | .Pp | ||
116 | The | ||
117 | .Fn heapsort | ||
118 | function is an implementation of J.W.J. William's ``heapsort'' algorithm, | ||
119 | a variant of selection sorting; in particular, see D.E. Knuth's Algorithm H. | ||
120 | .Fn Heapsort | ||
121 | takes O N lg N worst-case time. | ||
122 | Its | ||
123 | .Em only | ||
124 | advantage over | ||
125 | .Fn qsort | ||
126 | is that it uses almost no additional memory; while | ||
127 | .Fn qsort | ||
128 | does not allocate memory, it is implemented using recursion. | ||
129 | .Pp | ||
130 | The function | ||
131 | .Fn mergesort | ||
132 | requires additional memory of size | ||
133 | .Fa nmemb * | ||
134 | .Fa size | ||
135 | bytes; it should be used only when space is not at a premium. | ||
136 | .Fn Mergesort | ||
137 | is optimized for data with pre-existing order; its worst case | ||
138 | time is O N lg N; its best case is O N. | ||
139 | .Pp | ||
140 | Normally, | ||
141 | .Fn qsort | ||
142 | is faster than | ||
143 | .Fn mergesort | ||
144 | is faster than | ||
145 | .Fn heapsort . | ||
146 | Memory availability and pre-existing order in the data can make this | ||
147 | untrue. | ||
148 | .Sh RETURN VALUES | ||
149 | The | ||
150 | .Fn qsort | ||
151 | function | ||
152 | returns no value. | ||
153 | .Pp | ||
154 | Upon successful completion, | ||
155 | .Fn heapsort | ||
156 | and | ||
157 | .Fn mergesort | ||
158 | return 0. | ||
159 | Otherwise, they return \-1 and the global variable | ||
160 | .Va errno | ||
161 | is set to indicate the error. | ||
162 | .Sh ERRORS | ||
163 | The | ||
164 | .Fn heapsort | ||
165 | function succeeds unless: | ||
166 | .Bl -tag -width Er | ||
167 | .It Bq Er EINVAL | ||
168 | The | ||
169 | .Fa size | ||
170 | argument is zero, or, | ||
171 | the | ||
172 | .Fa size | ||
173 | argument to | ||
174 | .Fn mergesort | ||
175 | is less than | ||
176 | .Dq "sizeof(void *) / 2" . | ||
177 | .It Bq Er ENOMEM | ||
178 | .Fn Heapsort | ||
179 | or | ||
180 | .Fn mergesort | ||
181 | were unable to allocate memory. | ||
182 | .El | ||
183 | .Sh COMPATIBILITY | ||
184 | Previous versions of | ||
185 | .Fn qsort | ||
186 | did not permit the comparison routine itself to call | ||
187 | .Fn qsort 3 . | ||
188 | This is no longer true. | ||
189 | .Sh SEE ALSO | ||
190 | .Xr sort 1 , | ||
191 | .Xr radixsort 3 | ||
192 | .Rs | ||
193 | .%A Hoare, C.A.R. | ||
194 | .%D 1962 | ||
195 | .%T "Quicksort" | ||
196 | .%J "The Computer Journal" | ||
197 | .%V 5:1 | ||
198 | .%P pp. 10-15 | ||
199 | .Re | ||
200 | .Rs | ||
201 | .%A Williams, J.W.J | ||
202 | .%D 1964 | ||
203 | .%T "Heapsort" | ||
204 | .%J "Communications of the ACM" | ||
205 | .%V 7:1 | ||
206 | .%P pp. 347-348 | ||
207 | .Re | ||
208 | .Rs | ||
209 | .%A Knuth, D.E. | ||
210 | .%D 1968 | ||
211 | .%B "The Art of Computer Programming" | ||
212 | .%V Vol. 3 | ||
213 | .%T "Sorting and Searching" | ||
214 | .%P pp. 114-123, 145-149 | ||
215 | .Re | ||
216 | .Rs | ||
217 | .%A Mcilroy, P.M. | ||
218 | .%T "Optimistic Sorting and Information Theoretic Complexity" | ||
219 | .%J "Fourth Annual ACM-SIAM Symposium on Discrete Algorithms" | ||
220 | .%V January 1992 | ||
221 | .Re | ||
222 | .Rs | ||
223 | .%A Bentley, J.L. | ||
224 | .%T "Engineering a Sort Function" | ||
225 | .%J "bentley@research.att.com" | ||
226 | .%V January 1992 | ||
227 | .Re | ||
228 | .Sh STANDARDS | ||
229 | The | ||
230 | .Fn qsort | ||
231 | function | ||
232 | conforms to | ||
233 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/qsort.c b/src/lib/libc/stdlib/qsort.c new file mode 100644 index 0000000000..1c3020b595 --- /dev/null +++ b/src/lib/libc/stdlib/qsort.c | |||
@@ -0,0 +1,175 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1992, 1993 | ||
3 | * The Regents of the University of California. All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: qsort.c,v 1.5 1997/06/20 11:19:38 deraadt Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <sys/types.h> | ||
39 | #include <stdlib.h> | ||
40 | |||
41 | static __inline char *med3 __P((char *, char *, char *, int (*)())); | ||
42 | static __inline void swapfunc __P((char *, char *, int, int)); | ||
43 | |||
44 | #define min(a, b) (a) < (b) ? a : b | ||
45 | |||
46 | /* | ||
47 | * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function". | ||
48 | */ | ||
49 | #define swapcode(TYPE, parmi, parmj, n) { \ | ||
50 | long i = (n) / sizeof (TYPE); \ | ||
51 | register TYPE *pi = (TYPE *) (parmi); \ | ||
52 | register TYPE *pj = (TYPE *) (parmj); \ | ||
53 | do { \ | ||
54 | register TYPE t = *pi; \ | ||
55 | *pi++ = *pj; \ | ||
56 | *pj++ = t; \ | ||
57 | } while (--i > 0); \ | ||
58 | } | ||
59 | |||
60 | #define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \ | ||
61 | es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1; | ||
62 | |||
63 | static __inline void | ||
64 | swapfunc(a, b, n, swaptype) | ||
65 | char *a, *b; | ||
66 | int n, swaptype; | ||
67 | { | ||
68 | if (swaptype <= 1) | ||
69 | swapcode(long, a, b, n) | ||
70 | else | ||
71 | swapcode(char, a, b, n) | ||
72 | } | ||
73 | |||
74 | #define swap(a, b) \ | ||
75 | if (swaptype == 0) { \ | ||
76 | long t = *(long *)(a); \ | ||
77 | *(long *)(a) = *(long *)(b); \ | ||
78 | *(long *)(b) = t; \ | ||
79 | } else \ | ||
80 | swapfunc(a, b, es, swaptype) | ||
81 | |||
82 | #define vecswap(a, b, n) if ((n) > 0) swapfunc(a, b, n, swaptype) | ||
83 | |||
84 | static __inline char * | ||
85 | med3(a, b, c, cmp) | ||
86 | char *a, *b, *c; | ||
87 | int (*cmp)(); | ||
88 | { | ||
89 | return cmp(a, b) < 0 ? | ||
90 | (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a )) | ||
91 | :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c )); | ||
92 | } | ||
93 | |||
94 | void | ||
95 | qsort(aa, n, es, cmp) | ||
96 | void *aa; | ||
97 | size_t n, es; | ||
98 | int (*cmp)(); | ||
99 | { | ||
100 | char *pa, *pb, *pc, *pd, *pl, *pm, *pn; | ||
101 | int d, r, swaptype, swap_cnt; | ||
102 | register char *a = aa; | ||
103 | |||
104 | loop: SWAPINIT(a, es); | ||
105 | swap_cnt = 0; | ||
106 | if (n < 7) { | ||
107 | for (pm = (char *)a + es; pm < (char *) a + n * es; pm += es) | ||
108 | for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; | ||
109 | pl -= es) | ||
110 | swap(pl, pl - es); | ||
111 | return; | ||
112 | } | ||
113 | pm = (char *)a + (n / 2) * es; | ||
114 | if (n > 7) { | ||
115 | pl = (char *)a; | ||
116 | pn = (char *)a + (n - 1) * es; | ||
117 | if (n > 40) { | ||
118 | d = (n / 8) * es; | ||
119 | pl = med3(pl, pl + d, pl + 2 * d, cmp); | ||
120 | pm = med3(pm - d, pm, pm + d, cmp); | ||
121 | pn = med3(pn - 2 * d, pn - d, pn, cmp); | ||
122 | } | ||
123 | pm = med3(pl, pm, pn, cmp); | ||
124 | } | ||
125 | swap(a, pm); | ||
126 | pa = pb = (char *)a + es; | ||
127 | |||
128 | pc = pd = (char *)a + (n - 1) * es; | ||
129 | for (;;) { | ||
130 | while (pb <= pc && (r = cmp(pb, a)) <= 0) { | ||
131 | if (r == 0) { | ||
132 | swap_cnt = 1; | ||
133 | swap(pa, pb); | ||
134 | pa += es; | ||
135 | } | ||
136 | pb += es; | ||
137 | } | ||
138 | while (pb <= pc && (r = cmp(pc, a)) >= 0) { | ||
139 | if (r == 0) { | ||
140 | swap_cnt = 1; | ||
141 | swap(pc, pd); | ||
142 | pd -= es; | ||
143 | } | ||
144 | pc -= es; | ||
145 | } | ||
146 | if (pb > pc) | ||
147 | break; | ||
148 | swap(pb, pc); | ||
149 | swap_cnt = 1; | ||
150 | pb += es; | ||
151 | pc -= es; | ||
152 | } | ||
153 | if (swap_cnt == 0) { /* Switch to insertion sort */ | ||
154 | for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es) | ||
155 | for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; | ||
156 | pl -= es) | ||
157 | swap(pl, pl - es); | ||
158 | return; | ||
159 | } | ||
160 | |||
161 | pn = (char *)a + n * es; | ||
162 | r = min(pa - (char *)a, pb - pa); | ||
163 | vecswap(a, pb - r, r); | ||
164 | r = min(pd - pc, pn - pd - es); | ||
165 | vecswap(pb, pn - r, r); | ||
166 | if ((r = pb - pa) > es) | ||
167 | qsort(a, r / es, es, cmp); | ||
168 | if ((r = pd - pc) > es) { | ||
169 | /* Iterate rather than recurse to save stack space */ | ||
170 | a = pn - r; | ||
171 | n = r / es; | ||
172 | goto loop; | ||
173 | } | ||
174 | /* qsort(pn - r, r / es, es, cmp);*/ | ||
175 | } | ||
diff --git a/src/lib/libc/stdlib/radixsort.3 b/src/lib/libc/stdlib/radixsort.3 new file mode 100644 index 0000000000..8b0ea89a0f --- /dev/null +++ b/src/lib/libc/stdlib/radixsort.3 | |||
@@ -0,0 +1,161 @@ | |||
1 | .\" Copyright (c) 1990, 1991, 1993 | ||
2 | .\" The Regents of the University of California. All rights reserved. | ||
3 | .\" | ||
4 | .\" Redistribution and use in source and binary forms, with or without | ||
5 | .\" modification, are permitted provided that the following conditions | ||
6 | .\" are met: | ||
7 | .\" 1. Redistributions of source code must retain the above copyright | ||
8 | .\" notice, this list of conditions and the following disclaimer. | ||
9 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
10 | .\" notice, this list of conditions and the following disclaimer in the | ||
11 | .\" documentation and/or other materials provided with the distribution. | ||
12 | .\" 3. All advertising materials mentioning features or use of this software | ||
13 | .\" must display the following acknowledgement: | ||
14 | .\" This product includes software developed by the University of | ||
15 | .\" California, Berkeley and its contributors. | ||
16 | .\" 4. Neither the name of the University nor the names of its contributors | ||
17 | .\" may be used to endorse or promote products derived from this software | ||
18 | .\" without specific prior written permission. | ||
19 | .\" | ||
20 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
21 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
22 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
23 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
24 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
25 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
26 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
27 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
28 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
29 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
30 | .\" SUCH DAMAGE. | ||
31 | .\" | ||
32 | .\" $OpenBSD: radixsort.3,v 1.4 1998/06/15 17:55:08 mickey Exp $ | ||
33 | .\" | ||
34 | .Dd January 27, 1994 | ||
35 | .Dt RADIXSORT 3 | ||
36 | .Os | ||
37 | .Sh NAME | ||
38 | .Nm radixsort | ||
39 | .Nd radix sort | ||
40 | .Sh SYNOPSIS | ||
41 | .Fd #include <limits.h> | ||
42 | .Fd #include <stdlib.h> | ||
43 | .Ft int | ||
44 | .Fn radixsort "const u_char **base" "int nmemb" "const u_char *table" "u_int endbyte" | ||
45 | .Ft int | ||
46 | .Fn sradixsort "const u_char **base" "int nmemb" "const u_char *table" "u_int endbyte" | ||
47 | .Sh DESCRIPTION | ||
48 | The | ||
49 | .Fn radixsort | ||
50 | and | ||
51 | .Fn sradixsort | ||
52 | functions | ||
53 | are implementations of radix sort. | ||
54 | .Pp | ||
55 | These functions sort an array of pointers to byte strings, the initial | ||
56 | member of which is referenced by | ||
57 | .Fa base . | ||
58 | The byte strings may contain any values; the end of each string | ||
59 | is denoted by the user-specified value | ||
60 | .Fa endbyte . | ||
61 | .Pp | ||
62 | Applications may specify a sort order by providing the | ||
63 | .Fa table | ||
64 | argument. | ||
65 | If | ||
66 | .Pf non- Dv NULL , | ||
67 | .Fa table | ||
68 | must reference an array of | ||
69 | .Dv UCHAR_MAX | ||
70 | + 1 bytes which contains the sort | ||
71 | weight of each possible byte value. | ||
72 | The end-of-string byte must have a sort weight of 0 or 255 | ||
73 | (for sorting in reverse order). | ||
74 | More than one byte may have the same sort weight. | ||
75 | The | ||
76 | .Fa table | ||
77 | argument | ||
78 | is useful for applications which wish to sort different characters | ||
79 | equally, for example, providing a table with the same weights | ||
80 | for A-Z as for a-z will result in a case-insensitive sort. | ||
81 | If | ||
82 | .Fa table | ||
83 | is NULL, the contents of the array are sorted in ascending order | ||
84 | according to the | ||
85 | .Tn ASCII | ||
86 | order of the byte strings they reference and | ||
87 | .Fa endbyte | ||
88 | has a sorting weight of 0. | ||
89 | .Pp | ||
90 | The | ||
91 | .Fn sradixsort | ||
92 | function is stable, that is, if two elements compare as equal, their | ||
93 | order in the sorted array is unchanged. | ||
94 | The | ||
95 | .Fn sradixsort | ||
96 | function uses additional memory sufficient to hold | ||
97 | .Fa nmemb | ||
98 | pointers. | ||
99 | .Pp | ||
100 | The | ||
101 | .Fn radixsort | ||
102 | function is not stable, but uses no additional memory. | ||
103 | .Pp | ||
104 | These functions are variants of most-significant-byte radix sorting; in | ||
105 | particular, see D.E. Knuth's Algorithm R and section 5.2.5, exercise 10. | ||
106 | They take linear time relative to the number of bytes in the strings. | ||
107 | .Sh RETURN VALUES | ||
108 | Upon successful completion 0 is returned. | ||
109 | Otherwise, \-1 is returned and the global variable | ||
110 | .Va errno | ||
111 | is set to indicate the error. | ||
112 | .Sh ERRORS | ||
113 | .Bl -tag -width Er | ||
114 | .It Bq Er EINVAL | ||
115 | The value of the | ||
116 | .Fa endbyte | ||
117 | element of | ||
118 | .Fa table | ||
119 | is not 0 or 255. | ||
120 | .El | ||
121 | .Pp | ||
122 | Additionally, the | ||
123 | .Fn sradixsort | ||
124 | function | ||
125 | may fail and set | ||
126 | .Va errno | ||
127 | for any of the errors specified for the library routine | ||
128 | .Xr malloc 3 . | ||
129 | .Sh SEE ALSO | ||
130 | .Xr sort 1 , | ||
131 | .Xr qsort 3 | ||
132 | .Pp | ||
133 | .Rs | ||
134 | .%A Knuth, D.E. | ||
135 | .%D 1968 | ||
136 | .%B "The Art of Computer Programming" | ||
137 | .%T "Sorting and Searching" | ||
138 | .%V Vol. 3 | ||
139 | .%P pp. 170-178 | ||
140 | .Re | ||
141 | .Rs | ||
142 | .%A Paige, R. | ||
143 | .%D 1987 | ||
144 | .%T "Three Partition Refinement Algorithms" | ||
145 | .%J "SIAM J. Comput." | ||
146 | .%V Vol. 16 | ||
147 | .%N No. 6 | ||
148 | .Re | ||
149 | .Rs | ||
150 | .%A McIlroy, P. | ||
151 | .%D 1993 | ||
152 | .%B "Engineering Radix Sort" | ||
153 | .%T "Computing Systems" | ||
154 | .%V Vol. 6:1 | ||
155 | .%P pp. 5-27 | ||
156 | .Re | ||
157 | .Sh HISTORY | ||
158 | The | ||
159 | .Fn radixsort | ||
160 | function first appeared in | ||
161 | .Bx 4.4 . | ||
diff --git a/src/lib/libc/stdlib/radixsort.c b/src/lib/libc/stdlib/radixsort.c new file mode 100644 index 0000000000..41ed962466 --- /dev/null +++ b/src/lib/libc/stdlib/radixsort.c | |||
@@ -0,0 +1,317 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1990, 1993 | ||
3 | * The Regents of the University of California. All rights reserved. | ||
4 | * | ||
5 | * This code is derived from software contributed to Berkeley by | ||
6 | * Peter McIlroy and by Dan Bernstein at New York University, | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * 1. Redistributions of source code must retain the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer. | ||
13 | * 2. Redistributions in binary form must reproduce the above copyright | ||
14 | * notice, this list of conditions and the following disclaimer in the | ||
15 | * documentation and/or other materials provided with the distribution. | ||
16 | * 3. All advertising materials mentioning features or use of this software | ||
17 | * must display the following acknowledgement: | ||
18 | * This product includes software developed by the University of | ||
19 | * California, Berkeley and its contributors. | ||
20 | * 4. Neither the name of the University nor the names of its contributors | ||
21 | * may be used to endorse or promote products derived from this software | ||
22 | * without specific prior written permission. | ||
23 | * | ||
24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | * SUCH DAMAGE. | ||
35 | */ | ||
36 | |||
37 | #if defined(LIBC_SCCS) && !defined(lint) | ||
38 | static char *rcsid = "$OpenBSD: radixsort.c,v 1.3 1996/08/19 08:33:44 tholo Exp $"; | ||
39 | #endif /* LIBC_SCCS and not lint */ | ||
40 | |||
41 | /* | ||
42 | * Radixsort routines. | ||
43 | * | ||
44 | * Program r_sort_a() is unstable but uses O(logN) extra memory for a stack. | ||
45 | * Use radixsort(a, n, trace, endchar) for this case. | ||
46 | * | ||
47 | * For stable sorting (using N extra pointers) use sradixsort(), which calls | ||
48 | * r_sort_b(). | ||
49 | * | ||
50 | * For a description of this code, see D. McIlroy, P. McIlroy, K. Bostic, | ||
51 | * "Engineering Radix Sort". | ||
52 | */ | ||
53 | |||
54 | #include <sys/types.h> | ||
55 | #include <stdlib.h> | ||
56 | #include <errno.h> | ||
57 | |||
58 | typedef struct { | ||
59 | const u_char **sa; | ||
60 | int sn, si; | ||
61 | } stack; | ||
62 | |||
63 | static __inline void simplesort | ||
64 | __P((const u_char **, int, int, const u_char *, u_int)); | ||
65 | static void r_sort_a __P((const u_char **, int, int, const u_char *, u_int)); | ||
66 | static void r_sort_b __P((const u_char **, | ||
67 | const u_char **, int, int, const u_char *, u_int)); | ||
68 | |||
69 | #define THRESHOLD 20 /* Divert to simplesort(). */ | ||
70 | #define SIZE 512 /* Default stack size. */ | ||
71 | |||
72 | #define SETUP { \ | ||
73 | if (tab == NULL) { \ | ||
74 | tr = tr0; \ | ||
75 | for (c = 0; c < endch; c++) \ | ||
76 | tr0[c] = c + 1; \ | ||
77 | tr0[c] = 0; \ | ||
78 | for (c++; c < 256; c++) \ | ||
79 | tr0[c] = c; \ | ||
80 | endch = 0; \ | ||
81 | } else { \ | ||
82 | endch = tab[endch]; \ | ||
83 | tr = tab; \ | ||
84 | if (endch != 0 && endch != 255) { \ | ||
85 | errno = EINVAL; \ | ||
86 | return (-1); \ | ||
87 | } \ | ||
88 | } \ | ||
89 | } | ||
90 | |||
91 | int | ||
92 | radixsort(a, n, tab, endch) | ||
93 | const u_char **a, *tab; | ||
94 | int n; | ||
95 | u_int endch; | ||
96 | { | ||
97 | const u_char *tr; | ||
98 | int c; | ||
99 | u_char tr0[256]; | ||
100 | |||
101 | SETUP; | ||
102 | r_sort_a(a, n, 0, tr, endch); | ||
103 | return (0); | ||
104 | } | ||
105 | |||
106 | int | ||
107 | sradixsort(a, n, tab, endch) | ||
108 | const u_char **a, *tab; | ||
109 | int n; | ||
110 | u_int endch; | ||
111 | { | ||
112 | const u_char *tr, **ta; | ||
113 | int c; | ||
114 | u_char tr0[256]; | ||
115 | |||
116 | SETUP; | ||
117 | if (n < THRESHOLD) | ||
118 | simplesort(a, n, 0, tr, endch); | ||
119 | else { | ||
120 | if ((ta = malloc(n * sizeof(a))) == NULL) | ||
121 | return (-1); | ||
122 | r_sort_b(a, ta, n, 0, tr, endch); | ||
123 | free(ta); | ||
124 | } | ||
125 | return (0); | ||
126 | } | ||
127 | |||
128 | #define empty(s) (s >= sp) | ||
129 | #define pop(a, n, i) a = (--sp)->sa, n = sp->sn, i = sp->si | ||
130 | #define push(a, n, i) sp->sa = a, sp->sn = n, (sp++)->si = i | ||
131 | #define swap(a, b, t) t = a, a = b, b = t | ||
132 | |||
133 | /* Unstable, in-place sort. */ | ||
134 | void | ||
135 | r_sort_a(a, n, i, tr, endch) | ||
136 | const u_char **a; | ||
137 | int n, i; | ||
138 | const u_char *tr; | ||
139 | u_int endch; | ||
140 | { | ||
141 | static int count[256], nc, bmin; | ||
142 | register int c; | ||
143 | register const u_char **ak, *r; | ||
144 | stack s[SIZE], *sp, *sp0, *sp1, temp; | ||
145 | int *cp, bigc; | ||
146 | const u_char **an, *t, **aj, **top[256]; | ||
147 | |||
148 | /* Set up stack. */ | ||
149 | sp = s; | ||
150 | push(a, n, i); | ||
151 | while (!empty(s)) { | ||
152 | pop(a, n, i); | ||
153 | if (n < THRESHOLD) { | ||
154 | simplesort(a, n, i, tr, endch); | ||
155 | continue; | ||
156 | } | ||
157 | an = a + n; | ||
158 | |||
159 | /* Make character histogram. */ | ||
160 | if (nc == 0) { | ||
161 | bmin = 255; /* First occupied bin, excluding eos. */ | ||
162 | for (ak = a; ak < an;) { | ||
163 | c = tr[(*ak++)[i]]; | ||
164 | if (++count[c] == 1 && c != endch) { | ||
165 | if (c < bmin) | ||
166 | bmin = c; | ||
167 | nc++; | ||
168 | } | ||
169 | } | ||
170 | if (sp + nc > s + SIZE) { /* Get more stack. */ | ||
171 | r_sort_a(a, n, i, tr, endch); | ||
172 | continue; | ||
173 | } | ||
174 | } | ||
175 | |||
176 | /* | ||
177 | * Set top[]; push incompletely sorted bins onto stack. | ||
178 | * top[] = pointers to last out-of-place element in bins. | ||
179 | * count[] = counts of elements in bins. | ||
180 | * Before permuting: top[c-1] + count[c] = top[c]; | ||
181 | * during deal: top[c] counts down to top[c-1]. | ||
182 | */ | ||
183 | sp0 = sp1 = sp; /* Stack position of biggest bin. */ | ||
184 | bigc = 2; /* Size of biggest bin. */ | ||
185 | if (endch == 0) /* Special case: set top[eos]. */ | ||
186 | top[0] = ak = a + count[0]; | ||
187 | else { | ||
188 | ak = a; | ||
189 | top[255] = an; | ||
190 | } | ||
191 | for (cp = count + bmin; nc > 0; cp++) { | ||
192 | while (*cp == 0) /* Find next non-empty pile. */ | ||
193 | cp++; | ||
194 | if (*cp > 1) { | ||
195 | if (*cp > bigc) { | ||
196 | bigc = *cp; | ||
197 | sp1 = sp; | ||
198 | } | ||
199 | push(ak, *cp, i+1); | ||
200 | } | ||
201 | top[cp-count] = ak += *cp; | ||
202 | nc--; | ||
203 | } | ||
204 | swap(*sp0, *sp1, temp); /* Play it safe -- biggest bin last. */ | ||
205 | |||
206 | /* | ||
207 | * Permute misplacements home. Already home: everything | ||
208 | * before aj, and in bin[c], items from top[c] on. | ||
209 | * Inner loop: | ||
210 | * r = next element to put in place; | ||
211 | * ak = top[r[i]] = location to put the next element. | ||
212 | * aj = bottom of 1st disordered bin. | ||
213 | * Outer loop: | ||
214 | * Once the 1st disordered bin is done, ie. aj >= ak, | ||
215 | * aj<-aj + count[c] connects the bins in a linked list; | ||
216 | * reset count[c]. | ||
217 | */ | ||
218 | for (aj = a; aj < an; *aj = r, aj += count[c], count[c] = 0) | ||
219 | for (r = *aj; aj < (ak = --top[c = tr[r[i]]]);) | ||
220 | swap(*ak, r, t); | ||
221 | } | ||
222 | } | ||
223 | |||
224 | /* Stable sort, requiring additional memory. */ | ||
225 | void | ||
226 | r_sort_b(a, ta, n, i, tr, endch) | ||
227 | const u_char **a, **ta; | ||
228 | int n, i; | ||
229 | const u_char *tr; | ||
230 | u_int endch; | ||
231 | { | ||
232 | static int count[256], nc, bmin; | ||
233 | register int c; | ||
234 | register const u_char **ak, **ai; | ||
235 | stack s[512], *sp, *sp0, *sp1, temp; | ||
236 | const u_char **top[256]; | ||
237 | int *cp, bigc; | ||
238 | |||
239 | sp = s; | ||
240 | push(a, n, i); | ||
241 | while (!empty(s)) { | ||
242 | pop(a, n, i); | ||
243 | if (n < THRESHOLD) { | ||
244 | simplesort(a, n, i, tr, endch); | ||
245 | continue; | ||
246 | } | ||
247 | |||
248 | if (nc == 0) { | ||
249 | bmin = 255; | ||
250 | for (ak = a + n; --ak >= a;) { | ||
251 | c = tr[(*ak)[i]]; | ||
252 | if (++count[c] == 1 && c != endch) { | ||
253 | if (c < bmin) | ||
254 | bmin = c; | ||
255 | nc++; | ||
256 | } | ||
257 | } | ||
258 | if (sp + nc > s + SIZE) { | ||
259 | r_sort_b(a, ta, n, i, tr, endch); | ||
260 | continue; | ||
261 | } | ||
262 | } | ||
263 | |||
264 | sp0 = sp1 = sp; | ||
265 | bigc = 2; | ||
266 | if (endch == 0) { | ||
267 | top[0] = ak = a + count[0]; | ||
268 | count[0] = 0; | ||
269 | } else { | ||
270 | ak = a; | ||
271 | top[255] = a + n; | ||
272 | count[255] = 0; | ||
273 | } | ||
274 | for (cp = count + bmin; nc > 0; cp++) { | ||
275 | while (*cp == 0) | ||
276 | cp++; | ||
277 | if ((c = *cp) > 1) { | ||
278 | if (c > bigc) { | ||
279 | bigc = c; | ||
280 | sp1 = sp; | ||
281 | } | ||
282 | push(ak, c, i+1); | ||
283 | } | ||
284 | top[cp-count] = ak += c; | ||
285 | *cp = 0; /* Reset count[]. */ | ||
286 | nc--; | ||
287 | } | ||
288 | swap(*sp0, *sp1, temp); | ||
289 | |||
290 | for (ak = ta + n, ai = a+n; ak > ta;) /* Copy to temp. */ | ||
291 | *--ak = *--ai; | ||
292 | for (ak = ta+n; --ak >= ta;) /* Deal to piles. */ | ||
293 | *--top[tr[(*ak)[i]]] = *ak; | ||
294 | } | ||
295 | } | ||
296 | |||
297 | static __inline void | ||
298 | simplesort(a, n, b, tr, endch) /* insertion sort */ | ||
299 | register const u_char **a; | ||
300 | int n, b; | ||
301 | register const u_char *tr; | ||
302 | u_int endch; | ||
303 | { | ||
304 | register u_char ch; | ||
305 | const u_char **ak, **ai, *s, *t; | ||
306 | |||
307 | for (ak = a+1; --n >= 1; ak++) | ||
308 | for (ai = ak; ai > a; ai--) { | ||
309 | for (s = ai[0] + b, t = ai[-1] + b; | ||
310 | (ch = tr[*s]) != endch; s++, t++) | ||
311 | if (ch != tr[*t]) | ||
312 | break; | ||
313 | if (ch >= tr[*t]) | ||
314 | break; | ||
315 | swap(ai[0], ai[-1], s); | ||
316 | } | ||
317 | } | ||
diff --git a/src/lib/libc/stdlib/rand.3 b/src/lib/libc/stdlib/rand.3 new file mode 100644 index 0000000000..32d32761f1 --- /dev/null +++ b/src/lib/libc/stdlib/rand.3 | |||
@@ -0,0 +1,87 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: rand.3,v 1.4 1998/07/05 19:54:22 millert Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt RAND 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm rand , | ||
43 | .Nm srand | ||
44 | .Nd bad random number generator | ||
45 | .Sh SYNOPSIS | ||
46 | .Fd #include <stdlib.h> | ||
47 | .Ft void | ||
48 | .Fn srand "unsigned seed" | ||
49 | .Ft int | ||
50 | .Fn rand void | ||
51 | .Sh DESCRIPTION | ||
52 | .Bf -symbolic | ||
53 | These interfaces are obsoleted by | ||
54 | .Xr random 3 . | ||
55 | .Ef | ||
56 | .Pp | ||
57 | The | ||
58 | .Fn rand | ||
59 | function computes a sequence of pseudo-random integers in the range | ||
60 | of 0 to | ||
61 | .Dv RAND_MAX | ||
62 | (as defined by the header file | ||
63 | .Aq Pa stdlib.h ) . | ||
64 | .Pp | ||
65 | The | ||
66 | .Fn srand | ||
67 | function sets its argument as the seed for a new sequence of | ||
68 | pseudo-random numbers to be returned by | ||
69 | .Fn rand . | ||
70 | These sequences are repeatable by calling | ||
71 | .Fn srand | ||
72 | with the same seed value. | ||
73 | .Pp | ||
74 | If no seed value is provided, the functions are automatically | ||
75 | seeded with a value of 1. | ||
76 | .Sh SEE ALSO | ||
77 | .Xr arc4random 3 , | ||
78 | .Xr rand48 3 , | ||
79 | .Xr random 3 | ||
80 | .Sh STANDARDS | ||
81 | The | ||
82 | .Fn rand | ||
83 | and | ||
84 | .Fn srand | ||
85 | functions | ||
86 | conform to | ||
87 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/rand.c b/src/lib/libc/stdlib/rand.c new file mode 100644 index 0000000000..f270ffd986 --- /dev/null +++ b/src/lib/libc/stdlib/rand.c | |||
@@ -0,0 +1,54 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1990 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: rand.c,v 1.2 1996/08/19 08:33:44 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <sys/types.h> | ||
39 | #include <stdlib.h> | ||
40 | |||
41 | static u_long next = 1; | ||
42 | |||
43 | int | ||
44 | rand() | ||
45 | { | ||
46 | return ((next = next * 1103515245 + 12345) % ((u_int)RAND_MAX + 1)); | ||
47 | } | ||
48 | |||
49 | void | ||
50 | srand(seed) | ||
51 | u_int seed; | ||
52 | { | ||
53 | next = seed; | ||
54 | } | ||
diff --git a/src/lib/libc/stdlib/rand48.3 b/src/lib/libc/stdlib/rand48.3 new file mode 100644 index 0000000000..d5236a4779 --- /dev/null +++ b/src/lib/libc/stdlib/rand48.3 | |||
@@ -0,0 +1,161 @@ | |||
1 | \" Copyright (c) 1993 Martin Birgmeier | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" You may redistribute unmodified or modified versions of this source | ||
5 | .\" code provided that the above copyright notice and this and the | ||
6 | .\" following conditions are retained. | ||
7 | .\" | ||
8 | .\" This software is provided ``as is'', and comes with no warranties | ||
9 | .\" of any kind. I shall in no event be liable for anything that happens | ||
10 | .\" to anyone/anything when using this software. | ||
11 | .\" | ||
12 | .\" $OpenBSD: rand48.3,v 1.3 1998/07/05 19:54:23 millert Exp $ | ||
13 | .\" | ||
14 | .Dd October 8, 1993 | ||
15 | .Dt RAND48 3 | ||
16 | .Os | ||
17 | .Sh NAME | ||
18 | .Nm drand48 , | ||
19 | .Nm erand48 , | ||
20 | .Nm lrand48 , | ||
21 | .Nm nrand48 , | ||
22 | .Nm mrand48 , | ||
23 | .Nm jrand48 , | ||
24 | .Nm srand48 , | ||
25 | .Nm seed48 , | ||
26 | .Nm lcong48 | ||
27 | .Nd pseudo random number generators and initialization routines | ||
28 | .Sh SYNOPSIS | ||
29 | .Fd #include <stdlib.h> | ||
30 | .Ft double | ||
31 | .Fn drand48 void | ||
32 | .Ft double | ||
33 | .Fn erand48 "unsigned short xseed[3]" | ||
34 | .Ft long | ||
35 | .Fn lrand48 void | ||
36 | .Ft long | ||
37 | .Fn nrand48 "unsigned short xseed[3]" | ||
38 | .Ft long | ||
39 | .Fn mrand48 void | ||
40 | .Ft long | ||
41 | .Fn jrand48 "unsigned short xseed[3]" | ||
42 | .Ft void | ||
43 | .Fn srand48 "long seed" | ||
44 | .Ft "unsigned short *" | ||
45 | .Fn seed48 "unsigned short xseed[3]" | ||
46 | .Ft void | ||
47 | .Fn lcong48 "unsigned short p[7]" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn rand48 | ||
51 | family of functions generates pseudo-random numbers using a linear | ||
52 | congruential algorithm working on integers 48 bits in size. The | ||
53 | particular formula employed is | ||
54 | r(n+1) = (a * r(n) + c) mod m | ||
55 | where the default values are | ||
56 | for the multiplicand a = 0xfdeece66d = 25214903917 and | ||
57 | the addend c = 0xb = 11. The modulus is always fixed at m = 2 ** 48. | ||
58 | r(n) is called the seed of the random number generator. | ||
59 | .Pp | ||
60 | For all the six generator routines described next, the first | ||
61 | computational step is to perform a single iteration of the algorithm. | ||
62 | .Pp | ||
63 | .Fn drand48 | ||
64 | and | ||
65 | .Fn erand48 | ||
66 | return values of type double. The full 48 bits of r(n+1) are | ||
67 | loaded into the mantissa of the returned value, with the exponent set | ||
68 | such that the values produced lie in the interval [0.0, 1.0). | ||
69 | .Pp | ||
70 | .Fn lrand48 | ||
71 | and | ||
72 | .Fn nrand48 | ||
73 | return values of type long in the range | ||
74 | [0, 2**31-1]. The high-order (31) bits of | ||
75 | r(n+1) are loaded into the lower bits of the returned value, with | ||
76 | the topmost (sign) bit set to zero. | ||
77 | .Pp | ||
78 | .Fn mrand48 | ||
79 | and | ||
80 | .Fn jrand48 | ||
81 | return values of type long in the range | ||
82 | [-2**31, 2**31-1]. The high-order (32) bits of | ||
83 | r(n+1) are loaded into the returned value. | ||
84 | .Pp | ||
85 | .Fn drand48 , | ||
86 | .Fn lrand48 , | ||
87 | and | ||
88 | .Fn mrand48 | ||
89 | use an internal buffer to store r(n). For these functions | ||
90 | the initial value of r(0) = 0x1234abcd330e = 20017429951246. | ||
91 | .Pp | ||
92 | On the other hand, | ||
93 | .Fn erand48 , | ||
94 | .Fn nrand48 , | ||
95 | and | ||
96 | .Fn jrand48 | ||
97 | use a user-supplied buffer to store the seed r(n), | ||
98 | which consists of an array of 3 shorts, where the zeroth member | ||
99 | holds the least significant bits. | ||
100 | .Pp | ||
101 | All functions share the same multiplicand and addend. | ||
102 | .Pp | ||
103 | .Fn srand48 | ||
104 | is used to initialize the internal buffer r(n) of | ||
105 | .Fn drand48 , | ||
106 | .Fn lrand48 , | ||
107 | and | ||
108 | .Fn mrand48 | ||
109 | such that the 32 bits of the seed value are copied into the upper 32 bits | ||
110 | of r(n), with the lower 16 bits of r(n) arbitrarily being set to 0x330e. | ||
111 | Additionally, the constant multiplicand and addend of the algorithm are | ||
112 | reset to the default values given above. | ||
113 | .Pp | ||
114 | .Fn seed48 | ||
115 | also initializes the internal buffer r(n) of | ||
116 | .Fn drand48 , | ||
117 | .Fn lrand48 , | ||
118 | and | ||
119 | .Fn mrand48 , | ||
120 | but here all 48 bits of the seed can be specified in an array of 3 shorts, | ||
121 | where the zeroth member specifies the lowest bits. Again, | ||
122 | the constant multiplicand and addend of the algorithm are | ||
123 | reset to the default values given above. | ||
124 | .Fn seed48 | ||
125 | returns a pointer to an array of 3 shorts which contains the old seed. | ||
126 | This array is statically allocated, thus its contents are lost after | ||
127 | each new call to | ||
128 | .Fn seed48 . | ||
129 | .Pp | ||
130 | Finally, | ||
131 | .Fn lcong48 | ||
132 | allows full control over the multiplicand and addend used in | ||
133 | .Fn drand48 , | ||
134 | .Fn erand48 , | ||
135 | .Fn lrand48 , | ||
136 | .Fn nrand48 , | ||
137 | .Fn mrand48 , | ||
138 | and | ||
139 | .Fn jrand48 , | ||
140 | and the seed used in | ||
141 | .Fn drand48 , | ||
142 | .Fn lrand48 , | ||
143 | and | ||
144 | .Fn mrand48 . | ||
145 | An array of 7 shorts is passed as parameter; the first three shorts are | ||
146 | used to initialize the seed; the second three are used to initialize the | ||
147 | multiplicand; and the last short is used to initialize the addend. | ||
148 | It is thus not possible to use values greater than 0xffff as the addend. | ||
149 | .Pp | ||
150 | Note that all three methods of seeding the random number generator | ||
151 | always also set the multiplicand and addend for any of the six | ||
152 | generator calls. | ||
153 | .Pp | ||
154 | For a more powerful random number generator, see | ||
155 | .Xr random 3 | ||
156 | .Sh AUTHOR | ||
157 | Martin Birgmeier | ||
158 | .Sh SEE ALSO | ||
159 | .Xr arc4random 3 , | ||
160 | .Xr rand 3 , | ||
161 | .Xr random 3 . | ||
diff --git a/src/lib/libc/stdlib/rand48.h b/src/lib/libc/stdlib/rand48.h new file mode 100644 index 0000000000..e7cb3e0333 --- /dev/null +++ b/src/lib/libc/stdlib/rand48.h | |||
@@ -0,0 +1,32 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | * | ||
13 | * $OpenBSD: rand48.h,v 1.2 1996/08/19 08:33:45 tholo Exp $ | ||
14 | */ | ||
15 | |||
16 | #ifndef _RAND48_H_ | ||
17 | #define _RAND48_H_ | ||
18 | |||
19 | #include <math.h> | ||
20 | #include <stdlib.h> | ||
21 | |||
22 | void __dorand48 __P((unsigned short[3])); | ||
23 | |||
24 | #define RAND48_SEED_0 (0x330e) | ||
25 | #define RAND48_SEED_1 (0xabcd) | ||
26 | #define RAND48_SEED_2 (0x1234) | ||
27 | #define RAND48_MULT_0 (0xe66d) | ||
28 | #define RAND48_MULT_1 (0xdeec) | ||
29 | #define RAND48_MULT_2 (0x0005) | ||
30 | #define RAND48_ADD (0x000b) | ||
31 | |||
32 | #endif /* _RAND48_H_ */ | ||
diff --git a/src/lib/libc/stdlib/random.3 b/src/lib/libc/stdlib/random.3 new file mode 100644 index 0000000000..acfbd8cdeb --- /dev/null +++ b/src/lib/libc/stdlib/random.3 | |||
@@ -0,0 +1,183 @@ | |||
1 | .\" Copyright (c) 1983, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" Redistribution and use in source and binary forms, with or without | ||
5 | .\" modification, are permitted provided that the following conditions | ||
6 | .\" are met: | ||
7 | .\" 1. Redistributions of source code must retain the above copyright | ||
8 | .\" notice, this list of conditions and the following disclaimer. | ||
9 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
10 | .\" notice, this list of conditions and the following disclaimer in the | ||
11 | .\" documentation and/or other materials provided with the distribution. | ||
12 | .\" 3. All advertising materials mentioning features or use of this software | ||
13 | .\" must display the following acknowledgement: | ||
14 | .\" This product includes software developed by the University of | ||
15 | .\" California, Berkeley and its contributors. | ||
16 | .\" 4. Neither the name of the University nor the names of its contributors | ||
17 | .\" may be used to endorse or promote products derived from this software | ||
18 | .\" without specific prior written permission. | ||
19 | .\" | ||
20 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
21 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
22 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
23 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
24 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
25 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
26 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
27 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
28 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
29 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
30 | .\" SUCH DAMAGE. | ||
31 | .\" | ||
32 | .\" $OpenBSD: random.3,v 1.6 1998/07/05 19:54:25 millert Exp $ | ||
33 | .\" | ||
34 | .Dd April 19, 1991 | ||
35 | .Dt RANDOM 3 | ||
36 | .Os BSD 4.2 | ||
37 | .Sh NAME | ||
38 | .Nm random , | ||
39 | .Nm srandom , | ||
40 | .Nm initstate , | ||
41 | .Nm setstate | ||
42 | .Nd better random number generator; routines for changing generators | ||
43 | .Sh SYNOPSIS | ||
44 | .Fd #include <stdlib.h> | ||
45 | .Ft long | ||
46 | .Fn random void | ||
47 | .Ft void | ||
48 | .Fn srandom "unsigned int seed" | ||
49 | .Ft char * | ||
50 | .Fn initstate "unsigned int seed" "char *state" "size_t n" | ||
51 | .Ft char * | ||
52 | .Fn setstate "const char *state" | ||
53 | .Sh DESCRIPTION | ||
54 | The | ||
55 | .Fn random | ||
56 | function | ||
57 | uses a non-linear additive feedback random number generator employing a | ||
58 | default table of size 31 long integers to return successive pseudo-random | ||
59 | numbers in the range from 0 to | ||
60 | .if t 2\u\s731\s10\d\(mi1. | ||
61 | .if n (2**31)\(mi1. | ||
62 | The maximum value returned by | ||
63 | .Fn random | ||
64 | is | ||
65 | .Dv LONG_MAX | ||
66 | (as defined by the header file | ||
67 | .Aq Pa limits.h ) . | ||
68 | The period of this random number generator is very large, approximately | ||
69 | .if t 16\(mu(2\u\s731\s10\d\(mi1). | ||
70 | .if n 16*((2**31)\(mi1). | ||
71 | .Pp | ||
72 | The | ||
73 | .Fn random Ns / Fn srandom | ||
74 | have (almost) the same calling sequence and initialization properties as | ||
75 | .Xr rand 3 Ns / Xr srand 3 . | ||
76 | The difference is that | ||
77 | .Xr rand | ||
78 | produces a much less random sequence \(em in fact, the low dozen bits | ||
79 | generated by rand go through a cyclic pattern. All the bits generated by | ||
80 | .Fn random | ||
81 | are usable. For example, | ||
82 | .Sq Li random()&01 | ||
83 | will produce a random binary | ||
84 | value. | ||
85 | .Pp | ||
86 | Unlike | ||
87 | .Xr srand , | ||
88 | .Fn srandom | ||
89 | does not return the old seed; the reason for this is that the amount of | ||
90 | state information used is much more than a single word. (Two other | ||
91 | routines are provided to deal with restarting/changing random | ||
92 | number generators). Like | ||
93 | .Xr rand 3 , | ||
94 | however, | ||
95 | .Fn random | ||
96 | will by default produce a sequence of numbers that can be duplicated | ||
97 | by calling | ||
98 | .Fn srandom | ||
99 | with | ||
100 | .Ql 1 | ||
101 | as the seed. | ||
102 | .Pp | ||
103 | The | ||
104 | .Fn initstate | ||
105 | routine allows a state array, passed in as an argument, to be initialized | ||
106 | for future use. The size of the state array (in bytes) is used by | ||
107 | .Fn initstate | ||
108 | to decide how sophisticated a random number generator it should use \(em the | ||
109 | more state, the better the random numbers will be. | ||
110 | (Current "optimal" values for the amount of state information are | ||
111 | 8, 32, 64, 128, and 256 bytes; other amounts will be rounded down to | ||
112 | the nearest known amount. Using less than 8 bytes will cause an error.) | ||
113 | The seed for the initialization (which specifies a starting point for | ||
114 | the random number sequence, and provides for restarting at the same | ||
115 | point) is also an argument. | ||
116 | The | ||
117 | .Fn initstate | ||
118 | function | ||
119 | returns a pointer to the previous state information array. | ||
120 | .Pp | ||
121 | Once a state has been initialized, the | ||
122 | .Fn setstate | ||
123 | routine provides for rapid switching between states. | ||
124 | The | ||
125 | .Fn setstate | ||
126 | function | ||
127 | returns a pointer to the previous state array; its | ||
128 | argument state array is used for further random number generation | ||
129 | until the next call to | ||
130 | .Fn initstate | ||
131 | or | ||
132 | .Fn setstate . | ||
133 | .Pp | ||
134 | Once a state array has been initialized, it may be restarted at a | ||
135 | different point either by calling | ||
136 | .Fn initstate | ||
137 | (with the desired seed, the state array, and its size) or by calling | ||
138 | both | ||
139 | .Fn setstate | ||
140 | (with the state array) and | ||
141 | .Fn srandom | ||
142 | (with the desired seed). | ||
143 | The advantage of calling both | ||
144 | .Fn setstate | ||
145 | and | ||
146 | .Fn srandom | ||
147 | is that the size of the state array does not have to be remembered after | ||
148 | it is initialized. | ||
149 | .Pp | ||
150 | With 256 bytes of state information, the period of the random number | ||
151 | generator is greater than | ||
152 | .if t 2\u\s769\s10\d, | ||
153 | .if n 2**69 | ||
154 | which should be sufficient for most purposes. | ||
155 | .Sh AUTHOR | ||
156 | Earl T. Cohen | ||
157 | .Sh DIAGNOSTICS | ||
158 | If | ||
159 | .Fn initstate | ||
160 | is called with less than 8 bytes of state information, or if | ||
161 | .Fn setstate | ||
162 | detects that the state information has been garbled, error | ||
163 | messages are printed on the standard error output. | ||
164 | .Sh SEE ALSO | ||
165 | .Xr arc4random 3 , | ||
166 | .Xr drand48 3 , | ||
167 | .Xr rand 3 | ||
168 | .Sh STANDARDS | ||
169 | The | ||
170 | .Fn random , | ||
171 | .Fn srandom , | ||
172 | .Fn initstate , | ||
173 | and | ||
174 | .Fn setstate | ||
175 | functions conform to | ||
176 | .St -xpg4.2 . | ||
177 | .Sh HISTORY | ||
178 | These | ||
179 | functions appeared in | ||
180 | .Bx 4.2 . | ||
181 | .Sh BUGS | ||
182 | About 2/3 the speed of | ||
183 | .Xr rand 3 . | ||
diff --git a/src/lib/libc/stdlib/random.c b/src/lib/libc/stdlib/random.c new file mode 100644 index 0000000000..79344f30f1 --- /dev/null +++ b/src/lib/libc/stdlib/random.c | |||
@@ -0,0 +1,370 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1983 Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: random.c,v 1.6 1998/02/07 02:16:25 millert Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdio.h> | ||
39 | #include <stdlib.h> | ||
40 | |||
41 | /* | ||
42 | * random.c: | ||
43 | * | ||
44 | * An improved random number generation package. In addition to the standard | ||
45 | * rand()/srand() like interface, this package also has a special state info | ||
46 | * interface. The initstate() routine is called with a seed, an array of | ||
47 | * bytes, and a count of how many bytes are being passed in; this array is | ||
48 | * then initialized to contain information for random number generation with | ||
49 | * that much state information. Good sizes for the amount of state | ||
50 | * information are 32, 64, 128, and 256 bytes. The state can be switched by | ||
51 | * calling the setstate() routine with the same array as was initiallized | ||
52 | * with initstate(). By default, the package runs with 128 bytes of state | ||
53 | * information and generates far better random numbers than a linear | ||
54 | * congruential generator. If the amount of state information is less than | ||
55 | * 32 bytes, a simple linear congruential R.N.G. is used. | ||
56 | * | ||
57 | * Internally, the state information is treated as an array of longs; the | ||
58 | * zeroeth element of the array is the type of R.N.G. being used (small | ||
59 | * integer); the remainder of the array is the state information for the | ||
60 | * R.N.G. Thus, 32 bytes of state information will give 7 longs worth of | ||
61 | * state information, which will allow a degree seven polynomial. (Note: | ||
62 | * the zeroeth word of state information also has some other information | ||
63 | * stored in it -- see setstate() for details). | ||
64 | * | ||
65 | * The random number generation technique is a linear feedback shift register | ||
66 | * approach, employing trinomials (since there are fewer terms to sum up that | ||
67 | * way). In this approach, the least significant bit of all the numbers in | ||
68 | * the state table will act as a linear feedback shift register, and will | ||
69 | * have period 2^deg - 1 (where deg is the degree of the polynomial being | ||
70 | * used, assuming that the polynomial is irreducible and primitive). The | ||
71 | * higher order bits will have longer periods, since their values are also | ||
72 | * influenced by pseudo-random carries out of the lower bits. The total | ||
73 | * period of the generator is approximately deg*(2**deg - 1); thus doubling | ||
74 | * the amount of state information has a vast influence on the period of the | ||
75 | * generator. Note: the deg*(2**deg - 1) is an approximation only good for | ||
76 | * large deg, when the period of the shift register is the dominant factor. | ||
77 | * With deg equal to seven, the period is actually much longer than the | ||
78 | * 7*(2**7 - 1) predicted by this formula. | ||
79 | */ | ||
80 | |||
81 | /* | ||
82 | * For each of the currently supported random number generators, we have a | ||
83 | * break value on the amount of state information (you need at least this | ||
84 | * many bytes of state info to support this random number generator), a degree | ||
85 | * for the polynomial (actually a trinomial) that the R.N.G. is based on, and | ||
86 | * the separation between the two lower order coefficients of the trinomial. | ||
87 | */ | ||
88 | #define TYPE_0 0 /* linear congruential */ | ||
89 | #define BREAK_0 8 | ||
90 | #define DEG_0 0 | ||
91 | #define SEP_0 0 | ||
92 | |||
93 | #define TYPE_1 1 /* x**7 + x**3 + 1 */ | ||
94 | #define BREAK_1 32 | ||
95 | #define DEG_1 7 | ||
96 | #define SEP_1 3 | ||
97 | |||
98 | #define TYPE_2 2 /* x**15 + x + 1 */ | ||
99 | #define BREAK_2 64 | ||
100 | #define DEG_2 15 | ||
101 | #define SEP_2 1 | ||
102 | |||
103 | #define TYPE_3 3 /* x**31 + x**3 + 1 */ | ||
104 | #define BREAK_3 128 | ||
105 | #define DEG_3 31 | ||
106 | #define SEP_3 3 | ||
107 | |||
108 | #define TYPE_4 4 /* x**63 + x + 1 */ | ||
109 | #define BREAK_4 256 | ||
110 | #define DEG_4 63 | ||
111 | #define SEP_4 1 | ||
112 | |||
113 | /* | ||
114 | * Array versions of the above information to make code run faster -- | ||
115 | * relies on fact that TYPE_i == i. | ||
116 | */ | ||
117 | #define MAX_TYPES 5 /* max number of types above */ | ||
118 | |||
119 | static int degrees[MAX_TYPES] = { DEG_0, DEG_1, DEG_2, DEG_3, DEG_4 }; | ||
120 | static int seps [MAX_TYPES] = { SEP_0, SEP_1, SEP_2, SEP_3, SEP_4 }; | ||
121 | |||
122 | /* | ||
123 | * Initially, everything is set up as if from: | ||
124 | * | ||
125 | * initstate(1, &randtbl, 128); | ||
126 | * | ||
127 | * Note that this initialization takes advantage of the fact that srandom() | ||
128 | * advances the front and rear pointers 10*rand_deg times, and hence the | ||
129 | * rear pointer which starts at 0 will also end up at zero; thus the zeroeth | ||
130 | * element of the state information, which contains info about the current | ||
131 | * position of the rear pointer is just | ||
132 | * | ||
133 | * MAX_TYPES * (rptr - state) + TYPE_3 == TYPE_3. | ||
134 | */ | ||
135 | |||
136 | static long randtbl[DEG_3 + 1] = { | ||
137 | TYPE_3, | ||
138 | 0x991539b1, 0x16a5bce3, 0x6774a4cd, 0x3e01511e, 0x4e508aaa, 0x61048c05, | ||
139 | 0xf5500617, 0x846b7115, 0x6a19892c, 0x896a97af, 0xdb48f936, 0x14898454, | ||
140 | 0x37ffd106, 0xb58bff9c, 0x59e17104, 0xcf918a49, 0x09378c83, 0x52c7a471, | ||
141 | 0x8d293ea9, 0x1f4fc301, 0xc3db71be, 0x39b44e1c, 0xf8a44ef9, 0x4c8b80b1, | ||
142 | 0x19edc328, 0x87bf4bdd, 0xc9b240e5, 0xe9ee4b1b, 0x4382aee7, 0x535b6b41, | ||
143 | 0xf3bec5da, | ||
144 | }; | ||
145 | |||
146 | /* | ||
147 | * fptr and rptr are two pointers into the state info, a front and a rear | ||
148 | * pointer. These two pointers are always rand_sep places aparts, as they | ||
149 | * cycle cyclically through the state information. (Yes, this does mean we | ||
150 | * could get away with just one pointer, but the code for random() is more | ||
151 | * efficient this way). The pointers are left positioned as they would be | ||
152 | * from the call | ||
153 | * | ||
154 | * initstate(1, randtbl, 128); | ||
155 | * | ||
156 | * (The position of the rear pointer, rptr, is really 0 (as explained above | ||
157 | * in the initialization of randtbl) because the state table pointer is set | ||
158 | * to point to randtbl[1] (as explained below). | ||
159 | */ | ||
160 | static long *fptr = &randtbl[SEP_3 + 1]; | ||
161 | static long *rptr = &randtbl[1]; | ||
162 | |||
163 | /* | ||
164 | * The following things are the pointer to the state information table, the | ||
165 | * type of the current generator, the degree of the current polynomial being | ||
166 | * used, and the separation between the two pointers. Note that for efficiency | ||
167 | * of random(), we remember the first location of the state information, not | ||
168 | * the zeroeth. Hence it is valid to access state[-1], which is used to | ||
169 | * store the type of the R.N.G. Also, we remember the last location, since | ||
170 | * this is more efficient than indexing every time to find the address of | ||
171 | * the last element to see if the front and rear pointers have wrapped. | ||
172 | */ | ||
173 | static long *state = &randtbl[1]; | ||
174 | static int rand_type = TYPE_3; | ||
175 | static int rand_deg = DEG_3; | ||
176 | static int rand_sep = SEP_3; | ||
177 | static long *end_ptr = &randtbl[DEG_3 + 1]; | ||
178 | |||
179 | /* | ||
180 | * srandom: | ||
181 | * | ||
182 | * Initialize the random number generator based on the given seed. If the | ||
183 | * type is the trivial no-state-information type, just remember the seed. | ||
184 | * Otherwise, initializes state[] based on the given "seed" via a linear | ||
185 | * congruential generator. Then, the pointers are set to known locations | ||
186 | * that are exactly rand_sep places apart. Lastly, it cycles the state | ||
187 | * information a given number of times to get rid of any initial dependencies | ||
188 | * introduced by the L.C.R.N.G. Note that the initialization of randtbl[] | ||
189 | * for default usage relies on values produced by this routine. | ||
190 | */ | ||
191 | void | ||
192 | srandom(x) | ||
193 | u_int x; | ||
194 | { | ||
195 | register long int test; | ||
196 | register int i; | ||
197 | ldiv_t val; | ||
198 | |||
199 | if (rand_type == TYPE_0) | ||
200 | state[0] = x; | ||
201 | else { | ||
202 | state[0] = x; | ||
203 | for (i = 1; i < rand_deg; i++) { | ||
204 | /* | ||
205 | * Implement the following, without overflowing 31 bits: | ||
206 | * | ||
207 | * state[i] = (16807 * state[i - 1]) % 2147483647; | ||
208 | * | ||
209 | * 2^31-1 (prime) = 2147483647 = 127773*16807+2836 | ||
210 | */ | ||
211 | val = ldiv(state[i-1], 127773); | ||
212 | test = 16807 * val.rem - 2836 * val.quot; | ||
213 | state[i] = test + (test < 0 ? 2147483647 : 0); | ||
214 | } | ||
215 | fptr = &state[rand_sep]; | ||
216 | rptr = &state[0]; | ||
217 | for (i = 0; i < 10 * rand_deg; i++) | ||
218 | (void)random(); | ||
219 | } | ||
220 | } | ||
221 | |||
222 | /* | ||
223 | * initstate: | ||
224 | * | ||
225 | * Initialize the state information in the given array of n bytes for future | ||
226 | * random number generation. Based on the number of bytes we are given, and | ||
227 | * the break values for the different R.N.G.'s, we choose the best (largest) | ||
228 | * one we can and set things up for it. srandom() is then called to | ||
229 | * initialize the state information. | ||
230 | * | ||
231 | * Note that on return from srandom(), we set state[-1] to be the type | ||
232 | * multiplexed with the current value of the rear pointer; this is so | ||
233 | * successive calls to initstate() won't lose this information and will be | ||
234 | * able to restart with setstate(). | ||
235 | * | ||
236 | * Note: the first thing we do is save the current state, if any, just like | ||
237 | * setstate() so that it doesn't matter when initstate is called. | ||
238 | * | ||
239 | * Returns a pointer to the old state. | ||
240 | */ | ||
241 | char * | ||
242 | initstate(seed, arg_state, n) | ||
243 | u_int seed; /* seed for R.N.G. */ | ||
244 | char *arg_state; /* pointer to state array */ | ||
245 | size_t n; /* # bytes of state info */ | ||
246 | { | ||
247 | register char *ostate = (char *)(&state[-1]); | ||
248 | |||
249 | if (rand_type == TYPE_0) | ||
250 | state[-1] = rand_type; | ||
251 | else | ||
252 | state[-1] = MAX_TYPES * (rptr - state) + rand_type; | ||
253 | if (n < BREAK_0) | ||
254 | return(NULL); | ||
255 | if (n < BREAK_1) { | ||
256 | rand_type = TYPE_0; | ||
257 | rand_deg = DEG_0; | ||
258 | rand_sep = SEP_0; | ||
259 | } else if (n < BREAK_2) { | ||
260 | rand_type = TYPE_1; | ||
261 | rand_deg = DEG_1; | ||
262 | rand_sep = SEP_1; | ||
263 | } else if (n < BREAK_3) { | ||
264 | rand_type = TYPE_2; | ||
265 | rand_deg = DEG_2; | ||
266 | rand_sep = SEP_2; | ||
267 | } else if (n < BREAK_4) { | ||
268 | rand_type = TYPE_3; | ||
269 | rand_deg = DEG_3; | ||
270 | rand_sep = SEP_3; | ||
271 | } else { | ||
272 | rand_type = TYPE_4; | ||
273 | rand_deg = DEG_4; | ||
274 | rand_sep = SEP_4; | ||
275 | } | ||
276 | state = &(((long *)arg_state)[1]); /* first location */ | ||
277 | end_ptr = &state[rand_deg]; /* must set end_ptr before srandom */ | ||
278 | srandom(seed); | ||
279 | if (rand_type == TYPE_0) | ||
280 | state[-1] = rand_type; | ||
281 | else | ||
282 | state[-1] = MAX_TYPES*(rptr - state) + rand_type; | ||
283 | return(ostate); | ||
284 | } | ||
285 | |||
286 | /* | ||
287 | * setstate: | ||
288 | * | ||
289 | * Restore the state from the given state array. | ||
290 | * | ||
291 | * Note: it is important that we also remember the locations of the pointers | ||
292 | * in the current state information, and restore the locations of the pointers | ||
293 | * from the old state information. This is done by multiplexing the pointer | ||
294 | * location into the zeroeth word of the state information. | ||
295 | * | ||
296 | * Note that due to the order in which things are done, it is OK to call | ||
297 | * setstate() with the same state as the current state. | ||
298 | * | ||
299 | * Returns a pointer to the old state information. | ||
300 | */ | ||
301 | char * | ||
302 | setstate(arg_state) | ||
303 | const char *arg_state; | ||
304 | { | ||
305 | register long *new_state = (long *)arg_state; | ||
306 | register int type = new_state[0] % MAX_TYPES; | ||
307 | register int rear = new_state[0] / MAX_TYPES; | ||
308 | char *ostate = (char *)(&state[-1]); | ||
309 | |||
310 | if (rand_type == TYPE_0) | ||
311 | state[-1] = rand_type; | ||
312 | else | ||
313 | state[-1] = MAX_TYPES * (rptr - state) + rand_type; | ||
314 | switch(type) { | ||
315 | case TYPE_0: | ||
316 | case TYPE_1: | ||
317 | case TYPE_2: | ||
318 | case TYPE_3: | ||
319 | case TYPE_4: | ||
320 | rand_type = type; | ||
321 | rand_deg = degrees[type]; | ||
322 | rand_sep = seps[type]; | ||
323 | break; | ||
324 | default: | ||
325 | return(NULL); | ||
326 | } | ||
327 | state = &new_state[1]; | ||
328 | if (rand_type != TYPE_0) { | ||
329 | rptr = &state[rear]; | ||
330 | fptr = &state[(rear + rand_sep) % rand_deg]; | ||
331 | } | ||
332 | end_ptr = &state[rand_deg]; /* set end_ptr too */ | ||
333 | return(ostate); | ||
334 | } | ||
335 | |||
336 | /* | ||
337 | * random: | ||
338 | * | ||
339 | * If we are using the trivial TYPE_0 R.N.G., just do the old linear | ||
340 | * congruential bit. Otherwise, we do our fancy trinomial stuff, which is | ||
341 | * the same in all the other cases due to all the global variables that have | ||
342 | * been set up. The basic operation is to add the number at the rear pointer | ||
343 | * into the one at the front pointer. Then both pointers are advanced to | ||
344 | * the next location cyclically in the table. The value returned is the sum | ||
345 | * generated, reduced to 31 bits by throwing away the "least random" low bit. | ||
346 | * | ||
347 | * Note: the code takes advantage of the fact that both the front and | ||
348 | * rear pointers can't wrap on the same call by not testing the rear | ||
349 | * pointer if the front one has wrapped. | ||
350 | * | ||
351 | * Returns a 31-bit random number. | ||
352 | */ | ||
353 | long | ||
354 | random() | ||
355 | { | ||
356 | long i; | ||
357 | |||
358 | if (rand_type == TYPE_0) | ||
359 | i = state[0] = (state[0] * 1103515245 + 12345) & 0x7fffffff; | ||
360 | else { | ||
361 | *fptr += *rptr; | ||
362 | i = (*fptr >> 1) & 0x7fffffff; /* chucking least random bit */ | ||
363 | if (++fptr >= end_ptr) { | ||
364 | fptr = state; | ||
365 | ++rptr; | ||
366 | } else if (++rptr >= end_ptr) | ||
367 | rptr = state; | ||
368 | } | ||
369 | return(i); | ||
370 | } | ||
diff --git a/src/lib/libc/stdlib/realpath.3 b/src/lib/libc/stdlib/realpath.3 new file mode 100644 index 0000000000..cc140029e4 --- /dev/null +++ b/src/lib/libc/stdlib/realpath.3 | |||
@@ -0,0 +1,125 @@ | |||
1 | .\" Copyright (c) 1994 | ||
2 | .\" The Regents of the University of California. All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" Jan-Simon Pendry. | ||
6 | .\" | ||
7 | .\" Redistribution and use in source and binary forms, with or without | ||
8 | .\" modification, are permitted provided that the following conditions | ||
9 | .\" are met: | ||
10 | .\" 1. Redistributions of source code must retain the above copyright | ||
11 | .\" notice, this list of conditions and the following disclaimer. | ||
12 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
13 | .\" notice, this list of conditions and the following disclaimer in the | ||
14 | .\" documentation and/or other materials provided with the distribution. | ||
15 | .\" 3. All advertising materials mentioning features or use of this software | ||
16 | .\" must display the following acknowledgement: | ||
17 | .\" This product includes software developed by the University of | ||
18 | .\" California, Berkeley and its contributors. | ||
19 | .\" 4. Neither the name of the University nor the names of its contributors | ||
20 | .\" may be used to endorse or promote products derived from this software | ||
21 | .\" without specific prior written permission. | ||
22 | .\" | ||
23 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
24 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
25 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
26 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
27 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
28 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
29 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
30 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
31 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
32 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
33 | .\" SUCH DAMAGE. | ||
34 | .\" | ||
35 | .\" $OpenBSD: realpath.3,v 1.3 1997/05/30 07:48:30 deraadt Exp $ | ||
36 | .\" | ||
37 | .Dd February, 16, 1994 | ||
38 | .Dt REALPATH 3 | ||
39 | .Os | ||
40 | .Sh NAME | ||
41 | .Nm realpath | ||
42 | .Nd returns the canonicalized absolute pathname | ||
43 | .Sh SYNOPSIS | ||
44 | .Fd #include <sys/param.h> | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft "char *" | ||
47 | .Fn realpath "const char *pathname" "char resolvedname[MAXPATHLEN]" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn realpath | ||
51 | function resolves all symbolic links, extra | ||
52 | .Dq / | ||
53 | characters and references to | ||
54 | .Pa /./ | ||
55 | and | ||
56 | .Pa /../ | ||
57 | in | ||
58 | .Fa pathname , | ||
59 | and copies the resulting absolute pathname into | ||
60 | the memory referenced by | ||
61 | .Fa resolvedname . | ||
62 | The | ||
63 | .Fa resolvedname | ||
64 | argument | ||
65 | .Em must | ||
66 | refer to a buffer capable of storing at least | ||
67 | .Dv MAXPATHLEN | ||
68 | characters. | ||
69 | .Pp | ||
70 | The | ||
71 | .Fn realpath | ||
72 | function will resolve both absolute and relative paths | ||
73 | and return the absolute pathname corresponding to | ||
74 | .Fa pathname . | ||
75 | All but the last component of | ||
76 | .Fa pathname | ||
77 | must exist when | ||
78 | .Fn realpath | ||
79 | is called. | ||
80 | .Sh "RETURN VALUES" | ||
81 | The | ||
82 | .Fn realpath | ||
83 | function returns | ||
84 | .Fa resolved_name | ||
85 | on success. | ||
86 | If an error occurs, | ||
87 | .Fn realpath | ||
88 | returns | ||
89 | .Dv NULL , | ||
90 | and | ||
91 | .Fa resolved_name | ||
92 | contains the pathname which caused the problem. | ||
93 | .Sh ERRORS | ||
94 | The function | ||
95 | .Fn realpath | ||
96 | may fail and set the external variable | ||
97 | .Va errno | ||
98 | for any of the errors specified for the library functions | ||
99 | .Xr chdir 2 , | ||
100 | .Xr close 2 , | ||
101 | .Xr fchdir 2 , | ||
102 | .Xr lstat 2 , | ||
103 | .Xr open 2 , | ||
104 | .Xr readlink 2 | ||
105 | and | ||
106 | .Xr getcwd 3 . | ||
107 | .Sh CAVEATS | ||
108 | This implementation of | ||
109 | .Fn realpath | ||
110 | differs slightly from the Solaris implementation. | ||
111 | The | ||
112 | .Bx 4.4 | ||
113 | version always returns absolute pathnames, | ||
114 | whereas the Solaris implementation will, | ||
115 | under certain circumstances, return a relative | ||
116 | .Fa resolved_path | ||
117 | when given a relative | ||
118 | .Fa pathname . | ||
119 | .Sh "SEE ALSO" | ||
120 | .Xr getcwd 3 | ||
121 | .Sh HISTORY | ||
122 | The | ||
123 | .Fn realpath | ||
124 | function call first appeared in | ||
125 | .Bx 4.4 . | ||
diff --git a/src/lib/libc/stdlib/realpath.c b/src/lib/libc/stdlib/realpath.c new file mode 100644 index 0000000000..0288601464 --- /dev/null +++ b/src/lib/libc/stdlib/realpath.c | |||
@@ -0,0 +1,163 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1994 | ||
3 | * The Regents of the University of California. All rights reserved. | ||
4 | * | ||
5 | * This code is derived from software contributed to Berkeley by | ||
6 | * Jan-Simon Pendry. | ||
7 | * | ||
8 | * Redistribution and use in source and binary forms, with or without | ||
9 | * modification, are permitted provided that the following conditions | ||
10 | * are met: | ||
11 | * 1. Redistributions of source code must retain the above copyright | ||
12 | * notice, this list of conditions and the following disclaimer. | ||
13 | * 2. Redistributions in binary form must reproduce the above copyright | ||
14 | * notice, this list of conditions and the following disclaimer in the | ||
15 | * documentation and/or other materials provided with the distribution. | ||
16 | * 3. All advertising materials mentioning features or use of this software | ||
17 | * must display the following acknowledgement: | ||
18 | * This product includes software developed by the University of | ||
19 | * California, Berkeley and its contributors. | ||
20 | * 4. Neither the name of the University nor the names of its contributors | ||
21 | * may be used to endorse or promote products derived from this software | ||
22 | * without specific prior written permission. | ||
23 | * | ||
24 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | * SUCH DAMAGE. | ||
35 | */ | ||
36 | |||
37 | #if defined(LIBC_SCCS) && !defined(lint) | ||
38 | static char *rcsid = "$OpenBSD: realpath.c,v 1.4 1998/05/18 09:55:19 deraadt Exp $"; | ||
39 | #endif /* LIBC_SCCS and not lint */ | ||
40 | |||
41 | #include <sys/param.h> | ||
42 | #include <sys/stat.h> | ||
43 | |||
44 | #include <errno.h> | ||
45 | #include <fcntl.h> | ||
46 | #include <stdlib.h> | ||
47 | #include <string.h> | ||
48 | #include <unistd.h> | ||
49 | |||
50 | /* | ||
51 | * char *realpath(const char *path, char resolved_path[MAXPATHLEN]); | ||
52 | * | ||
53 | * Find the real name of path, by removing all ".", ".." and symlink | ||
54 | * components. Returns (resolved) on success, or (NULL) on failure, | ||
55 | * in which case the path which caused trouble is left in (resolved). | ||
56 | */ | ||
57 | char * | ||
58 | realpath(path, resolved) | ||
59 | const char *path; | ||
60 | char *resolved; | ||
61 | { | ||
62 | struct stat sb; | ||
63 | int fd, n, rootd, serrno; | ||
64 | char *p, *q, wbuf[MAXPATHLEN]; | ||
65 | int symlinks = 0; | ||
66 | |||
67 | /* Save the starting point. */ | ||
68 | if ((fd = open(".", O_RDONLY)) < 0) { | ||
69 | (void)strcpy(resolved, "."); | ||
70 | return (NULL); | ||
71 | } | ||
72 | |||
73 | /* | ||
74 | * Find the dirname and basename from the path to be resolved. | ||
75 | * Change directory to the dirname component. | ||
76 | * lstat the basename part. | ||
77 | * if it is a symlink, read in the value and loop. | ||
78 | * if it is a directory, then change to that directory. | ||
79 | * get the current directory name and append the basename. | ||
80 | */ | ||
81 | (void)strncpy(resolved, path, MAXPATHLEN - 1); | ||
82 | resolved[MAXPATHLEN - 1] = '\0'; | ||
83 | loop: | ||
84 | q = strrchr(resolved, '/'); | ||
85 | if (q != NULL) { | ||
86 | p = q + 1; | ||
87 | if (q == resolved) | ||
88 | q = "/"; | ||
89 | else { | ||
90 | do { | ||
91 | --q; | ||
92 | } while (q > resolved && *q == '/'); | ||
93 | q[1] = '\0'; | ||
94 | q = resolved; | ||
95 | } | ||
96 | if (chdir(q) < 0) | ||
97 | goto err1; | ||
98 | } else | ||
99 | p = resolved; | ||
100 | |||
101 | /* Deal with the last component. */ | ||
102 | if (lstat(p, &sb) == 0) { | ||
103 | if (S_ISLNK(sb.st_mode)) { | ||
104 | if (++symlinks > MAXSYMLINKS) { | ||
105 | errno = ELOOP; | ||
106 | goto err1; | ||
107 | } | ||
108 | n = readlink(p, resolved, MAXPATHLEN-1); | ||
109 | if (n < 0) | ||
110 | goto err1; | ||
111 | resolved[n] = '\0'; | ||
112 | goto loop; | ||
113 | } | ||
114 | if (S_ISDIR(sb.st_mode)) { | ||
115 | if (chdir(p) < 0) | ||
116 | goto err1; | ||
117 | p = ""; | ||
118 | } | ||
119 | } | ||
120 | |||
121 | /* | ||
122 | * Save the last component name and get the full pathname of | ||
123 | * the current directory. | ||
124 | */ | ||
125 | (void)strcpy(wbuf, p); | ||
126 | if (getcwd(resolved, MAXPATHLEN) == 0) | ||
127 | goto err1; | ||
128 | |||
129 | /* | ||
130 | * Join the two strings together, ensuring that the right thing | ||
131 | * happens if the last component is empty, or the dirname is root. | ||
132 | */ | ||
133 | if (resolved[0] == '/' && resolved[1] == '\0') | ||
134 | rootd = 1; | ||
135 | else | ||
136 | rootd = 0; | ||
137 | |||
138 | if (*wbuf) { | ||
139 | if (strlen(resolved) + strlen(wbuf) + rootd + 1 > MAXPATHLEN) { | ||
140 | errno = ENAMETOOLONG; | ||
141 | goto err1; | ||
142 | } | ||
143 | if (rootd == 0) | ||
144 | (void)strcat(resolved, "/"); | ||
145 | (void)strcat(resolved, wbuf); | ||
146 | } | ||
147 | |||
148 | /* Go back to where we came from. */ | ||
149 | if (fchdir(fd) < 0) { | ||
150 | serrno = errno; | ||
151 | goto err2; | ||
152 | } | ||
153 | |||
154 | /* It's okay if the close fails, what's an fd more or less? */ | ||
155 | (void)close(fd); | ||
156 | return (resolved); | ||
157 | |||
158 | err1: serrno = errno; | ||
159 | (void)fchdir(fd); | ||
160 | err2: (void)close(fd); | ||
161 | errno = serrno; | ||
162 | return (NULL); | ||
163 | } | ||
diff --git a/src/lib/libc/stdlib/seed48.c b/src/lib/libc/stdlib/seed48.c new file mode 100644 index 0000000000..c4dcd0ead8 --- /dev/null +++ b/src/lib/libc/stdlib/seed48.c | |||
@@ -0,0 +1,40 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | */ | ||
13 | |||
14 | #if defined(LIBC_SCCS) && !defined(lint) | ||
15 | static char rcsid[] = "$OpenBSD: seed48.c,v 1.2 1996/08/19 08:33:48 tholo Exp $"; | ||
16 | #endif /* LIBC_SCCS and not lint */ | ||
17 | |||
18 | #include "rand48.h" | ||
19 | |||
20 | extern unsigned short __rand48_seed[3]; | ||
21 | extern unsigned short __rand48_mult[3]; | ||
22 | extern unsigned short __rand48_add; | ||
23 | |||
24 | unsigned short * | ||
25 | seed48(unsigned short xseed[3]) | ||
26 | { | ||
27 | static unsigned short sseed[3]; | ||
28 | |||
29 | sseed[0] = __rand48_seed[0]; | ||
30 | sseed[1] = __rand48_seed[1]; | ||
31 | sseed[2] = __rand48_seed[2]; | ||
32 | __rand48_seed[0] = xseed[0]; | ||
33 | __rand48_seed[1] = xseed[1]; | ||
34 | __rand48_seed[2] = xseed[2]; | ||
35 | __rand48_mult[0] = RAND48_MULT_0; | ||
36 | __rand48_mult[1] = RAND48_MULT_1; | ||
37 | __rand48_mult[2] = RAND48_MULT_2; | ||
38 | __rand48_add = RAND48_ADD; | ||
39 | return sseed; | ||
40 | } | ||
diff --git a/src/lib/libc/stdlib/setenv.c b/src/lib/libc/stdlib/setenv.c new file mode 100644 index 0000000000..b6f261e61c --- /dev/null +++ b/src/lib/libc/stdlib/setenv.c | |||
@@ -0,0 +1,120 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1987 Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: setenv.c,v 1.3 1998/02/02 22:44:53 millert Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <stdlib.h> | ||
39 | #include <string.h> | ||
40 | |||
41 | /* | ||
42 | * setenv -- | ||
43 | * Set the value of the environmental variable "name" to be | ||
44 | * "value". If rewrite is set, replace any current value. | ||
45 | */ | ||
46 | int | ||
47 | setenv(name, value, rewrite) | ||
48 | register const char *name; | ||
49 | register const char *value; | ||
50 | int rewrite; | ||
51 | { | ||
52 | extern char **environ; | ||
53 | static int alloced; /* if allocated space before */ | ||
54 | register char *C; | ||
55 | int l_value, offset; | ||
56 | char *__findenv(); | ||
57 | |||
58 | if (*value == '=') /* no `=' in value */ | ||
59 | ++value; | ||
60 | l_value = strlen(value); | ||
61 | if ((C = __findenv(name, &offset))) { /* find if already exists */ | ||
62 | if (!rewrite) | ||
63 | return (0); | ||
64 | if (strlen(C) >= l_value) { /* old larger; copy over */ | ||
65 | while (*C++ = *value++); | ||
66 | return (0); | ||
67 | } | ||
68 | } else { /* create new slot */ | ||
69 | register int cnt; | ||
70 | register char **P; | ||
71 | |||
72 | for (P = environ, cnt = 0; *P; ++P, ++cnt); | ||
73 | if (alloced) { /* just increase size */ | ||
74 | P = (char **)realloc((void *)environ, | ||
75 | (size_t)(sizeof(char *) * (cnt + 2))); | ||
76 | if (!P) | ||
77 | return (-1); | ||
78 | environ = P; | ||
79 | } | ||
80 | else { /* get new space */ | ||
81 | alloced = 1; /* copy old entries into it */ | ||
82 | P = (char **)malloc((size_t)(sizeof(char *) * | ||
83 | (cnt + 2))); | ||
84 | if (!P) | ||
85 | return (-1); | ||
86 | bcopy(environ, P, cnt * sizeof(char *)); | ||
87 | environ = P; | ||
88 | } | ||
89 | environ[cnt + 1] = NULL; | ||
90 | offset = cnt; | ||
91 | } | ||
92 | for (C = (char *)name; *C && *C != '='; ++C); /* no `=' in name */ | ||
93 | if (!(environ[offset] = /* name + `=' + value */ | ||
94 | malloc((size_t)((int)(C - name) + l_value + 2)))) | ||
95 | return (-1); | ||
96 | for (C = environ[offset]; (*C = *name++) && *C != '='; ++C) | ||
97 | ; | ||
98 | for (*C++ = '='; *C++ = *value++; ) | ||
99 | ; | ||
100 | return (0); | ||
101 | } | ||
102 | |||
103 | /* | ||
104 | * unsetenv(name) -- | ||
105 | * Delete environmental variable "name". | ||
106 | */ | ||
107 | void | ||
108 | unsetenv(name) | ||
109 | const char *name; | ||
110 | { | ||
111 | extern char **environ; | ||
112 | register char **P; | ||
113 | int offset; | ||
114 | char *__findenv(); | ||
115 | |||
116 | while (__findenv(name, &offset)) /* if set multiple times */ | ||
117 | for (P = &environ[offset];; ++P) | ||
118 | if (!(*P = *(P + 1))) | ||
119 | break; | ||
120 | } | ||
diff --git a/src/lib/libc/stdlib/srand48.c b/src/lib/libc/stdlib/srand48.c new file mode 100644 index 0000000000..fcff8a172e --- /dev/null +++ b/src/lib/libc/stdlib/srand48.c | |||
@@ -0,0 +1,34 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1993 Martin Birgmeier | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * You may redistribute unmodified or modified versions of this source | ||
6 | * code provided that the above copyright notice and this and the | ||
7 | * following conditions are retained. | ||
8 | * | ||
9 | * This software is provided ``as is'', and comes with no warranties | ||
10 | * of any kind. I shall in no event be liable for anything that happens | ||
11 | * to anyone/anything when using this software. | ||
12 | */ | ||
13 | |||
14 | #if defined(LIBC_SCCS) && !defined(lint) | ||
15 | static char rcsid[] = "$OpenBSD: srand48.c,v 1.2 1996/08/19 08:33:49 tholo Exp $"; | ||
16 | #endif /* LIBC_SCCS and not lint */ | ||
17 | |||
18 | #include "rand48.h" | ||
19 | |||
20 | extern unsigned short __rand48_seed[3]; | ||
21 | extern unsigned short __rand48_mult[3]; | ||
22 | extern unsigned short __rand48_add; | ||
23 | |||
24 | void | ||
25 | srand48(long seed) | ||
26 | { | ||
27 | __rand48_seed[0] = RAND48_SEED_0; | ||
28 | __rand48_seed[1] = (unsigned short) seed; | ||
29 | __rand48_seed[2] = (unsigned short) (seed >> 16); | ||
30 | __rand48_mult[0] = RAND48_MULT_0; | ||
31 | __rand48_mult[1] = RAND48_MULT_1; | ||
32 | __rand48_mult[2] = RAND48_MULT_2; | ||
33 | __rand48_add = RAND48_ADD; | ||
34 | } | ||
diff --git a/src/lib/libc/stdlib/strtod.3 b/src/lib/libc/stdlib/strtod.3 new file mode 100644 index 0000000000..3476fa41d6 --- /dev/null +++ b/src/lib/libc/stdlib/strtod.3 | |||
@@ -0,0 +1,113 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: strtod.3,v 1.2 1996/08/19 08:33:49 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt STRTOD 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm strtod | ||
43 | .Nd convert | ||
44 | .Tn ASCII | ||
45 | string to double | ||
46 | .Sh SYNOPSIS | ||
47 | .Fd #include <stdlib.h> | ||
48 | .Ft double | ||
49 | .Fn strtod "const char *nptr" "char **endptr" | ||
50 | .Sh DESCRIPTION | ||
51 | The | ||
52 | .Fn strtod | ||
53 | function converts the initial portion of the string | ||
54 | pointed to by | ||
55 | .Fa nptr | ||
56 | to | ||
57 | .Em double | ||
58 | representation. | ||
59 | .Pp | ||
60 | The expected form of the string is an optional plus (``+'') or minus | ||
61 | sign (``-'') followed by a sequence of digits optionally containing | ||
62 | a decimal-point character, optionally followed by an exponent. | ||
63 | An exponent consists of an ``E'' or ``e'', followed by an optional plus | ||
64 | or minus sign, followed by a sequence of digits. | ||
65 | .Pp | ||
66 | Leading white-space characters in the string (as defined by the | ||
67 | .Xr isspace 3 | ||
68 | function) are skipped. | ||
69 | .Sh RETURN VALUES | ||
70 | The | ||
71 | .Fn strtod | ||
72 | function returns the converted value, if any. | ||
73 | .Pp | ||
74 | If | ||
75 | .Fa endptr | ||
76 | is not | ||
77 | .Dv NULL , | ||
78 | a pointer to the character after the last character used | ||
79 | in the conversion is stored in the location referenced by | ||
80 | .Fa endptr . | ||
81 | .Pp | ||
82 | If no conversion is performed, zero is returned and the value of | ||
83 | .Fa nptr | ||
84 | is stored in the location referenced by | ||
85 | .Fa endptr . | ||
86 | .Pp | ||
87 | If the correct value would cause overflow, plus or minus | ||
88 | .Dv HUGE_VAL | ||
89 | is returned (according to the sign of the value), and | ||
90 | .Dv ERANGE | ||
91 | is stored in | ||
92 | .Va errno . | ||
93 | If the correct value would cause underflow, zero is | ||
94 | returned and | ||
95 | .Dv ERANGE | ||
96 | is stored in | ||
97 | .Va errno . | ||
98 | .Sh ERRORS | ||
99 | .Bl -tag -width Er | ||
100 | .It Bq Er ERANGE | ||
101 | Overflow or underflow occurred. | ||
102 | .Sh SEE ALSO | ||
103 | .Xr atof 3 , | ||
104 | .Xr atoi 3 , | ||
105 | .Xr atol 3 , | ||
106 | .Xr strtol 3 , | ||
107 | .Xr strtoul 3 | ||
108 | .Sh STANDARDS | ||
109 | The | ||
110 | .Fn strtod | ||
111 | function | ||
112 | conforms to | ||
113 | .St -ansiC . | ||
diff --git a/src/lib/libc/stdlib/strtod.c b/src/lib/libc/stdlib/strtod.c new file mode 100644 index 0000000000..55d9e91224 --- /dev/null +++ b/src/lib/libc/stdlib/strtod.c | |||
@@ -0,0 +1,2529 @@ | |||
1 | /**************************************************************** | ||
2 | * | ||
3 | * The author of this software is David M. Gay. | ||
4 | * | ||
5 | * Copyright (c) 1991 by AT&T. | ||
6 | * | ||
7 | * Permission to use, copy, modify, and distribute this software for any | ||
8 | * purpose without fee is hereby granted, provided that this entire notice | ||
9 | * is included in all copies of any software which is or includes a copy | ||
10 | * or modification of this software and in all copies of the supporting | ||
11 | * documentation for such software. | ||
12 | * | ||
13 | * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED | ||
14 | * WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR AT&T MAKES ANY | ||
15 | * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY | ||
16 | * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. | ||
17 | * | ||
18 | ***************************************************************/ | ||
19 | |||
20 | /* Please send bug reports to | ||
21 | David M. Gay | ||
22 | AT&T Bell Laboratories, Room 2C-463 | ||
23 | 600 Mountain Avenue | ||
24 | Murray Hill, NJ 07974-2070 | ||
25 | U.S.A. | ||
26 | dmg@research.att.com or research!dmg | ||
27 | */ | ||
28 | |||
29 | /* strtod for IEEE-, VAX-, and IBM-arithmetic machines. | ||
30 | * | ||
31 | * This strtod returns a nearest machine number to the input decimal | ||
32 | * string (or sets errno to ERANGE). With IEEE arithmetic, ties are | ||
33 | * broken by the IEEE round-even rule. Otherwise ties are broken by | ||
34 | * biased rounding (add half and chop). | ||
35 | * | ||
36 | * Inspired loosely by William D. Clinger's paper "How to Read Floating | ||
37 | * Point Numbers Accurately" [Proc. ACM SIGPLAN '90, pp. 92-101]. | ||
38 | * | ||
39 | * Modifications: | ||
40 | * | ||
41 | * 1. We only require IEEE, IBM, or VAX double-precision | ||
42 | * arithmetic (not IEEE double-extended). | ||
43 | * 2. We get by with floating-point arithmetic in a case that | ||
44 | * Clinger missed -- when we're computing d * 10^n | ||
45 | * for a small integer d and the integer n is not too | ||
46 | * much larger than 22 (the maximum integer k for which | ||
47 | * we can represent 10^k exactly), we may be able to | ||
48 | * compute (d*10^k) * 10^(e-k) with just one roundoff. | ||
49 | * 3. Rather than a bit-at-a-time adjustment of the binary | ||
50 | * result in the hard case, we use floating-point | ||
51 | * arithmetic to determine the adjustment to within | ||
52 | * one bit; only in really hard cases do we need to | ||
53 | * compute a second residual. | ||
54 | * 4. Because of 3., we don't need a large table of powers of 10 | ||
55 | * for ten-to-e (just some small tables, e.g. of 10^k | ||
56 | * for 0 <= k <= 22). | ||
57 | */ | ||
58 | |||
59 | /* | ||
60 | * #define IEEE_LITTLE_ENDIAN for IEEE-arithmetic machines where the least | ||
61 | * significant byte has the lowest address. | ||
62 | * #define IEEE_BIG_ENDIAN for IEEE-arithmetic machines where the most | ||
63 | * significant byte has the lowest address. | ||
64 | * #define Long int on machines with 32-bit ints and 64-bit longs. | ||
65 | * #define Sudden_Underflow for IEEE-format machines without gradual | ||
66 | * underflow (i.e., that flush to zero on underflow). | ||
67 | * #define IBM for IBM mainframe-style floating-point arithmetic. | ||
68 | * #define VAX for VAX-style floating-point arithmetic. | ||
69 | * #define Unsigned_Shifts if >> does treats its left operand as unsigned. | ||
70 | * #define No_leftright to omit left-right logic in fast floating-point | ||
71 | * computation of dtoa. | ||
72 | * #define Check_FLT_ROUNDS if FLT_ROUNDS can assume the values 2 or 3. | ||
73 | * #define RND_PRODQUOT to use rnd_prod and rnd_quot (assembly routines | ||
74 | * that use extended-precision instructions to compute rounded | ||
75 | * products and quotients) with IBM. | ||
76 | * #define ROUND_BIASED for IEEE-format with biased rounding. | ||
77 | * #define Inaccurate_Divide for IEEE-format with correctly rounded | ||
78 | * products but inaccurate quotients, e.g., for Intel i860. | ||
79 | * #define Just_16 to store 16 bits per 32-bit Long when doing high-precision | ||
80 | * integer arithmetic. Whether this speeds things up or slows things | ||
81 | * down depends on the machine and the number being converted. | ||
82 | * #define KR_headers for old-style C function headers. | ||
83 | * #define Bad_float_h if your system lacks a float.h or if it does not | ||
84 | * define some or all of DBL_DIG, DBL_MAX_10_EXP, DBL_MAX_EXP, | ||
85 | * FLT_RADIX, FLT_ROUNDS, and DBL_MAX. | ||
86 | * #define MALLOC your_malloc, where your_malloc(n) acts like malloc(n) | ||
87 | * if memory is available and otherwise does something you deem | ||
88 | * appropriate. If MALLOC is undefined, malloc will be invoked | ||
89 | * directly -- and assumed always to succeed. | ||
90 | */ | ||
91 | |||
92 | #if defined(LIBC_SCCS) && !defined(lint) | ||
93 | static char *rcsid = "$OpenBSD: strtod.c,v 1.12 1998/08/28 20:49:24 mickey Exp $"; | ||
94 | #endif /* LIBC_SCCS and not lint */ | ||
95 | |||
96 | #if defined(__m68k__) || defined(__sparc__) || defined(__i386__) || \ | ||
97 | defined(__mips__) || defined(__ns32k__) || defined(__alpha__) || \ | ||
98 | defined(__powerpc__) || defined(__m88k__) || defined(__hppa__) | ||
99 | #include <sys/types.h> | ||
100 | #if BYTE_ORDER == BIG_ENDIAN | ||
101 | #define IEEE_BIG_ENDIAN | ||
102 | #else | ||
103 | #define IEEE_LITTLE_ENDIAN | ||
104 | #endif | ||
105 | #endif | ||
106 | |||
107 | #ifdef __arm32__ | ||
108 | /* | ||
109 | * Although the CPU is little endian the FP has different | ||
110 | * byte and word endianness. The byte order is still little endian | ||
111 | * but the word order is big endian. | ||
112 | */ | ||
113 | #define IEEE_BIG_ENDIAN | ||
114 | #endif | ||
115 | |||
116 | #ifdef vax | ||
117 | #define VAX | ||
118 | #endif | ||
119 | |||
120 | #define Long int32_t | ||
121 | #define ULong u_int32_t | ||
122 | |||
123 | #ifdef DEBUG | ||
124 | #include "stdio.h" | ||
125 | #define Bug(x) {fprintf(stderr, "%s\n", x); exit(1);} | ||
126 | #endif | ||
127 | |||
128 | #ifdef __cplusplus | ||
129 | #include "malloc.h" | ||
130 | #include "memory.h" | ||
131 | #else | ||
132 | #ifndef KR_headers | ||
133 | #include "stdlib.h" | ||
134 | #include "string.h" | ||
135 | #include "locale.h" | ||
136 | #else | ||
137 | #include "malloc.h" | ||
138 | #include "memory.h" | ||
139 | #endif | ||
140 | #endif | ||
141 | |||
142 | #ifdef MALLOC | ||
143 | #ifdef KR_headers | ||
144 | extern char *MALLOC(); | ||
145 | #else | ||
146 | extern void *MALLOC(size_t); | ||
147 | #endif | ||
148 | #else | ||
149 | #define MALLOC malloc | ||
150 | #endif | ||
151 | |||
152 | #include "ctype.h" | ||
153 | #include "errno.h" | ||
154 | |||
155 | #ifdef Bad_float_h | ||
156 | #undef __STDC__ | ||
157 | #ifdef IEEE_BIG_ENDIAN | ||
158 | #define IEEE_ARITHMETIC | ||
159 | #endif | ||
160 | #ifdef IEEE_LITTLE_ENDIAN | ||
161 | #define IEEE_ARITHMETIC | ||
162 | #endif | ||
163 | |||
164 | #ifdef IEEE_ARITHMETIC | ||
165 | #define DBL_DIG 15 | ||
166 | #define DBL_MAX_10_EXP 308 | ||
167 | #define DBL_MAX_EXP 1024 | ||
168 | #define FLT_RADIX 2 | ||
169 | #define FLT_ROUNDS 1 | ||
170 | #define DBL_MAX 1.7976931348623157e+308 | ||
171 | #endif | ||
172 | |||
173 | #ifdef IBM | ||
174 | #define DBL_DIG 16 | ||
175 | #define DBL_MAX_10_EXP 75 | ||
176 | #define DBL_MAX_EXP 63 | ||
177 | #define FLT_RADIX 16 | ||
178 | #define FLT_ROUNDS 0 | ||
179 | #define DBL_MAX 7.2370055773322621e+75 | ||
180 | #endif | ||
181 | |||
182 | #ifdef VAX | ||
183 | #define DBL_DIG 16 | ||
184 | #define DBL_MAX_10_EXP 38 | ||
185 | #define DBL_MAX_EXP 127 | ||
186 | #define FLT_RADIX 2 | ||
187 | #define FLT_ROUNDS 1 | ||
188 | #define DBL_MAX 1.7014118346046923e+38 | ||
189 | #endif | ||
190 | |||
191 | #ifndef LONG_MAX | ||
192 | #define LONG_MAX 2147483647 | ||
193 | #endif | ||
194 | #else | ||
195 | #include "float.h" | ||
196 | #endif | ||
197 | #ifndef __MATH_H__ | ||
198 | #include "math.h" | ||
199 | #endif | ||
200 | |||
201 | #ifdef __cplusplus | ||
202 | extern "C" { | ||
203 | #endif | ||
204 | |||
205 | #ifndef CONST | ||
206 | #ifdef KR_headers | ||
207 | #define CONST /* blank */ | ||
208 | #else | ||
209 | #define CONST const | ||
210 | #endif | ||
211 | #endif | ||
212 | |||
213 | #ifdef Unsigned_Shifts | ||
214 | #define Sign_Extend(a,b) if (b < 0) a |= 0xffff0000; | ||
215 | #else | ||
216 | #define Sign_Extend(a,b) /*no-op*/ | ||
217 | #endif | ||
218 | |||
219 | #if defined(IEEE_LITTLE_ENDIAN) + defined(IEEE_BIG_ENDIAN) + defined(VAX) + \ | ||
220 | defined(IBM) != 1 | ||
221 | Exactly one of IEEE_LITTLE_ENDIAN IEEE_BIG_ENDIAN, VAX, or | ||
222 | IBM should be defined. | ||
223 | #endif | ||
224 | |||
225 | typedef union { | ||
226 | double d; | ||
227 | ULong ul[2]; | ||
228 | } _double; | ||
229 | #define value(x) ((x).d) | ||
230 | #ifdef IEEE_LITTLE_ENDIAN | ||
231 | #define word0(x) ((x).ul[1]) | ||
232 | #define word1(x) ((x).ul[0]) | ||
233 | #else | ||
234 | #define word0(x) ((x).ul[0]) | ||
235 | #define word1(x) ((x).ul[1]) | ||
236 | #endif | ||
237 | |||
238 | /* The following definition of Storeinc is appropriate for MIPS processors. | ||
239 | * An alternative that might be better on some machines is | ||
240 | * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff) | ||
241 | */ | ||
242 | #if defined(IEEE_LITTLE_ENDIAN) + defined(VAX) + defined(__arm32__) | ||
243 | #define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \ | ||
244 | ((unsigned short *)a)[0] = (unsigned short)c, a++) | ||
245 | #else | ||
246 | #define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \ | ||
247 | ((unsigned short *)a)[1] = (unsigned short)c, a++) | ||
248 | #endif | ||
249 | |||
250 | /* #define P DBL_MANT_DIG */ | ||
251 | /* Ten_pmax = floor(P*log(2)/log(5)) */ | ||
252 | /* Bletch = (highest power of 2 < DBL_MAX_10_EXP) / 16 */ | ||
253 | /* Quick_max = floor((P-1)*log(FLT_RADIX)/log(10) - 1) */ | ||
254 | /* Int_max = floor(P*log(FLT_RADIX)/log(10) - 1) */ | ||
255 | |||
256 | #if defined(IEEE_LITTLE_ENDIAN) + defined(IEEE_BIG_ENDIAN) | ||
257 | #define Exp_shift 20 | ||
258 | #define Exp_shift1 20 | ||
259 | #define Exp_msk1 0x100000 | ||
260 | #define Exp_msk11 0x100000 | ||
261 | #define Exp_mask 0x7ff00000 | ||
262 | #define P 53 | ||
263 | #define Bias 1023 | ||
264 | #define IEEE_Arith | ||
265 | #define Emin (-1022) | ||
266 | #define Exp_1 0x3ff00000 | ||
267 | #define Exp_11 0x3ff00000 | ||
268 | #define Ebits 11 | ||
269 | #define Frac_mask 0xfffff | ||
270 | #define Frac_mask1 0xfffff | ||
271 | #define Ten_pmax 22 | ||
272 | #define Bletch 0x10 | ||
273 | #define Bndry_mask 0xfffff | ||
274 | #define Bndry_mask1 0xfffff | ||
275 | #define LSB 1 | ||
276 | #define Sign_bit 0x80000000 | ||
277 | #define Log2P 1 | ||
278 | #define Tiny0 0 | ||
279 | #define Tiny1 1 | ||
280 | #define Quick_max 14 | ||
281 | #define Int_max 14 | ||
282 | #define Infinite(x) (word0(x) == 0x7ff00000) /* sufficient test for here */ | ||
283 | #else | ||
284 | #undef Sudden_Underflow | ||
285 | #define Sudden_Underflow | ||
286 | #ifdef IBM | ||
287 | #define Exp_shift 24 | ||
288 | #define Exp_shift1 24 | ||
289 | #define Exp_msk1 0x1000000 | ||
290 | #define Exp_msk11 0x1000000 | ||
291 | #define Exp_mask 0x7f000000 | ||
292 | #define P 14 | ||
293 | #define Bias 65 | ||
294 | #define Exp_1 0x41000000 | ||
295 | #define Exp_11 0x41000000 | ||
296 | #define Ebits 8 /* exponent has 7 bits, but 8 is the right value in b2d */ | ||
297 | #define Frac_mask 0xffffff | ||
298 | #define Frac_mask1 0xffffff | ||
299 | #define Bletch 4 | ||
300 | #define Ten_pmax 22 | ||
301 | #define Bndry_mask 0xefffff | ||
302 | #define Bndry_mask1 0xffffff | ||
303 | #define LSB 1 | ||
304 | #define Sign_bit 0x80000000 | ||
305 | #define Log2P 4 | ||
306 | #define Tiny0 0x100000 | ||
307 | #define Tiny1 0 | ||
308 | #define Quick_max 14 | ||
309 | #define Int_max 15 | ||
310 | #else /* VAX */ | ||
311 | #define Exp_shift 23 | ||
312 | #define Exp_shift1 7 | ||
313 | #define Exp_msk1 0x80 | ||
314 | #define Exp_msk11 0x800000 | ||
315 | #define Exp_mask 0x7f80 | ||
316 | #define P 56 | ||
317 | #define Bias 129 | ||
318 | #define Exp_1 0x40800000 | ||
319 | #define Exp_11 0x4080 | ||
320 | #define Ebits 8 | ||
321 | #define Frac_mask 0x7fffff | ||
322 | #define Frac_mask1 0xffff007f | ||
323 | #define Ten_pmax 24 | ||
324 | #define Bletch 2 | ||
325 | #define Bndry_mask 0xffff007f | ||
326 | #define Bndry_mask1 0xffff007f | ||
327 | #define LSB 0x10000 | ||
328 | #define Sign_bit 0x8000 | ||
329 | #define Log2P 1 | ||
330 | #define Tiny0 0x80 | ||
331 | #define Tiny1 0 | ||
332 | #define Quick_max 15 | ||
333 | #define Int_max 15 | ||
334 | #endif | ||
335 | #endif | ||
336 | |||
337 | #ifndef IEEE_Arith | ||
338 | #define ROUND_BIASED | ||
339 | #endif | ||
340 | |||
341 | #ifdef RND_PRODQUOT | ||
342 | #define rounded_product(a,b) a = rnd_prod(a, b) | ||
343 | #define rounded_quotient(a,b) a = rnd_quot(a, b) | ||
344 | #ifdef KR_headers | ||
345 | extern double rnd_prod(), rnd_quot(); | ||
346 | #else | ||
347 | extern double rnd_prod(double, double), rnd_quot(double, double); | ||
348 | #endif | ||
349 | #else | ||
350 | #define rounded_product(a,b) a *= b | ||
351 | #define rounded_quotient(a,b) a /= b | ||
352 | #endif | ||
353 | |||
354 | #define Big0 (Frac_mask1 | Exp_msk1*(DBL_MAX_EXP+Bias-1)) | ||
355 | #define Big1 0xffffffff | ||
356 | |||
357 | #ifndef Just_16 | ||
358 | /* When Pack_32 is not defined, we store 16 bits per 32-bit Long. | ||
359 | * This makes some inner loops simpler and sometimes saves work | ||
360 | * during multiplications, but it often seems to make things slightly | ||
361 | * slower. Hence the default is now to store 32 bits per Long. | ||
362 | */ | ||
363 | #ifndef Pack_32 | ||
364 | #define Pack_32 | ||
365 | #endif | ||
366 | #endif | ||
367 | |||
368 | #define Kmax 15 | ||
369 | |||
370 | #ifdef __cplusplus | ||
371 | extern "C" double strtod(const char *s00, char **se); | ||
372 | extern "C" char *__dtoa(double d, int mode, int ndigits, | ||
373 | int *decpt, int *sign, char **rve); | ||
374 | #endif | ||
375 | |||
376 | struct | ||
377 | Bigint { | ||
378 | struct Bigint *next; | ||
379 | int k, maxwds, sign, wds; | ||
380 | ULong x[1]; | ||
381 | }; | ||
382 | |||
383 | typedef struct Bigint Bigint; | ||
384 | |||
385 | static Bigint *freelist[Kmax+1]; | ||
386 | |||
387 | static Bigint * | ||
388 | Balloc | ||
389 | #ifdef KR_headers | ||
390 | (k) int k; | ||
391 | #else | ||
392 | (int k) | ||
393 | #endif | ||
394 | { | ||
395 | int x; | ||
396 | Bigint *rv; | ||
397 | |||
398 | if (rv = freelist[k]) { | ||
399 | freelist[k] = rv->next; | ||
400 | } | ||
401 | else { | ||
402 | x = 1 << k; | ||
403 | rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(Long)); | ||
404 | rv->k = k; | ||
405 | rv->maxwds = x; | ||
406 | } | ||
407 | rv->sign = rv->wds = 0; | ||
408 | return rv; | ||
409 | } | ||
410 | |||
411 | static void | ||
412 | Bfree | ||
413 | #ifdef KR_headers | ||
414 | (v) Bigint *v; | ||
415 | #else | ||
416 | (Bigint *v) | ||
417 | #endif | ||
418 | { | ||
419 | if (v) { | ||
420 | v->next = freelist[v->k]; | ||
421 | freelist[v->k] = v; | ||
422 | } | ||
423 | } | ||
424 | |||
425 | #define Bcopy(x,y) memcpy((char *)&x->sign, (char *)&y->sign, \ | ||
426 | y->wds*sizeof(Long) + 2*sizeof(int)) | ||
427 | |||
428 | static Bigint * | ||
429 | multadd | ||
430 | #ifdef KR_headers | ||
431 | (b, m, a) Bigint *b; int m, a; | ||
432 | #else | ||
433 | (Bigint *b, int m, int a) /* multiply by m and add a */ | ||
434 | #endif | ||
435 | { | ||
436 | int i, wds; | ||
437 | ULong *x, y; | ||
438 | #ifdef Pack_32 | ||
439 | ULong xi, z; | ||
440 | #endif | ||
441 | Bigint *b1; | ||
442 | |||
443 | wds = b->wds; | ||
444 | x = b->x; | ||
445 | i = 0; | ||
446 | do { | ||
447 | #ifdef Pack_32 | ||
448 | xi = *x; | ||
449 | y = (xi & 0xffff) * m + a; | ||
450 | z = (xi >> 16) * m + (y >> 16); | ||
451 | a = (int)(z >> 16); | ||
452 | *x++ = (z << 16) + (y & 0xffff); | ||
453 | #else | ||
454 | y = *x * m + a; | ||
455 | a = (int)(y >> 16); | ||
456 | *x++ = y & 0xffff; | ||
457 | #endif | ||
458 | } | ||
459 | while(++i < wds); | ||
460 | if (a) { | ||
461 | if (wds >= b->maxwds) { | ||
462 | b1 = Balloc(b->k+1); | ||
463 | Bcopy(b1, b); | ||
464 | Bfree(b); | ||
465 | b = b1; | ||
466 | } | ||
467 | b->x[wds++] = a; | ||
468 | b->wds = wds; | ||
469 | } | ||
470 | return b; | ||
471 | } | ||
472 | |||
473 | static Bigint * | ||
474 | s2b | ||
475 | #ifdef KR_headers | ||
476 | (s, nd0, nd, y9) CONST char *s; int nd0, nd; ULong y9; | ||
477 | #else | ||
478 | (CONST char *s, int nd0, int nd, ULong y9) | ||
479 | #endif | ||
480 | { | ||
481 | Bigint *b; | ||
482 | int i, k; | ||
483 | Long x, y; | ||
484 | |||
485 | x = (nd + 8) / 9; | ||
486 | for(k = 0, y = 1; x > y; y <<= 1, k++) ; | ||
487 | #ifdef Pack_32 | ||
488 | b = Balloc(k); | ||
489 | b->x[0] = y9; | ||
490 | b->wds = 1; | ||
491 | #else | ||
492 | b = Balloc(k+1); | ||
493 | b->x[0] = y9 & 0xffff; | ||
494 | b->wds = (b->x[1] = y9 >> 16) ? 2 : 1; | ||
495 | #endif | ||
496 | |||
497 | i = 9; | ||
498 | if (9 < nd0) { | ||
499 | s += 9; | ||
500 | do b = multadd(b, 10, *s++ - '0'); | ||
501 | while(++i < nd0); | ||
502 | s++; | ||
503 | } | ||
504 | else | ||
505 | s += 10; | ||
506 | for(; i < nd; i++) | ||
507 | b = multadd(b, 10, *s++ - '0'); | ||
508 | return b; | ||
509 | } | ||
510 | |||
511 | static int | ||
512 | hi0bits | ||
513 | #ifdef KR_headers | ||
514 | (x) register ULong x; | ||
515 | #else | ||
516 | (register ULong x) | ||
517 | #endif | ||
518 | { | ||
519 | register int k = 0; | ||
520 | |||
521 | if (!(x & 0xffff0000)) { | ||
522 | k = 16; | ||
523 | x <<= 16; | ||
524 | } | ||
525 | if (!(x & 0xff000000)) { | ||
526 | k += 8; | ||
527 | x <<= 8; | ||
528 | } | ||
529 | if (!(x & 0xf0000000)) { | ||
530 | k += 4; | ||
531 | x <<= 4; | ||
532 | } | ||
533 | if (!(x & 0xc0000000)) { | ||
534 | k += 2; | ||
535 | x <<= 2; | ||
536 | } | ||
537 | if (!(x & 0x80000000)) { | ||
538 | k++; | ||
539 | if (!(x & 0x40000000)) | ||
540 | return 32; | ||
541 | } | ||
542 | return k; | ||
543 | } | ||
544 | |||
545 | static int | ||
546 | lo0bits | ||
547 | #ifdef KR_headers | ||
548 | (y) ULong *y; | ||
549 | #else | ||
550 | (ULong *y) | ||
551 | #endif | ||
552 | { | ||
553 | register int k; | ||
554 | register ULong x = *y; | ||
555 | |||
556 | if (x & 7) { | ||
557 | if (x & 1) | ||
558 | return 0; | ||
559 | if (x & 2) { | ||
560 | *y = x >> 1; | ||
561 | return 1; | ||
562 | } | ||
563 | *y = x >> 2; | ||
564 | return 2; | ||
565 | } | ||
566 | k = 0; | ||
567 | if (!(x & 0xffff)) { | ||
568 | k = 16; | ||
569 | x >>= 16; | ||
570 | } | ||
571 | if (!(x & 0xff)) { | ||
572 | k += 8; | ||
573 | x >>= 8; | ||
574 | } | ||
575 | if (!(x & 0xf)) { | ||
576 | k += 4; | ||
577 | x >>= 4; | ||
578 | } | ||
579 | if (!(x & 0x3)) { | ||
580 | k += 2; | ||
581 | x >>= 2; | ||
582 | } | ||
583 | if (!(x & 1)) { | ||
584 | k++; | ||
585 | x >>= 1; | ||
586 | if (!x & 1) | ||
587 | return 32; | ||
588 | } | ||
589 | *y = x; | ||
590 | return k; | ||
591 | } | ||
592 | |||
593 | static Bigint * | ||
594 | i2b | ||
595 | #ifdef KR_headers | ||
596 | (i) int i; | ||
597 | #else | ||
598 | (int i) | ||
599 | #endif | ||
600 | { | ||
601 | Bigint *b; | ||
602 | |||
603 | b = Balloc(1); | ||
604 | b->x[0] = i; | ||
605 | b->wds = 1; | ||
606 | return b; | ||
607 | } | ||
608 | |||
609 | static Bigint * | ||
610 | mult | ||
611 | #ifdef KR_headers | ||
612 | (a, b) Bigint *a, *b; | ||
613 | #else | ||
614 | (Bigint *a, Bigint *b) | ||
615 | #endif | ||
616 | { | ||
617 | Bigint *c; | ||
618 | int k, wa, wb, wc; | ||
619 | ULong carry, y, z; | ||
620 | ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0; | ||
621 | #ifdef Pack_32 | ||
622 | ULong z2; | ||
623 | #endif | ||
624 | |||
625 | if (a->wds < b->wds) { | ||
626 | c = a; | ||
627 | a = b; | ||
628 | b = c; | ||
629 | } | ||
630 | k = a->k; | ||
631 | wa = a->wds; | ||
632 | wb = b->wds; | ||
633 | wc = wa + wb; | ||
634 | if (wc > a->maxwds) | ||
635 | k++; | ||
636 | c = Balloc(k); | ||
637 | for(x = c->x, xa = x + wc; x < xa; x++) | ||
638 | *x = 0; | ||
639 | xa = a->x; | ||
640 | xae = xa + wa; | ||
641 | xb = b->x; | ||
642 | xbe = xb + wb; | ||
643 | xc0 = c->x; | ||
644 | #ifdef Pack_32 | ||
645 | for(; xb < xbe; xb++, xc0++) { | ||
646 | if (y = *xb & 0xffff) { | ||
647 | x = xa; | ||
648 | xc = xc0; | ||
649 | carry = 0; | ||
650 | do { | ||
651 | z = (*x & 0xffff) * y + (*xc & 0xffff) + carry; | ||
652 | carry = z >> 16; | ||
653 | z2 = (*x++ >> 16) * y + (*xc >> 16) + carry; | ||
654 | carry = z2 >> 16; | ||
655 | Storeinc(xc, z2, z); | ||
656 | } | ||
657 | while(x < xae); | ||
658 | *xc = carry; | ||
659 | } | ||
660 | if (y = *xb >> 16) { | ||
661 | x = xa; | ||
662 | xc = xc0; | ||
663 | carry = 0; | ||
664 | z2 = *xc; | ||
665 | do { | ||
666 | z = (*x & 0xffff) * y + (*xc >> 16) + carry; | ||
667 | carry = z >> 16; | ||
668 | Storeinc(xc, z, z2); | ||
669 | z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry; | ||
670 | carry = z2 >> 16; | ||
671 | } | ||
672 | while(x < xae); | ||
673 | *xc = z2; | ||
674 | } | ||
675 | } | ||
676 | #else | ||
677 | for(; xb < xbe; xc0++) { | ||
678 | if (y = *xb++) { | ||
679 | x = xa; | ||
680 | xc = xc0; | ||
681 | carry = 0; | ||
682 | do { | ||
683 | z = *x++ * y + *xc + carry; | ||
684 | carry = z >> 16; | ||
685 | *xc++ = z & 0xffff; | ||
686 | } | ||
687 | while(x < xae); | ||
688 | *xc = carry; | ||
689 | } | ||
690 | } | ||
691 | #endif | ||
692 | for(xc0 = c->x, xc = xc0 + wc; wc > 0 && !*--xc; --wc) ; | ||
693 | c->wds = wc; | ||
694 | return c; | ||
695 | } | ||
696 | |||
697 | static Bigint *p5s; | ||
698 | |||
699 | static Bigint * | ||
700 | pow5mult | ||
701 | #ifdef KR_headers | ||
702 | (b, k) Bigint *b; int k; | ||
703 | #else | ||
704 | (Bigint *b, int k) | ||
705 | #endif | ||
706 | { | ||
707 | Bigint *b1, *p5, *p51; | ||
708 | int i; | ||
709 | static int p05[3] = { 5, 25, 125 }; | ||
710 | |||
711 | if (i = k & 3) | ||
712 | b = multadd(b, p05[i-1], 0); | ||
713 | |||
714 | if (!(k >>= 2)) | ||
715 | return b; | ||
716 | if (!(p5 = p5s)) { | ||
717 | /* first time */ | ||
718 | p5 = p5s = i2b(625); | ||
719 | p5->next = 0; | ||
720 | } | ||
721 | for(;;) { | ||
722 | if (k & 1) { | ||
723 | b1 = mult(b, p5); | ||
724 | Bfree(b); | ||
725 | b = b1; | ||
726 | } | ||
727 | if (!(k >>= 1)) | ||
728 | break; | ||
729 | if (!(p51 = p5->next)) { | ||
730 | p51 = p5->next = mult(p5,p5); | ||
731 | p51->next = 0; | ||
732 | } | ||
733 | p5 = p51; | ||
734 | } | ||
735 | return b; | ||
736 | } | ||
737 | |||
738 | static Bigint * | ||
739 | lshift | ||
740 | #ifdef KR_headers | ||
741 | (b, k) Bigint *b; int k; | ||
742 | #else | ||
743 | (Bigint *b, int k) | ||
744 | #endif | ||
745 | { | ||
746 | int i, k1, n, n1; | ||
747 | Bigint *b1; | ||
748 | ULong *x, *x1, *xe, z; | ||
749 | |||
750 | #ifdef Pack_32 | ||
751 | n = k >> 5; | ||
752 | #else | ||
753 | n = k >> 4; | ||
754 | #endif | ||
755 | k1 = b->k; | ||
756 | n1 = n + b->wds + 1; | ||
757 | for(i = b->maxwds; n1 > i; i <<= 1) | ||
758 | k1++; | ||
759 | b1 = Balloc(k1); | ||
760 | x1 = b1->x; | ||
761 | for(i = 0; i < n; i++) | ||
762 | *x1++ = 0; | ||
763 | x = b->x; | ||
764 | xe = x + b->wds; | ||
765 | #ifdef Pack_32 | ||
766 | if (k &= 0x1f) { | ||
767 | k1 = 32 - k; | ||
768 | z = 0; | ||
769 | do { | ||
770 | *x1++ = *x << k | z; | ||
771 | z = *x++ >> k1; | ||
772 | } | ||
773 | while(x < xe); | ||
774 | if (*x1 = z) | ||
775 | ++n1; | ||
776 | } | ||
777 | #else | ||
778 | if (k &= 0xf) { | ||
779 | k1 = 16 - k; | ||
780 | z = 0; | ||
781 | do { | ||
782 | *x1++ = *x << k & 0xffff | z; | ||
783 | z = *x++ >> k1; | ||
784 | } | ||
785 | while(x < xe); | ||
786 | if (*x1 = z) | ||
787 | ++n1; | ||
788 | } | ||
789 | #endif | ||
790 | else do | ||
791 | *x1++ = *x++; | ||
792 | while(x < xe); | ||
793 | b1->wds = n1 - 1; | ||
794 | Bfree(b); | ||
795 | return b1; | ||
796 | } | ||
797 | |||
798 | static int | ||
799 | cmp | ||
800 | #ifdef KR_headers | ||
801 | (a, b) Bigint *a, *b; | ||
802 | #else | ||
803 | (Bigint *a, Bigint *b) | ||
804 | #endif | ||
805 | { | ||
806 | ULong *xa, *xa0, *xb, *xb0; | ||
807 | int i, j; | ||
808 | |||
809 | i = a->wds; | ||
810 | j = b->wds; | ||
811 | #ifdef DEBUG | ||
812 | if (i > 1 && !a->x[i-1]) | ||
813 | Bug("cmp called with a->x[a->wds-1] == 0"); | ||
814 | if (j > 1 && !b->x[j-1]) | ||
815 | Bug("cmp called with b->x[b->wds-1] == 0"); | ||
816 | #endif | ||
817 | if (i -= j) | ||
818 | return i; | ||
819 | xa0 = a->x; | ||
820 | xa = xa0 + j; | ||
821 | xb0 = b->x; | ||
822 | xb = xb0 + j; | ||
823 | for(;;) { | ||
824 | if (*--xa != *--xb) | ||
825 | return *xa < *xb ? -1 : 1; | ||
826 | if (xa <= xa0) | ||
827 | break; | ||
828 | } | ||
829 | return 0; | ||
830 | } | ||
831 | |||
832 | static Bigint * | ||
833 | diff | ||
834 | #ifdef KR_headers | ||
835 | (a, b) Bigint *a, *b; | ||
836 | #else | ||
837 | (Bigint *a, Bigint *b) | ||
838 | #endif | ||
839 | { | ||
840 | Bigint *c; | ||
841 | int i, wa, wb; | ||
842 | Long borrow, y; /* We need signed shifts here. */ | ||
843 | ULong *xa, *xae, *xb, *xbe, *xc; | ||
844 | #ifdef Pack_32 | ||
845 | Long z; | ||
846 | #endif | ||
847 | |||
848 | i = cmp(a,b); | ||
849 | if (!i) { | ||
850 | c = Balloc(0); | ||
851 | c->wds = 1; | ||
852 | c->x[0] = 0; | ||
853 | return c; | ||
854 | } | ||
855 | if (i < 0) { | ||
856 | c = a; | ||
857 | a = b; | ||
858 | b = c; | ||
859 | i = 1; | ||
860 | } | ||
861 | else | ||
862 | i = 0; | ||
863 | c = Balloc(a->k); | ||
864 | c->sign = i; | ||
865 | wa = a->wds; | ||
866 | xa = a->x; | ||
867 | xae = xa + wa; | ||
868 | wb = b->wds; | ||
869 | xb = b->x; | ||
870 | xbe = xb + wb; | ||
871 | xc = c->x; | ||
872 | borrow = 0; | ||
873 | #ifdef Pack_32 | ||
874 | do { | ||
875 | y = (*xa & 0xffff) - (*xb & 0xffff) + borrow; | ||
876 | borrow = y >> 16; | ||
877 | Sign_Extend(borrow, y); | ||
878 | z = (*xa++ >> 16) - (*xb++ >> 16) + borrow; | ||
879 | borrow = z >> 16; | ||
880 | Sign_Extend(borrow, z); | ||
881 | Storeinc(xc, z, y); | ||
882 | } | ||
883 | while(xb < xbe); | ||
884 | while(xa < xae) { | ||
885 | y = (*xa & 0xffff) + borrow; | ||
886 | borrow = y >> 16; | ||
887 | Sign_Extend(borrow, y); | ||
888 | z = (*xa++ >> 16) + borrow; | ||
889 | borrow = z >> 16; | ||
890 | Sign_Extend(borrow, z); | ||
891 | Storeinc(xc, z, y); | ||
892 | } | ||
893 | #else | ||
894 | do { | ||
895 | y = *xa++ - *xb++ + borrow; | ||
896 | borrow = y >> 16; | ||
897 | Sign_Extend(borrow, y); | ||
898 | *xc++ = y & 0xffff; | ||
899 | } | ||
900 | while(xb < xbe); | ||
901 | while(xa < xae) { | ||
902 | y = *xa++ + borrow; | ||
903 | borrow = y >> 16; | ||
904 | Sign_Extend(borrow, y); | ||
905 | *xc++ = y & 0xffff; | ||
906 | } | ||
907 | #endif | ||
908 | while(!*--xc) | ||
909 | wa--; | ||
910 | c->wds = wa; | ||
911 | return c; | ||
912 | } | ||
913 | |||
914 | static double | ||
915 | ulp | ||
916 | #ifdef KR_headers | ||
917 | (_x) double _x; | ||
918 | #else | ||
919 | (double _x) | ||
920 | #endif | ||
921 | { | ||
922 | _double x; | ||
923 | register Long L; | ||
924 | _double a; | ||
925 | |||
926 | value(x) = _x; | ||
927 | L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1; | ||
928 | #ifndef Sudden_Underflow | ||
929 | if (L > 0) { | ||
930 | #endif | ||
931 | #ifdef IBM | ||
932 | L |= Exp_msk1 >> 4; | ||
933 | #endif | ||
934 | word0(a) = L; | ||
935 | word1(a) = 0; | ||
936 | #ifndef Sudden_Underflow | ||
937 | } | ||
938 | else { | ||
939 | L = -L >> Exp_shift; | ||
940 | if (L < Exp_shift) { | ||
941 | word0(a) = 0x80000 >> L; | ||
942 | word1(a) = 0; | ||
943 | } | ||
944 | else { | ||
945 | word0(a) = 0; | ||
946 | L -= Exp_shift; | ||
947 | word1(a) = L >= 31 ? 1 : 1 << 31 - L; | ||
948 | } | ||
949 | } | ||
950 | #endif | ||
951 | return value(a); | ||
952 | } | ||
953 | |||
954 | static double | ||
955 | b2d | ||
956 | #ifdef KR_headers | ||
957 | (a, e) Bigint *a; int *e; | ||
958 | #else | ||
959 | (Bigint *a, int *e) | ||
960 | #endif | ||
961 | { | ||
962 | ULong *xa, *xa0, w, y, z; | ||
963 | int k; | ||
964 | _double d; | ||
965 | #ifdef VAX | ||
966 | ULong d0, d1; | ||
967 | #else | ||
968 | #define d0 word0(d) | ||
969 | #define d1 word1(d) | ||
970 | #endif | ||
971 | |||
972 | xa0 = a->x; | ||
973 | xa = xa0 + a->wds; | ||
974 | y = *--xa; | ||
975 | #ifdef DEBUG | ||
976 | if (!y) Bug("zero y in b2d"); | ||
977 | #endif | ||
978 | k = hi0bits(y); | ||
979 | *e = 32 - k; | ||
980 | #ifdef Pack_32 | ||
981 | if (k < Ebits) { | ||
982 | d0 = Exp_1 | y >> Ebits - k; | ||
983 | w = xa > xa0 ? *--xa : 0; | ||
984 | d1 = y << (32-Ebits) + k | w >> Ebits - k; | ||
985 | goto ret_d; | ||
986 | } | ||
987 | z = xa > xa0 ? *--xa : 0; | ||
988 | if (k -= Ebits) { | ||
989 | d0 = Exp_1 | y << k | z >> 32 - k; | ||
990 | y = xa > xa0 ? *--xa : 0; | ||
991 | d1 = z << k | y >> 32 - k; | ||
992 | } | ||
993 | else { | ||
994 | d0 = Exp_1 | y; | ||
995 | d1 = z; | ||
996 | } | ||
997 | #else | ||
998 | if (k < Ebits + 16) { | ||
999 | z = xa > xa0 ? *--xa : 0; | ||
1000 | d0 = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k; | ||
1001 | w = xa > xa0 ? *--xa : 0; | ||
1002 | y = xa > xa0 ? *--xa : 0; | ||
1003 | d1 = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k; | ||
1004 | goto ret_d; | ||
1005 | } | ||
1006 | z = xa > xa0 ? *--xa : 0; | ||
1007 | w = xa > xa0 ? *--xa : 0; | ||
1008 | k -= Ebits + 16; | ||
1009 | d0 = Exp_1 | y << k + 16 | z << k | w >> 16 - k; | ||
1010 | y = xa > xa0 ? *--xa : 0; | ||
1011 | d1 = w << k + 16 | y << k; | ||
1012 | #endif | ||
1013 | ret_d: | ||
1014 | #ifdef VAX | ||
1015 | word0(d) = d0 >> 16 | d0 << 16; | ||
1016 | word1(d) = d1 >> 16 | d1 << 16; | ||
1017 | #else | ||
1018 | #undef d0 | ||
1019 | #undef d1 | ||
1020 | #endif | ||
1021 | return value(d); | ||
1022 | } | ||
1023 | |||
1024 | static Bigint * | ||
1025 | d2b | ||
1026 | #ifdef KR_headers | ||
1027 | (_d, e, bits) double d; int *e, *bits; | ||
1028 | #else | ||
1029 | (double _d, int *e, int *bits) | ||
1030 | #endif | ||
1031 | { | ||
1032 | Bigint *b; | ||
1033 | int de, i, k; | ||
1034 | ULong *x, y, z; | ||
1035 | _double d; | ||
1036 | #ifdef VAX | ||
1037 | ULong d0, d1; | ||
1038 | #endif | ||
1039 | |||
1040 | value(d) = _d; | ||
1041 | #ifdef VAX | ||
1042 | d0 = word0(d) >> 16 | word0(d) << 16; | ||
1043 | d1 = word1(d) >> 16 | word1(d) << 16; | ||
1044 | #else | ||
1045 | #define d0 word0(d) | ||
1046 | #define d1 word1(d) | ||
1047 | #endif | ||
1048 | |||
1049 | #ifdef Pack_32 | ||
1050 | b = Balloc(1); | ||
1051 | #else | ||
1052 | b = Balloc(2); | ||
1053 | #endif | ||
1054 | x = b->x; | ||
1055 | |||
1056 | z = d0 & Frac_mask; | ||
1057 | d0 &= 0x7fffffff; /* clear sign bit, which we ignore */ | ||
1058 | #ifdef Sudden_Underflow | ||
1059 | de = (int)(d0 >> Exp_shift); | ||
1060 | #ifndef IBM | ||
1061 | z |= Exp_msk11; | ||
1062 | #endif | ||
1063 | #else | ||
1064 | if (de = (int)(d0 >> Exp_shift)) | ||
1065 | z |= Exp_msk1; | ||
1066 | #endif | ||
1067 | #ifdef Pack_32 | ||
1068 | if (y = d1) { | ||
1069 | if (k = lo0bits(&y)) { | ||
1070 | x[0] = y | z << 32 - k; | ||
1071 | z >>= k; | ||
1072 | } | ||
1073 | else | ||
1074 | x[0] = y; | ||
1075 | i = b->wds = (x[1] = z) ? 2 : 1; | ||
1076 | } | ||
1077 | else { | ||
1078 | #ifdef DEBUG | ||
1079 | if (!z) | ||
1080 | Bug("Zero passed to d2b"); | ||
1081 | #endif | ||
1082 | k = lo0bits(&z); | ||
1083 | x[0] = z; | ||
1084 | i = b->wds = 1; | ||
1085 | k += 32; | ||
1086 | } | ||
1087 | #else | ||
1088 | if (y = d1) { | ||
1089 | if (k = lo0bits(&y)) | ||
1090 | if (k >= 16) { | ||
1091 | x[0] = y | z << 32 - k & 0xffff; | ||
1092 | x[1] = z >> k - 16 & 0xffff; | ||
1093 | x[2] = z >> k; | ||
1094 | i = 2; | ||
1095 | } | ||
1096 | else { | ||
1097 | x[0] = y & 0xffff; | ||
1098 | x[1] = y >> 16 | z << 16 - k & 0xffff; | ||
1099 | x[2] = z >> k & 0xffff; | ||
1100 | x[3] = z >> k+16; | ||
1101 | i = 3; | ||
1102 | } | ||
1103 | else { | ||
1104 | x[0] = y & 0xffff; | ||
1105 | x[1] = y >> 16; | ||
1106 | x[2] = z & 0xffff; | ||
1107 | x[3] = z >> 16; | ||
1108 | i = 3; | ||
1109 | } | ||
1110 | } | ||
1111 | else { | ||
1112 | #ifdef DEBUG | ||
1113 | if (!z) | ||
1114 | Bug("Zero passed to d2b"); | ||
1115 | #endif | ||
1116 | k = lo0bits(&z); | ||
1117 | if (k >= 16) { | ||
1118 | x[0] = z; | ||
1119 | i = 0; | ||
1120 | } | ||
1121 | else { | ||
1122 | x[0] = z & 0xffff; | ||
1123 | x[1] = z >> 16; | ||
1124 | i = 1; | ||
1125 | } | ||
1126 | k += 32; | ||
1127 | } | ||
1128 | while(!x[i]) | ||
1129 | --i; | ||
1130 | b->wds = i + 1; | ||
1131 | #endif | ||
1132 | #ifndef Sudden_Underflow | ||
1133 | if (de) { | ||
1134 | #endif | ||
1135 | #ifdef IBM | ||
1136 | *e = (de - Bias - (P-1) << 2) + k; | ||
1137 | *bits = 4*P + 8 - k - hi0bits(word0(d) & Frac_mask); | ||
1138 | #else | ||
1139 | *e = de - Bias - (P-1) + k; | ||
1140 | *bits = P - k; | ||
1141 | #endif | ||
1142 | #ifndef Sudden_Underflow | ||
1143 | } | ||
1144 | else { | ||
1145 | *e = de - Bias - (P-1) + 1 + k; | ||
1146 | #ifdef Pack_32 | ||
1147 | *bits = 32*i - hi0bits(x[i-1]); | ||
1148 | #else | ||
1149 | *bits = (i+2)*16 - hi0bits(x[i]); | ||
1150 | #endif | ||
1151 | } | ||
1152 | #endif | ||
1153 | return b; | ||
1154 | } | ||
1155 | #undef d0 | ||
1156 | #undef d1 | ||
1157 | |||
1158 | static double | ||
1159 | ratio | ||
1160 | #ifdef KR_headers | ||
1161 | (a, b) Bigint *a, *b; | ||
1162 | #else | ||
1163 | (Bigint *a, Bigint *b) | ||
1164 | #endif | ||
1165 | { | ||
1166 | _double da, db; | ||
1167 | int k, ka, kb; | ||
1168 | |||
1169 | value(da) = b2d(a, &ka); | ||
1170 | value(db) = b2d(b, &kb); | ||
1171 | #ifdef Pack_32 | ||
1172 | k = ka - kb + 32*(a->wds - b->wds); | ||
1173 | #else | ||
1174 | k = ka - kb + 16*(a->wds - b->wds); | ||
1175 | #endif | ||
1176 | #ifdef IBM | ||
1177 | if (k > 0) { | ||
1178 | word0(da) += (k >> 2)*Exp_msk1; | ||
1179 | if (k &= 3) | ||
1180 | da *= 1 << k; | ||
1181 | } | ||
1182 | else { | ||
1183 | k = -k; | ||
1184 | word0(db) += (k >> 2)*Exp_msk1; | ||
1185 | if (k &= 3) | ||
1186 | db *= 1 << k; | ||
1187 | } | ||
1188 | #else | ||
1189 | if (k > 0) | ||
1190 | word0(da) += k*Exp_msk1; | ||
1191 | else { | ||
1192 | k = -k; | ||
1193 | word0(db) += k*Exp_msk1; | ||
1194 | } | ||
1195 | #endif | ||
1196 | return value(da) / value(db); | ||
1197 | } | ||
1198 | |||
1199 | static CONST double | ||
1200 | tens[] = { | ||
1201 | 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, | ||
1202 | 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, | ||
1203 | 1e20, 1e21, 1e22 | ||
1204 | #ifdef VAX | ||
1205 | , 1e23, 1e24 | ||
1206 | #endif | ||
1207 | }; | ||
1208 | |||
1209 | #ifdef IEEE_Arith | ||
1210 | static CONST double bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 }; | ||
1211 | static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64, 1e-128, 1e-256 }; | ||
1212 | #define n_bigtens 5 | ||
1213 | #else | ||
1214 | #ifdef IBM | ||
1215 | static CONST double bigtens[] = { 1e16, 1e32, 1e64 }; | ||
1216 | static CONST double tinytens[] = { 1e-16, 1e-32, 1e-64 }; | ||
1217 | #define n_bigtens 3 | ||
1218 | #else | ||
1219 | static CONST double bigtens[] = { 1e16, 1e32 }; | ||
1220 | static CONST double tinytens[] = { 1e-16, 1e-32 }; | ||
1221 | #define n_bigtens 2 | ||
1222 | #endif | ||
1223 | #endif | ||
1224 | |||
1225 | double | ||
1226 | strtod | ||
1227 | #ifdef KR_headers | ||
1228 | (s00, se) CONST char *s00; char **se; | ||
1229 | #else | ||
1230 | (CONST char *s00, char **se) | ||
1231 | #endif | ||
1232 | { | ||
1233 | int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign, | ||
1234 | e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0, sign; | ||
1235 | CONST char *s, *s0, *s1; | ||
1236 | double aadj, aadj1, adj; | ||
1237 | _double rv, rv0; | ||
1238 | Long L; | ||
1239 | ULong y, z; | ||
1240 | Bigint *bb, *bb1, *bd, *bd0, *bs, *delta; | ||
1241 | |||
1242 | #ifndef KR_headers | ||
1243 | CONST char decimal_point = localeconv()->decimal_point[0]; | ||
1244 | #else | ||
1245 | CONST char decimal_point = '.'; | ||
1246 | #endif | ||
1247 | |||
1248 | sign = nz0 = nz = 0; | ||
1249 | value(rv) = 0.; | ||
1250 | |||
1251 | |||
1252 | for(s = s00; isspace((unsigned char) *s); s++) | ||
1253 | ; | ||
1254 | |||
1255 | if (*s == '-') { | ||
1256 | sign = 1; | ||
1257 | s++; | ||
1258 | } else if (*s == '+') { | ||
1259 | s++; | ||
1260 | } | ||
1261 | |||
1262 | if (*s == '\0') { | ||
1263 | s = s00; | ||
1264 | goto ret; | ||
1265 | } | ||
1266 | |||
1267 | if (*s == '0') { | ||
1268 | nz0 = 1; | ||
1269 | while(*++s == '0') ; | ||
1270 | if (!*s) | ||
1271 | goto ret; | ||
1272 | } | ||
1273 | s0 = s; | ||
1274 | y = z = 0; | ||
1275 | for(nd = nf = 0; (c = *s) >= '0' && c <= '9'; nd++, s++) | ||
1276 | if (nd < 9) | ||
1277 | y = 10*y + c - '0'; | ||
1278 | else if (nd < 16) | ||
1279 | z = 10*z + c - '0'; | ||
1280 | nd0 = nd; | ||
1281 | if (c == decimal_point) { | ||
1282 | c = *++s; | ||
1283 | if (!nd) { | ||
1284 | for(; c == '0'; c = *++s) | ||
1285 | nz++; | ||
1286 | if (c > '0' && c <= '9') { | ||
1287 | s0 = s; | ||
1288 | nf += nz; | ||
1289 | nz = 0; | ||
1290 | goto have_dig; | ||
1291 | } | ||
1292 | goto dig_done; | ||
1293 | } | ||
1294 | for(; c >= '0' && c <= '9'; c = *++s) { | ||
1295 | have_dig: | ||
1296 | nz++; | ||
1297 | if (c -= '0') { | ||
1298 | nf += nz; | ||
1299 | for(i = 1; i < nz; i++) | ||
1300 | if (nd++ < 9) | ||
1301 | y *= 10; | ||
1302 | else if (nd <= DBL_DIG + 1) | ||
1303 | z *= 10; | ||
1304 | if (nd++ < 9) | ||
1305 | y = 10*y + c; | ||
1306 | else if (nd <= DBL_DIG + 1) | ||
1307 | z = 10*z + c; | ||
1308 | nz = 0; | ||
1309 | } | ||
1310 | } | ||
1311 | } | ||
1312 | dig_done: | ||
1313 | e = 0; | ||
1314 | if (c == 'e' || c == 'E') { | ||
1315 | if (!nd && !nz && !nz0) { | ||
1316 | s = s00; | ||
1317 | goto ret; | ||
1318 | } | ||
1319 | s00 = s; | ||
1320 | esign = 0; | ||
1321 | switch(c = *++s) { | ||
1322 | case '-': | ||
1323 | esign = 1; | ||
1324 | case '+': | ||
1325 | c = *++s; | ||
1326 | } | ||
1327 | if (c >= '0' && c <= '9') { | ||
1328 | while(c == '0') | ||
1329 | c = *++s; | ||
1330 | if (c > '0' && c <= '9') { | ||
1331 | L = c - '0'; | ||
1332 | s1 = s; | ||
1333 | while((c = *++s) >= '0' && c <= '9') | ||
1334 | L = 10*L + c - '0'; | ||
1335 | if (s - s1 > 8 || L > 19999) | ||
1336 | /* Avoid confusion from exponents | ||
1337 | * so large that e might overflow. | ||
1338 | */ | ||
1339 | e = 19999; /* safe for 16 bit ints */ | ||
1340 | else | ||
1341 | e = (int)L; | ||
1342 | if (esign) | ||
1343 | e = -e; | ||
1344 | } | ||
1345 | else | ||
1346 | e = 0; | ||
1347 | } | ||
1348 | else | ||
1349 | s = s00; | ||
1350 | } | ||
1351 | if (!nd) { | ||
1352 | if (!nz && !nz0) | ||
1353 | s = s00; | ||
1354 | goto ret; | ||
1355 | } | ||
1356 | e1 = e -= nf; | ||
1357 | |||
1358 | /* Now we have nd0 digits, starting at s0, followed by a | ||
1359 | * decimal point, followed by nd-nd0 digits. The number we're | ||
1360 | * after is the integer represented by those digits times | ||
1361 | * 10**e */ | ||
1362 | |||
1363 | if (!nd0) | ||
1364 | nd0 = nd; | ||
1365 | k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1; | ||
1366 | value(rv) = y; | ||
1367 | if (k > 9) | ||
1368 | value(rv) = tens[k - 9] * value(rv) + z; | ||
1369 | bd0 = 0; | ||
1370 | if (nd <= DBL_DIG | ||
1371 | #ifndef RND_PRODQUOT | ||
1372 | && FLT_ROUNDS == 1 | ||
1373 | #endif | ||
1374 | ) { | ||
1375 | if (!e) | ||
1376 | goto ret; | ||
1377 | if (e > 0) { | ||
1378 | if (e <= Ten_pmax) { | ||
1379 | #ifdef VAX | ||
1380 | goto vax_ovfl_check; | ||
1381 | #else | ||
1382 | /* value(rv) = */ rounded_product(value(rv), | ||
1383 | tens[e]); | ||
1384 | goto ret; | ||
1385 | #endif | ||
1386 | } | ||
1387 | i = DBL_DIG - nd; | ||
1388 | if (e <= Ten_pmax + i) { | ||
1389 | /* A fancier test would sometimes let us do | ||
1390 | * this for larger i values. | ||
1391 | */ | ||
1392 | e -= i; | ||
1393 | value(rv) *= tens[i]; | ||
1394 | #ifdef VAX | ||
1395 | /* VAX exponent range is so narrow we must | ||
1396 | * worry about overflow here... | ||
1397 | */ | ||
1398 | vax_ovfl_check: | ||
1399 | word0(rv) -= P*Exp_msk1; | ||
1400 | /* value(rv) = */ rounded_product(value(rv), | ||
1401 | tens[e]); | ||
1402 | if ((word0(rv) & Exp_mask) | ||
1403 | > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) | ||
1404 | goto ovfl; | ||
1405 | word0(rv) += P*Exp_msk1; | ||
1406 | #else | ||
1407 | /* value(rv) = */ rounded_product(value(rv), | ||
1408 | tens[e]); | ||
1409 | #endif | ||
1410 | goto ret; | ||
1411 | } | ||
1412 | } | ||
1413 | #ifndef Inaccurate_Divide | ||
1414 | else if (e >= -Ten_pmax) { | ||
1415 | /* value(rv) = */ rounded_quotient(value(rv), | ||
1416 | tens[-e]); | ||
1417 | goto ret; | ||
1418 | } | ||
1419 | #endif | ||
1420 | } | ||
1421 | e1 += nd - k; | ||
1422 | |||
1423 | /* Get starting approximation = rv * 10**e1 */ | ||
1424 | |||
1425 | if (e1 > 0) { | ||
1426 | if (i = e1 & 15) | ||
1427 | value(rv) *= tens[i]; | ||
1428 | if (e1 &= ~15) { | ||
1429 | if (e1 > DBL_MAX_10_EXP) { | ||
1430 | ovfl: | ||
1431 | errno = ERANGE; | ||
1432 | #ifdef __STDC__ | ||
1433 | value(rv) = HUGE_VAL; | ||
1434 | #else | ||
1435 | /* Can't trust HUGE_VAL */ | ||
1436 | #ifdef IEEE_Arith | ||
1437 | word0(rv) = Exp_mask; | ||
1438 | word1(rv) = 0; | ||
1439 | #else | ||
1440 | word0(rv) = Big0; | ||
1441 | word1(rv) = Big1; | ||
1442 | #endif | ||
1443 | #endif | ||
1444 | if (bd0) | ||
1445 | goto retfree; | ||
1446 | goto ret; | ||
1447 | } | ||
1448 | if (e1 >>= 4) { | ||
1449 | for(j = 0; e1 > 1; j++, e1 >>= 1) | ||
1450 | if (e1 & 1) | ||
1451 | value(rv) *= bigtens[j]; | ||
1452 | /* The last multiplication could overflow. */ | ||
1453 | word0(rv) -= P*Exp_msk1; | ||
1454 | value(rv) *= bigtens[j]; | ||
1455 | if ((z = word0(rv) & Exp_mask) | ||
1456 | > Exp_msk1*(DBL_MAX_EXP+Bias-P)) | ||
1457 | goto ovfl; | ||
1458 | if (z > Exp_msk1*(DBL_MAX_EXP+Bias-1-P)) { | ||
1459 | /* set to largest number */ | ||
1460 | /* (Can't trust DBL_MAX) */ | ||
1461 | word0(rv) = Big0; | ||
1462 | word1(rv) = Big1; | ||
1463 | } | ||
1464 | else | ||
1465 | word0(rv) += P*Exp_msk1; | ||
1466 | } | ||
1467 | |||
1468 | } | ||
1469 | } | ||
1470 | else if (e1 < 0) { | ||
1471 | e1 = -e1; | ||
1472 | if (i = e1 & 15) | ||
1473 | value(rv) /= tens[i]; | ||
1474 | if (e1 &= ~15) { | ||
1475 | e1 >>= 4; | ||
1476 | if (e1 >= 1 << n_bigtens) | ||
1477 | goto undfl; | ||
1478 | for(j = 0; e1 > 1; j++, e1 >>= 1) | ||
1479 | if (e1 & 1) | ||
1480 | value(rv) *= tinytens[j]; | ||
1481 | /* The last multiplication could underflow. */ | ||
1482 | value(rv0) = value(rv); | ||
1483 | value(rv) *= tinytens[j]; | ||
1484 | if (!value(rv)) { | ||
1485 | value(rv) = 2.*value(rv0); | ||
1486 | value(rv) *= tinytens[j]; | ||
1487 | if (!value(rv)) { | ||
1488 | undfl: | ||
1489 | value(rv) = 0.; | ||
1490 | errno = ERANGE; | ||
1491 | if (bd0) | ||
1492 | goto retfree; | ||
1493 | goto ret; | ||
1494 | } | ||
1495 | word0(rv) = Tiny0; | ||
1496 | word1(rv) = Tiny1; | ||
1497 | /* The refinement below will clean | ||
1498 | * this approximation up. | ||
1499 | */ | ||
1500 | } | ||
1501 | } | ||
1502 | } | ||
1503 | |||
1504 | /* Now the hard part -- adjusting rv to the correct value.*/ | ||
1505 | |||
1506 | /* Put digits into bd: true value = bd * 10^e */ | ||
1507 | |||
1508 | bd0 = s2b(s0, nd0, nd, y); | ||
1509 | |||
1510 | for(;;) { | ||
1511 | bd = Balloc(bd0->k); | ||
1512 | Bcopy(bd, bd0); | ||
1513 | bb = d2b(value(rv), &bbe, &bbbits); /* rv = bb * 2^bbe */ | ||
1514 | bs = i2b(1); | ||
1515 | |||
1516 | if (e >= 0) { | ||
1517 | bb2 = bb5 = 0; | ||
1518 | bd2 = bd5 = e; | ||
1519 | } | ||
1520 | else { | ||
1521 | bb2 = bb5 = -e; | ||
1522 | bd2 = bd5 = 0; | ||
1523 | } | ||
1524 | if (bbe >= 0) | ||
1525 | bb2 += bbe; | ||
1526 | else | ||
1527 | bd2 -= bbe; | ||
1528 | bs2 = bb2; | ||
1529 | #ifdef Sudden_Underflow | ||
1530 | #ifdef IBM | ||
1531 | j = 1 + 4*P - 3 - bbbits + ((bbe + bbbits - 1) & 3); | ||
1532 | #else | ||
1533 | j = P + 1 - bbbits; | ||
1534 | #endif | ||
1535 | #else | ||
1536 | i = bbe + bbbits - 1; /* logb(rv) */ | ||
1537 | if (i < Emin) /* denormal */ | ||
1538 | j = bbe + (P-Emin); | ||
1539 | else | ||
1540 | j = P + 1 - bbbits; | ||
1541 | #endif | ||
1542 | bb2 += j; | ||
1543 | bd2 += j; | ||
1544 | i = bb2 < bd2 ? bb2 : bd2; | ||
1545 | if (i > bs2) | ||
1546 | i = bs2; | ||
1547 | if (i > 0) { | ||
1548 | bb2 -= i; | ||
1549 | bd2 -= i; | ||
1550 | bs2 -= i; | ||
1551 | } | ||
1552 | if (bb5 > 0) { | ||
1553 | bs = pow5mult(bs, bb5); | ||
1554 | bb1 = mult(bs, bb); | ||
1555 | Bfree(bb); | ||
1556 | bb = bb1; | ||
1557 | } | ||
1558 | if (bb2 > 0) | ||
1559 | bb = lshift(bb, bb2); | ||
1560 | if (bd5 > 0) | ||
1561 | bd = pow5mult(bd, bd5); | ||
1562 | if (bd2 > 0) | ||
1563 | bd = lshift(bd, bd2); | ||
1564 | if (bs2 > 0) | ||
1565 | bs = lshift(bs, bs2); | ||
1566 | delta = diff(bb, bd); | ||
1567 | dsign = delta->sign; | ||
1568 | delta->sign = 0; | ||
1569 | i = cmp(delta, bs); | ||
1570 | if (i < 0) { | ||
1571 | /* Error is less than half an ulp -- check for | ||
1572 | * special case of mantissa a power of two. | ||
1573 | */ | ||
1574 | if (dsign || word1(rv) || word0(rv) & Bndry_mask) | ||
1575 | break; | ||
1576 | delta = lshift(delta,Log2P); | ||
1577 | if (cmp(delta, bs) > 0) | ||
1578 | goto drop_down; | ||
1579 | break; | ||
1580 | } | ||
1581 | if (i == 0) { | ||
1582 | /* exactly half-way between */ | ||
1583 | if (dsign) { | ||
1584 | if ((word0(rv) & Bndry_mask1) == Bndry_mask1 | ||
1585 | && word1(rv) == 0xffffffff) { | ||
1586 | /*boundary case -- increment exponent*/ | ||
1587 | word0(rv) = (word0(rv) & Exp_mask) | ||
1588 | + Exp_msk1 | ||
1589 | #ifdef IBM | ||
1590 | | Exp_msk1 >> 4 | ||
1591 | #endif | ||
1592 | ; | ||
1593 | word1(rv) = 0; | ||
1594 | break; | ||
1595 | } | ||
1596 | } | ||
1597 | else if (!(word0(rv) & Bndry_mask) && !word1(rv)) { | ||
1598 | drop_down: | ||
1599 | /* boundary case -- decrement exponent */ | ||
1600 | #ifdef Sudden_Underflow | ||
1601 | L = word0(rv) & Exp_mask; | ||
1602 | #ifdef IBM | ||
1603 | if (L < Exp_msk1) | ||
1604 | #else | ||
1605 | if (L <= Exp_msk1) | ||
1606 | #endif | ||
1607 | goto undfl; | ||
1608 | L -= Exp_msk1; | ||
1609 | #else | ||
1610 | L = (word0(rv) & Exp_mask) - Exp_msk1; | ||
1611 | #endif | ||
1612 | word0(rv) = L | Bndry_mask1; | ||
1613 | word1(rv) = 0xffffffff; | ||
1614 | #ifdef IBM | ||
1615 | goto cont; | ||
1616 | #else | ||
1617 | break; | ||
1618 | #endif | ||
1619 | } | ||
1620 | #ifndef ROUND_BIASED | ||
1621 | if (!(word1(rv) & LSB)) | ||
1622 | break; | ||
1623 | #endif | ||
1624 | if (dsign) | ||
1625 | value(rv) += ulp(value(rv)); | ||
1626 | #ifndef ROUND_BIASED | ||
1627 | else { | ||
1628 | value(rv) -= ulp(value(rv)); | ||
1629 | #ifndef Sudden_Underflow | ||
1630 | if (!value(rv)) | ||
1631 | goto undfl; | ||
1632 | #endif | ||
1633 | } | ||
1634 | #endif | ||
1635 | break; | ||
1636 | } | ||
1637 | if ((aadj = ratio(delta, bs)) <= 2.) { | ||
1638 | if (dsign) | ||
1639 | aadj = aadj1 = 1.; | ||
1640 | else if (word1(rv) || word0(rv) & Bndry_mask) { | ||
1641 | #ifndef Sudden_Underflow | ||
1642 | if (word1(rv) == Tiny1 && !word0(rv)) | ||
1643 | goto undfl; | ||
1644 | #endif | ||
1645 | aadj = 1.; | ||
1646 | aadj1 = -1.; | ||
1647 | } | ||
1648 | else { | ||
1649 | /* special case -- power of FLT_RADIX to be */ | ||
1650 | /* rounded down... */ | ||
1651 | |||
1652 | if (aadj < 2./FLT_RADIX) | ||
1653 | aadj = 1./FLT_RADIX; | ||
1654 | else | ||
1655 | aadj *= 0.5; | ||
1656 | aadj1 = -aadj; | ||
1657 | } | ||
1658 | } | ||
1659 | else { | ||
1660 | aadj *= 0.5; | ||
1661 | aadj1 = dsign ? aadj : -aadj; | ||
1662 | #ifdef Check_FLT_ROUNDS | ||
1663 | switch(FLT_ROUNDS) { | ||
1664 | case 2: /* towards +infinity */ | ||
1665 | aadj1 -= 0.5; | ||
1666 | break; | ||
1667 | case 0: /* towards 0 */ | ||
1668 | case 3: /* towards -infinity */ | ||
1669 | aadj1 += 0.5; | ||
1670 | } | ||
1671 | #else | ||
1672 | if (FLT_ROUNDS == 0) | ||
1673 | aadj1 += 0.5; | ||
1674 | #endif | ||
1675 | } | ||
1676 | y = word0(rv) & Exp_mask; | ||
1677 | |||
1678 | /* Check for overflow */ | ||
1679 | |||
1680 | if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) { | ||
1681 | value(rv0) = value(rv); | ||
1682 | word0(rv) -= P*Exp_msk1; | ||
1683 | adj = aadj1 * ulp(value(rv)); | ||
1684 | value(rv) += adj; | ||
1685 | if ((word0(rv) & Exp_mask) >= | ||
1686 | Exp_msk1*(DBL_MAX_EXP+Bias-P)) { | ||
1687 | if (word0(rv0) == Big0 && word1(rv0) == Big1) | ||
1688 | goto ovfl; | ||
1689 | word0(rv) = Big0; | ||
1690 | word1(rv) = Big1; | ||
1691 | goto cont; | ||
1692 | } | ||
1693 | else | ||
1694 | word0(rv) += P*Exp_msk1; | ||
1695 | } | ||
1696 | else { | ||
1697 | #ifdef Sudden_Underflow | ||
1698 | if ((word0(rv) & Exp_mask) <= P*Exp_msk1) { | ||
1699 | value(rv0) = value(rv); | ||
1700 | word0(rv) += P*Exp_msk1; | ||
1701 | adj = aadj1 * ulp(value(rv)); | ||
1702 | value(rv) += adj; | ||
1703 | #ifdef IBM | ||
1704 | if ((word0(rv) & Exp_mask) < P*Exp_msk1) | ||
1705 | #else | ||
1706 | if ((word0(rv) & Exp_mask) <= P*Exp_msk1) | ||
1707 | #endif | ||
1708 | { | ||
1709 | if (word0(rv0) == Tiny0 | ||
1710 | && word1(rv0) == Tiny1) | ||
1711 | goto undfl; | ||
1712 | word0(rv) = Tiny0; | ||
1713 | word1(rv) = Tiny1; | ||
1714 | goto cont; | ||
1715 | } | ||
1716 | else | ||
1717 | word0(rv) -= P*Exp_msk1; | ||
1718 | } | ||
1719 | else { | ||
1720 | adj = aadj1 * ulp(value(rv)); | ||
1721 | value(rv) += adj; | ||
1722 | } | ||
1723 | #else | ||
1724 | /* Compute adj so that the IEEE rounding rules will | ||
1725 | * correctly round rv + adj in some half-way cases. | ||
1726 | * If rv * ulp(rv) is denormalized (i.e., | ||
1727 | * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid | ||
1728 | * trouble from bits lost to denormalization; | ||
1729 | * example: 1.2e-307 . | ||
1730 | */ | ||
1731 | if (y <= (P-1)*Exp_msk1 && aadj >= 1.) { | ||
1732 | aadj1 = (double)(int)(aadj + 0.5); | ||
1733 | if (!dsign) | ||
1734 | aadj1 = -aadj1; | ||
1735 | } | ||
1736 | adj = aadj1 * ulp(value(rv)); | ||
1737 | value(rv) += adj; | ||
1738 | #endif | ||
1739 | } | ||
1740 | z = word0(rv) & Exp_mask; | ||
1741 | if (y == z) { | ||
1742 | /* Can we stop now? */ | ||
1743 | L = aadj; | ||
1744 | aadj -= L; | ||
1745 | /* The tolerances below are conservative. */ | ||
1746 | if (dsign || word1(rv) || word0(rv) & Bndry_mask) { | ||
1747 | if (aadj < .4999999 || aadj > .5000001) | ||
1748 | break; | ||
1749 | } | ||
1750 | else if (aadj < .4999999/FLT_RADIX) | ||
1751 | break; | ||
1752 | } | ||
1753 | cont: | ||
1754 | Bfree(bb); | ||
1755 | Bfree(bd); | ||
1756 | Bfree(bs); | ||
1757 | Bfree(delta); | ||
1758 | } | ||
1759 | retfree: | ||
1760 | Bfree(bb); | ||
1761 | Bfree(bd); | ||
1762 | Bfree(bs); | ||
1763 | Bfree(bd0); | ||
1764 | Bfree(delta); | ||
1765 | ret: | ||
1766 | if (se) | ||
1767 | *se = (char *)s; | ||
1768 | return sign ? -value(rv) : value(rv); | ||
1769 | } | ||
1770 | |||
1771 | static int | ||
1772 | quorem | ||
1773 | #ifdef KR_headers | ||
1774 | (b, S) Bigint *b, *S; | ||
1775 | #else | ||
1776 | (Bigint *b, Bigint *S) | ||
1777 | #endif | ||
1778 | { | ||
1779 | int n; | ||
1780 | Long borrow, y; | ||
1781 | ULong carry, q, ys; | ||
1782 | ULong *bx, *bxe, *sx, *sxe; | ||
1783 | #ifdef Pack_32 | ||
1784 | Long z; | ||
1785 | ULong si, zs; | ||
1786 | #endif | ||
1787 | |||
1788 | n = S->wds; | ||
1789 | #ifdef DEBUG | ||
1790 | /*debug*/ if (b->wds > n) | ||
1791 | /*debug*/ Bug("oversize b in quorem"); | ||
1792 | #endif | ||
1793 | if (b->wds < n) | ||
1794 | return 0; | ||
1795 | sx = S->x; | ||
1796 | sxe = sx + --n; | ||
1797 | bx = b->x; | ||
1798 | bxe = bx + n; | ||
1799 | q = *bxe / (*sxe + 1); /* ensure q <= true quotient */ | ||
1800 | #ifdef DEBUG | ||
1801 | /*debug*/ if (q > 9) | ||
1802 | /*debug*/ Bug("oversized quotient in quorem"); | ||
1803 | #endif | ||
1804 | if (q) { | ||
1805 | borrow = 0; | ||
1806 | carry = 0; | ||
1807 | do { | ||
1808 | #ifdef Pack_32 | ||
1809 | si = *sx++; | ||
1810 | ys = (si & 0xffff) * q + carry; | ||
1811 | zs = (si >> 16) * q + (ys >> 16); | ||
1812 | carry = zs >> 16; | ||
1813 | y = (*bx & 0xffff) - (ys & 0xffff) + borrow; | ||
1814 | borrow = y >> 16; | ||
1815 | Sign_Extend(borrow, y); | ||
1816 | z = (*bx >> 16) - (zs & 0xffff) + borrow; | ||
1817 | borrow = z >> 16; | ||
1818 | Sign_Extend(borrow, z); | ||
1819 | Storeinc(bx, z, y); | ||
1820 | #else | ||
1821 | ys = *sx++ * q + carry; | ||
1822 | carry = ys >> 16; | ||
1823 | y = *bx - (ys & 0xffff) + borrow; | ||
1824 | borrow = y >> 16; | ||
1825 | Sign_Extend(borrow, y); | ||
1826 | *bx++ = y & 0xffff; | ||
1827 | #endif | ||
1828 | } | ||
1829 | while(sx <= sxe); | ||
1830 | if (!*bxe) { | ||
1831 | bx = b->x; | ||
1832 | while(--bxe > bx && !*bxe) | ||
1833 | --n; | ||
1834 | b->wds = n; | ||
1835 | } | ||
1836 | } | ||
1837 | if (cmp(b, S) >= 0) { | ||
1838 | q++; | ||
1839 | borrow = 0; | ||
1840 | carry = 0; | ||
1841 | bx = b->x; | ||
1842 | sx = S->x; | ||
1843 | do { | ||
1844 | #ifdef Pack_32 | ||
1845 | si = *sx++; | ||
1846 | ys = (si & 0xffff) + carry; | ||
1847 | zs = (si >> 16) + (ys >> 16); | ||
1848 | carry = zs >> 16; | ||
1849 | y = (*bx & 0xffff) - (ys & 0xffff) + borrow; | ||
1850 | borrow = y >> 16; | ||
1851 | Sign_Extend(borrow, y); | ||
1852 | z = (*bx >> 16) - (zs & 0xffff) + borrow; | ||
1853 | borrow = z >> 16; | ||
1854 | Sign_Extend(borrow, z); | ||
1855 | Storeinc(bx, z, y); | ||
1856 | #else | ||
1857 | ys = *sx++ + carry; | ||
1858 | carry = ys >> 16; | ||
1859 | y = *bx - (ys & 0xffff) + borrow; | ||
1860 | borrow = y >> 16; | ||
1861 | Sign_Extend(borrow, y); | ||
1862 | *bx++ = y & 0xffff; | ||
1863 | #endif | ||
1864 | } | ||
1865 | while(sx <= sxe); | ||
1866 | bx = b->x; | ||
1867 | bxe = bx + n; | ||
1868 | if (!*bxe) { | ||
1869 | while(--bxe > bx && !*bxe) | ||
1870 | --n; | ||
1871 | b->wds = n; | ||
1872 | } | ||
1873 | } | ||
1874 | return q; | ||
1875 | } | ||
1876 | |||
1877 | /* dtoa for IEEE arithmetic (dmg): convert double to ASCII string. | ||
1878 | * | ||
1879 | * Inspired by "How to Print Floating-Point Numbers Accurately" by | ||
1880 | * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 92-101]. | ||
1881 | * | ||
1882 | * Modifications: | ||
1883 | * 1. Rather than iterating, we use a simple numeric overestimate | ||
1884 | * to determine k = floor(log10(d)). We scale relevant | ||
1885 | * quantities using O(log2(k)) rather than O(k) multiplications. | ||
1886 | * 2. For some modes > 2 (corresponding to ecvt and fcvt), we don't | ||
1887 | * try to generate digits strictly left to right. Instead, we | ||
1888 | * compute with fewer bits and propagate the carry if necessary | ||
1889 | * when rounding the final digit up. This is often faster. | ||
1890 | * 3. Under the assumption that input will be rounded nearest, | ||
1891 | * mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22. | ||
1892 | * That is, we allow equality in stopping tests when the | ||
1893 | * round-nearest rule will give the same floating-point value | ||
1894 | * as would satisfaction of the stopping test with strict | ||
1895 | * inequality. | ||
1896 | * 4. We remove common factors of powers of 2 from relevant | ||
1897 | * quantities. | ||
1898 | * 5. When converting floating-point integers less than 1e16, | ||
1899 | * we use floating-point arithmetic rather than resorting | ||
1900 | * to multiple-precision integers. | ||
1901 | * 6. When asked to produce fewer than 15 digits, we first try | ||
1902 | * to get by with floating-point arithmetic; we resort to | ||
1903 | * multiple-precision integer arithmetic only if we cannot | ||
1904 | * guarantee that the floating-point calculation has given | ||
1905 | * the correctly rounded result. For k requested digits and | ||
1906 | * "uniformly" distributed input, the probability is | ||
1907 | * something like 10^(k-15) that we must resort to the Long | ||
1908 | * calculation. | ||
1909 | */ | ||
1910 | |||
1911 | char * | ||
1912 | __dtoa | ||
1913 | #ifdef KR_headers | ||
1914 | (_d, mode, ndigits, decpt, sign, rve) | ||
1915 | double _d; int mode, ndigits, *decpt, *sign; char **rve; | ||
1916 | #else | ||
1917 | (double _d, int mode, int ndigits, int *decpt, int *sign, char **rve) | ||
1918 | #endif | ||
1919 | { | ||
1920 | /* Arguments ndigits, decpt, sign are similar to those | ||
1921 | of ecvt and fcvt; trailing zeros are suppressed from | ||
1922 | the returned string. If not null, *rve is set to point | ||
1923 | to the end of the return value. If d is +-Infinity or NaN, | ||
1924 | then *decpt is set to 9999. | ||
1925 | |||
1926 | mode: | ||
1927 | 0 ==> shortest string that yields d when read in | ||
1928 | and rounded to nearest. | ||
1929 | 1 ==> like 0, but with Steele & White stopping rule; | ||
1930 | e.g. with IEEE P754 arithmetic , mode 0 gives | ||
1931 | 1e23 whereas mode 1 gives 9.999999999999999e22. | ||
1932 | 2 ==> max(1,ndigits) significant digits. This gives a | ||
1933 | return value similar to that of ecvt, except | ||
1934 | that trailing zeros are suppressed. | ||
1935 | 3 ==> through ndigits past the decimal point. This | ||
1936 | gives a return value similar to that from fcvt, | ||
1937 | except that trailing zeros are suppressed, and | ||
1938 | ndigits can be negative. | ||
1939 | 4-9 should give the same return values as 2-3, i.e., | ||
1940 | 4 <= mode <= 9 ==> same return as mode | ||
1941 | 2 + (mode & 1). These modes are mainly for | ||
1942 | debugging; often they run slower but sometimes | ||
1943 | faster than modes 2-3. | ||
1944 | 4,5,8,9 ==> left-to-right digit generation. | ||
1945 | 6-9 ==> don't try fast floating-point estimate | ||
1946 | (if applicable). | ||
1947 | |||
1948 | Values of mode other than 0-9 are treated as mode 0. | ||
1949 | |||
1950 | Sufficient space is allocated to the return value | ||
1951 | to hold the suppressed trailing zeros. | ||
1952 | */ | ||
1953 | |||
1954 | int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1, | ||
1955 | j, j1, k, k0, k_check, leftright, m2, m5, s2, s5, | ||
1956 | spec_case, try_quick; | ||
1957 | Long L; | ||
1958 | #ifndef Sudden_Underflow | ||
1959 | int denorm; | ||
1960 | ULong x; | ||
1961 | #endif | ||
1962 | Bigint *b, *b1, *delta, *mlo, *mhi, *S; | ||
1963 | double ds; | ||
1964 | char *s, *s0; | ||
1965 | static Bigint *result; | ||
1966 | static int result_k; | ||
1967 | _double d, d2, eps; | ||
1968 | |||
1969 | value(d) = _d; | ||
1970 | if (result) { | ||
1971 | result->k = result_k; | ||
1972 | result->maxwds = 1 << result_k; | ||
1973 | Bfree(result); | ||
1974 | result = 0; | ||
1975 | } | ||
1976 | |||
1977 | if (word0(d) & Sign_bit) { | ||
1978 | /* set sign for everything, including 0's and NaNs */ | ||
1979 | *sign = 1; | ||
1980 | word0(d) &= ~Sign_bit; /* clear sign bit */ | ||
1981 | } | ||
1982 | else | ||
1983 | *sign = 0; | ||
1984 | |||
1985 | #if defined(IEEE_Arith) + defined(VAX) | ||
1986 | #ifdef IEEE_Arith | ||
1987 | if ((word0(d) & Exp_mask) == Exp_mask) | ||
1988 | #else | ||
1989 | if (word0(d) == 0x8000) | ||
1990 | #endif | ||
1991 | { | ||
1992 | /* Infinity or NaN */ | ||
1993 | *decpt = 9999; | ||
1994 | s = | ||
1995 | #ifdef IEEE_Arith | ||
1996 | !word1(d) && !(word0(d) & 0xfffff) ? "Infinity" : | ||
1997 | #endif | ||
1998 | "NaN"; | ||
1999 | if (rve) | ||
2000 | *rve = | ||
2001 | #ifdef IEEE_Arith | ||
2002 | s[3] ? s + 8 : | ||
2003 | #endif | ||
2004 | s + 3; | ||
2005 | return s; | ||
2006 | } | ||
2007 | #endif | ||
2008 | #ifdef IBM | ||
2009 | value(d) += 0; /* normalize */ | ||
2010 | #endif | ||
2011 | if (!value(d)) { | ||
2012 | *decpt = 1; | ||
2013 | s = "0"; | ||
2014 | if (rve) | ||
2015 | *rve = s + 1; | ||
2016 | return s; | ||
2017 | } | ||
2018 | |||
2019 | b = d2b(value(d), &be, &bbits); | ||
2020 | #ifdef Sudden_Underflow | ||
2021 | i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1)); | ||
2022 | #else | ||
2023 | if (i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1))) { | ||
2024 | #endif | ||
2025 | value(d2) = value(d); | ||
2026 | word0(d2) &= Frac_mask1; | ||
2027 | word0(d2) |= Exp_11; | ||
2028 | #ifdef IBM | ||
2029 | if (j = 11 - hi0bits(word0(d2) & Frac_mask)) | ||
2030 | value(d2) /= 1 << j; | ||
2031 | #endif | ||
2032 | |||
2033 | /* log(x) ~=~ log(1.5) + (x-1.5)/1.5 | ||
2034 | * log10(x) = log(x) / log(10) | ||
2035 | * ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10)) | ||
2036 | * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2) | ||
2037 | * | ||
2038 | * This suggests computing an approximation k to log10(d) by | ||
2039 | * | ||
2040 | * k = (i - Bias)*0.301029995663981 | ||
2041 | * + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 ); | ||
2042 | * | ||
2043 | * We want k to be too large rather than too small. | ||
2044 | * The error in the first-order Taylor series approximation | ||
2045 | * is in our favor, so we just round up the constant enough | ||
2046 | * to compensate for any error in the multiplication of | ||
2047 | * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077, | ||
2048 | * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14, | ||
2049 | * adding 1e-13 to the constant term more than suffices. | ||
2050 | * Hence we adjust the constant term to 0.1760912590558. | ||
2051 | * (We could get a more accurate k by invoking log10, | ||
2052 | * but this is probably not worthwhile.) | ||
2053 | */ | ||
2054 | |||
2055 | i -= Bias; | ||
2056 | #ifdef IBM | ||
2057 | i <<= 2; | ||
2058 | i += j; | ||
2059 | #endif | ||
2060 | #ifndef Sudden_Underflow | ||
2061 | denorm = 0; | ||
2062 | } | ||
2063 | else { | ||
2064 | /* d is denormalized */ | ||
2065 | |||
2066 | i = bbits + be + (Bias + (P-1) - 1); | ||
2067 | x = i > 32 ? word0(d) << 64 - i | word1(d) >> i - 32 | ||
2068 | : word1(d) << 32 - i; | ||
2069 | value(d2) = x; | ||
2070 | word0(d2) -= 31*Exp_msk1; /* adjust exponent */ | ||
2071 | i -= (Bias + (P-1) - 1) + 1; | ||
2072 | denorm = 1; | ||
2073 | } | ||
2074 | #endif | ||
2075 | ds = (value(d2)-1.5)*0.289529654602168 + 0.1760912590558 + | ||
2076 | i*0.301029995663981; | ||
2077 | k = (int)ds; | ||
2078 | if (ds < 0. && ds != k) | ||
2079 | k--; /* want k = floor(ds) */ | ||
2080 | k_check = 1; | ||
2081 | if (k >= 0 && k <= Ten_pmax) { | ||
2082 | if (value(d) < tens[k]) | ||
2083 | k--; | ||
2084 | k_check = 0; | ||
2085 | } | ||
2086 | j = bbits - i - 1; | ||
2087 | if (j >= 0) { | ||
2088 | b2 = 0; | ||
2089 | s2 = j; | ||
2090 | } | ||
2091 | else { | ||
2092 | b2 = -j; | ||
2093 | s2 = 0; | ||
2094 | } | ||
2095 | if (k >= 0) { | ||
2096 | b5 = 0; | ||
2097 | s5 = k; | ||
2098 | s2 += k; | ||
2099 | } | ||
2100 | else { | ||
2101 | b2 -= k; | ||
2102 | b5 = -k; | ||
2103 | s5 = 0; | ||
2104 | } | ||
2105 | if (mode < 0 || mode > 9) | ||
2106 | mode = 0; | ||
2107 | try_quick = 1; | ||
2108 | if (mode > 5) { | ||
2109 | mode -= 4; | ||
2110 | try_quick = 0; | ||
2111 | } | ||
2112 | leftright = 1; | ||
2113 | switch(mode) { | ||
2114 | case 0: | ||
2115 | case 1: | ||
2116 | ilim = ilim1 = -1; | ||
2117 | i = 18; | ||
2118 | ndigits = 0; | ||
2119 | break; | ||
2120 | case 2: | ||
2121 | leftright = 0; | ||
2122 | /* no break */ | ||
2123 | case 4: | ||
2124 | if (ndigits <= 0) | ||
2125 | ndigits = 1; | ||
2126 | ilim = ilim1 = i = ndigits; | ||
2127 | break; | ||
2128 | case 3: | ||
2129 | leftright = 0; | ||
2130 | /* no break */ | ||
2131 | case 5: | ||
2132 | i = ndigits + k + 1; | ||
2133 | ilim = i; | ||
2134 | ilim1 = i - 1; | ||
2135 | if (i <= 0) | ||
2136 | i = 1; | ||
2137 | } | ||
2138 | j = sizeof(ULong); | ||
2139 | for(result_k = 0; sizeof(Bigint) - sizeof(ULong) + j <= i; | ||
2140 | j <<= 1) result_k++; | ||
2141 | result = Balloc(result_k); | ||
2142 | s = s0 = (char *)result; | ||
2143 | |||
2144 | if (ilim >= 0 && ilim <= Quick_max && try_quick) { | ||
2145 | |||
2146 | /* Try to get by with floating-point arithmetic. */ | ||
2147 | |||
2148 | i = 0; | ||
2149 | value(d2) = value(d); | ||
2150 | k0 = k; | ||
2151 | ilim0 = ilim; | ||
2152 | ieps = 2; /* conservative */ | ||
2153 | if (k > 0) { | ||
2154 | ds = tens[k&0xf]; | ||
2155 | j = k >> 4; | ||
2156 | if (j & Bletch) { | ||
2157 | /* prevent overflows */ | ||
2158 | j &= Bletch - 1; | ||
2159 | value(d) /= bigtens[n_bigtens-1]; | ||
2160 | ieps++; | ||
2161 | } | ||
2162 | for(; j; j >>= 1, i++) | ||
2163 | if (j & 1) { | ||
2164 | ieps++; | ||
2165 | ds *= bigtens[i]; | ||
2166 | } | ||
2167 | value(d) /= ds; | ||
2168 | } | ||
2169 | else if (j1 = -k) { | ||
2170 | value(d) *= tens[j1 & 0xf]; | ||
2171 | for(j = j1 >> 4; j; j >>= 1, i++) | ||
2172 | if (j & 1) { | ||
2173 | ieps++; | ||
2174 | value(d) *= bigtens[i]; | ||
2175 | } | ||
2176 | } | ||
2177 | if (k_check && value(d) < 1. && ilim > 0) { | ||
2178 | if (ilim1 <= 0) | ||
2179 | goto fast_failed; | ||
2180 | ilim = ilim1; | ||
2181 | k--; | ||
2182 | value(d) *= 10.; | ||
2183 | ieps++; | ||
2184 | } | ||
2185 | value(eps) = ieps*value(d) + 7.; | ||
2186 | word0(eps) -= (P-1)*Exp_msk1; | ||
2187 | if (ilim == 0) { | ||
2188 | S = mhi = 0; | ||
2189 | value(d) -= 5.; | ||
2190 | if (value(d) > value(eps)) | ||
2191 | goto one_digit; | ||
2192 | if (value(d) < -value(eps)) | ||
2193 | goto no_digits; | ||
2194 | goto fast_failed; | ||
2195 | } | ||
2196 | #ifndef No_leftright | ||
2197 | if (leftright) { | ||
2198 | /* Use Steele & White method of only | ||
2199 | * generating digits needed. | ||
2200 | */ | ||
2201 | value(eps) = 0.5/tens[ilim-1] - value(eps); | ||
2202 | for(i = 0;;) { | ||
2203 | L = value(d); | ||
2204 | value(d) -= L; | ||
2205 | *s++ = '0' + (int)L; | ||
2206 | if (value(d) < value(eps)) | ||
2207 | goto ret1; | ||
2208 | if (1. - value(d) < value(eps)) | ||
2209 | goto bump_up; | ||
2210 | if (++i >= ilim) | ||
2211 | break; | ||
2212 | value(eps) *= 10.; | ||
2213 | value(d) *= 10.; | ||
2214 | } | ||
2215 | } | ||
2216 | else { | ||
2217 | #endif | ||
2218 | /* Generate ilim digits, then fix them up. */ | ||
2219 | value(eps) *= tens[ilim-1]; | ||
2220 | for(i = 1;; i++, value(d) *= 10.) { | ||
2221 | L = value(d); | ||
2222 | value(d) -= L; | ||
2223 | *s++ = '0' + (int)L; | ||
2224 | if (i == ilim) { | ||
2225 | if (value(d) > 0.5 + value(eps)) | ||
2226 | goto bump_up; | ||
2227 | else if (value(d) < 0.5 - value(eps)) { | ||
2228 | while(*--s == '0'); | ||
2229 | s++; | ||
2230 | goto ret1; | ||
2231 | } | ||
2232 | break; | ||
2233 | } | ||
2234 | } | ||
2235 | #ifndef No_leftright | ||
2236 | } | ||
2237 | #endif | ||
2238 | fast_failed: | ||
2239 | s = s0; | ||
2240 | value(d) = value(d2); | ||
2241 | k = k0; | ||
2242 | ilim = ilim0; | ||
2243 | } | ||
2244 | |||
2245 | /* Do we have a "small" integer? */ | ||
2246 | |||
2247 | if (be >= 0 && k <= Int_max) { | ||
2248 | /* Yes. */ | ||
2249 | ds = tens[k]; | ||
2250 | if (ndigits < 0 && ilim <= 0) { | ||
2251 | S = mhi = 0; | ||
2252 | if (ilim < 0 || value(d) <= 5*ds) | ||
2253 | goto no_digits; | ||
2254 | goto one_digit; | ||
2255 | } | ||
2256 | for(i = 1;; i++) { | ||
2257 | L = value(d) / ds; | ||
2258 | value(d) -= L*ds; | ||
2259 | #ifdef Check_FLT_ROUNDS | ||
2260 | /* If FLT_ROUNDS == 2, L will usually be high by 1 */ | ||
2261 | if (value(d) < 0) { | ||
2262 | L--; | ||
2263 | value(d) += ds; | ||
2264 | } | ||
2265 | #endif | ||
2266 | *s++ = '0' + (int)L; | ||
2267 | if (i == ilim) { | ||
2268 | value(d) += value(d); | ||
2269 | if (value(d) > ds || value(d) == ds && L & 1) { | ||
2270 | bump_up: | ||
2271 | while(*--s == '9') | ||
2272 | if (s == s0) { | ||
2273 | k++; | ||
2274 | *s = '0'; | ||
2275 | break; | ||
2276 | } | ||
2277 | ++*s++; | ||
2278 | } | ||
2279 | break; | ||
2280 | } | ||
2281 | if (!(value(d) *= 10.)) | ||
2282 | break; | ||
2283 | } | ||
2284 | goto ret1; | ||
2285 | } | ||
2286 | |||
2287 | m2 = b2; | ||
2288 | m5 = b5; | ||
2289 | mhi = mlo = 0; | ||
2290 | if (leftright) { | ||
2291 | if (mode < 2) { | ||
2292 | i = | ||
2293 | #ifndef Sudden_Underflow | ||
2294 | denorm ? be + (Bias + (P-1) - 1 + 1) : | ||
2295 | #endif | ||
2296 | #ifdef IBM | ||
2297 | 1 + 4*P - 3 - bbits + ((bbits + be - 1) & 3); | ||
2298 | #else | ||
2299 | 1 + P - bbits; | ||
2300 | #endif | ||
2301 | } | ||
2302 | else { | ||
2303 | j = ilim - 1; | ||
2304 | if (m5 >= j) | ||
2305 | m5 -= j; | ||
2306 | else { | ||
2307 | s5 += j -= m5; | ||
2308 | b5 += j; | ||
2309 | m5 = 0; | ||
2310 | } | ||
2311 | if ((i = ilim) < 0) { | ||
2312 | m2 -= i; | ||
2313 | i = 0; | ||
2314 | } | ||
2315 | } | ||
2316 | b2 += i; | ||
2317 | s2 += i; | ||
2318 | mhi = i2b(1); | ||
2319 | } | ||
2320 | if (m2 > 0 && s2 > 0) { | ||
2321 | i = m2 < s2 ? m2 : s2; | ||
2322 | b2 -= i; | ||
2323 | m2 -= i; | ||
2324 | s2 -= i; | ||
2325 | } | ||
2326 | if (b5 > 0) { | ||
2327 | if (leftright) { | ||
2328 | if (m5 > 0) { | ||
2329 | mhi = pow5mult(mhi, m5); | ||
2330 | b1 = mult(mhi, b); | ||
2331 | Bfree(b); | ||
2332 | b = b1; | ||
2333 | } | ||
2334 | if (j = b5 - m5) | ||
2335 | b = pow5mult(b, j); | ||
2336 | } | ||
2337 | else | ||
2338 | b = pow5mult(b, b5); | ||
2339 | } | ||
2340 | S = i2b(1); | ||
2341 | if (s5 > 0) | ||
2342 | S = pow5mult(S, s5); | ||
2343 | |||
2344 | /* Check for special case that d is a normalized power of 2. */ | ||
2345 | |||
2346 | if (mode < 2) { | ||
2347 | if (!word1(d) && !(word0(d) & Bndry_mask) | ||
2348 | #ifndef Sudden_Underflow | ||
2349 | && word0(d) & Exp_mask | ||
2350 | #endif | ||
2351 | ) { | ||
2352 | /* The special case */ | ||
2353 | b2 += Log2P; | ||
2354 | s2 += Log2P; | ||
2355 | spec_case = 1; | ||
2356 | } | ||
2357 | else | ||
2358 | spec_case = 0; | ||
2359 | } | ||
2360 | |||
2361 | /* Arrange for convenient computation of quotients: | ||
2362 | * shift left if necessary so divisor has 4 leading 0 bits. | ||
2363 | * | ||
2364 | * Perhaps we should just compute leading 28 bits of S once | ||
2365 | * and for all and pass them and a shift to quorem, so it | ||
2366 | * can do shifts and ors to compute the numerator for q. | ||
2367 | */ | ||
2368 | #ifdef Pack_32 | ||
2369 | if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0x1f) | ||
2370 | i = 32 - i; | ||
2371 | #else | ||
2372 | if (i = ((s5 ? 32 - hi0bits(S->x[S->wds-1]) : 1) + s2) & 0xf) | ||
2373 | i = 16 - i; | ||
2374 | #endif | ||
2375 | if (i > 4) { | ||
2376 | i -= 4; | ||
2377 | b2 += i; | ||
2378 | m2 += i; | ||
2379 | s2 += i; | ||
2380 | } | ||
2381 | else if (i < 4) { | ||
2382 | i += 28; | ||
2383 | b2 += i; | ||
2384 | m2 += i; | ||
2385 | s2 += i; | ||
2386 | } | ||
2387 | if (b2 > 0) | ||
2388 | b = lshift(b, b2); | ||
2389 | if (s2 > 0) | ||
2390 | S = lshift(S, s2); | ||
2391 | if (k_check) { | ||
2392 | if (cmp(b,S) < 0) { | ||
2393 | k--; | ||
2394 | b = multadd(b, 10, 0); /* we botched the k estimate */ | ||
2395 | if (leftright) | ||
2396 | mhi = multadd(mhi, 10, 0); | ||
2397 | ilim = ilim1; | ||
2398 | } | ||
2399 | } | ||
2400 | if (ilim <= 0 && mode > 2) { | ||
2401 | if (ilim < 0 || cmp(b,S = multadd(S,5,0)) <= 0) { | ||
2402 | /* no digits, fcvt style */ | ||
2403 | no_digits: | ||
2404 | k = -1 - ndigits; | ||
2405 | goto ret; | ||
2406 | } | ||
2407 | one_digit: | ||
2408 | *s++ = '1'; | ||
2409 | k++; | ||
2410 | goto ret; | ||
2411 | } | ||
2412 | if (leftright) { | ||
2413 | if (m2 > 0) | ||
2414 | mhi = lshift(mhi, m2); | ||
2415 | |||
2416 | /* Compute mlo -- check for special case | ||
2417 | * that d is a normalized power of 2. | ||
2418 | */ | ||
2419 | |||
2420 | mlo = mhi; | ||
2421 | if (spec_case) { | ||
2422 | mhi = Balloc(mhi->k); | ||
2423 | Bcopy(mhi, mlo); | ||
2424 | mhi = lshift(mhi, Log2P); | ||
2425 | } | ||
2426 | |||
2427 | for(i = 1;;i++) { | ||
2428 | dig = quorem(b,S) + '0'; | ||
2429 | /* Do we yet have the shortest decimal string | ||
2430 | * that will round to d? | ||
2431 | */ | ||
2432 | j = cmp(b, mlo); | ||
2433 | delta = diff(S, mhi); | ||
2434 | j1 = delta->sign ? 1 : cmp(b, delta); | ||
2435 | Bfree(delta); | ||
2436 | #ifndef ROUND_BIASED | ||
2437 | if (j1 == 0 && !mode && !(word1(d) & 1)) { | ||
2438 | if (dig == '9') | ||
2439 | goto round_9_up; | ||
2440 | if (j > 0) | ||
2441 | dig++; | ||
2442 | *s++ = dig; | ||
2443 | goto ret; | ||
2444 | } | ||
2445 | #endif | ||
2446 | if (j < 0 || j == 0 && !mode | ||
2447 | #ifndef ROUND_BIASED | ||
2448 | && !(word1(d) & 1) | ||
2449 | #endif | ||
2450 | ) { | ||
2451 | if (j1 > 0) { | ||
2452 | b = lshift(b, 1); | ||
2453 | j1 = cmp(b, S); | ||
2454 | if ((j1 > 0 || j1 == 0 && dig & 1) | ||
2455 | && dig++ == '9') | ||
2456 | goto round_9_up; | ||
2457 | } | ||
2458 | *s++ = dig; | ||
2459 | goto ret; | ||
2460 | } | ||
2461 | if (j1 > 0) { | ||
2462 | if (dig == '9') { /* possible if i == 1 */ | ||
2463 | round_9_up: | ||
2464 | *s++ = '9'; | ||
2465 | goto roundoff; | ||
2466 | } | ||
2467 | *s++ = dig + 1; | ||
2468 | goto ret; | ||
2469 | } | ||
2470 | *s++ = dig; | ||
2471 | if (i == ilim) | ||
2472 | break; | ||
2473 | b = multadd(b, 10, 0); | ||
2474 | if (mlo == mhi) | ||
2475 | mlo = mhi = multadd(mhi, 10, 0); | ||
2476 | else { | ||
2477 | mlo = multadd(mlo, 10, 0); | ||
2478 | mhi = multadd(mhi, 10, 0); | ||
2479 | } | ||
2480 | } | ||
2481 | } | ||
2482 | else | ||
2483 | for(i = 1;; i++) { | ||
2484 | *s++ = dig = quorem(b,S) + '0'; | ||
2485 | if (i >= ilim) | ||
2486 | break; | ||
2487 | b = multadd(b, 10, 0); | ||
2488 | } | ||
2489 | |||
2490 | /* Round off last digit */ | ||
2491 | |||
2492 | b = lshift(b, 1); | ||
2493 | j = cmp(b, S); | ||
2494 | if (j > 0 || j == 0 && dig & 1) { | ||
2495 | roundoff: | ||
2496 | while(*--s == '9') | ||
2497 | if (s == s0) { | ||
2498 | k++; | ||
2499 | *s++ = '1'; | ||
2500 | goto ret; | ||
2501 | } | ||
2502 | ++*s++; | ||
2503 | } | ||
2504 | else { | ||
2505 | while(*--s == '0'); | ||
2506 | s++; | ||
2507 | } | ||
2508 | ret: | ||
2509 | Bfree(S); | ||
2510 | if (mhi) { | ||
2511 | if (mlo && mlo != mhi) | ||
2512 | Bfree(mlo); | ||
2513 | Bfree(mhi); | ||
2514 | } | ||
2515 | ret1: | ||
2516 | Bfree(b); | ||
2517 | if (s == s0) { /* don't return empty string */ | ||
2518 | *s++ = '0'; | ||
2519 | k = 0; | ||
2520 | } | ||
2521 | *s = 0; | ||
2522 | *decpt = k + 1; | ||
2523 | if (rve) | ||
2524 | *rve = s; | ||
2525 | return s0; | ||
2526 | } | ||
2527 | #ifdef __cplusplus | ||
2528 | } | ||
2529 | #endif | ||
diff --git a/src/lib/libc/stdlib/strtol.3 b/src/lib/libc/stdlib/strtol.3 new file mode 100644 index 0000000000..b7d2cd1225 --- /dev/null +++ b/src/lib/libc/stdlib/strtol.3 | |||
@@ -0,0 +1,168 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" Chris Torek and the American National Standards Committee X3, | ||
6 | .\" on Information Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: strtol.3,v 1.3 1996/08/19 08:33:51 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 25, 1992 | ||
39 | .Dt STRTOL 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm strtol, strtoq | ||
43 | .Nd convert string value to a long or quad_t integer | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Fd #include <limits.h> | ||
47 | .Ft long | ||
48 | .Fn strtol "const char *nptr" "char **endptr" "int base" | ||
49 | |||
50 | .Fd #include <sys/types.h> | ||
51 | .Fd #include <stdlib.h> | ||
52 | .Fd #include <limits.h> | ||
53 | .Ft quad_t | ||
54 | .Fn strtoq "const char *nptr" "char **endptr" "int base" | ||
55 | .Sh DESCRIPTION | ||
56 | The | ||
57 | .Fn strtol | ||
58 | function | ||
59 | converts the string in | ||
60 | .Fa nptr | ||
61 | to a | ||
62 | .Em long | ||
63 | value. | ||
64 | The | ||
65 | .Fn strtoq | ||
66 | function | ||
67 | converts the string in | ||
68 | .Fa nptr | ||
69 | to a | ||
70 | .Em quad_t | ||
71 | value. | ||
72 | The conversion is done according to the given | ||
73 | .Fa base , | ||
74 | which must be between 2 and 36 inclusive, | ||
75 | or be the special value 0. | ||
76 | .Pp | ||
77 | The string may begin with an arbitrary amount of white space | ||
78 | (as determined by | ||
79 | .Xr isspace 3 ) | ||
80 | followed by a single optional | ||
81 | .Ql + | ||
82 | or | ||
83 | .Ql - | ||
84 | sign. | ||
85 | If | ||
86 | .Fa base | ||
87 | is zero or 16, | ||
88 | the string may then include a | ||
89 | .Ql 0x | ||
90 | prefix, | ||
91 | and the number will be read in base 16; otherwise, a zero | ||
92 | .Fa base | ||
93 | is taken as 10 (decimal) unless the next character is | ||
94 | .Ql 0 , | ||
95 | in which case it is taken as 8 (octal). | ||
96 | .Pp | ||
97 | The remainder of the string is converted to a | ||
98 | .Em long | ||
99 | value in the obvious manner, | ||
100 | stopping at the first character which is not a valid digit | ||
101 | in the given base. | ||
102 | (In bases above 10, the letter | ||
103 | .Ql A | ||
104 | in either upper or lower case | ||
105 | represents 10, | ||
106 | .Ql B | ||
107 | represents 11, and so forth, with | ||
108 | .Ql Z | ||
109 | representing 35.) | ||
110 | .Pp | ||
111 | If | ||
112 | .Fa endptr | ||
113 | is non nil, | ||
114 | .Fn strtol | ||
115 | stores the address of the first invalid character in | ||
116 | .Fa *endptr . | ||
117 | If there were no digits at all, however, | ||
118 | .Fn strtol | ||
119 | stores the original value of | ||
120 | .Fa nptr | ||
121 | in | ||
122 | .Fa *endptr . | ||
123 | (Thus, if | ||
124 | .Fa *nptr | ||
125 | is not | ||
126 | .Ql \e0 | ||
127 | but | ||
128 | .Fa **endptr | ||
129 | is | ||
130 | .Ql \e0 | ||
131 | on return, the entire string was valid.) | ||
132 | .Sh RETURN VALUES | ||
133 | The | ||
134 | .Fn strtol | ||
135 | function | ||
136 | returns the result of the conversion, | ||
137 | unless the value would underflow or overflow. | ||
138 | If an underflow occurs, | ||
139 | .Fn strtol | ||
140 | returns | ||
141 | .Dv LONG_MIN . | ||
142 | If an overflow occurs, | ||
143 | .Fn strtol | ||
144 | returns | ||
145 | .Dv LONG_MAX . | ||
146 | In both cases, | ||
147 | .Va errno | ||
148 | is set to | ||
149 | .Er ERANGE . | ||
150 | .Sh ERRORS | ||
151 | .Bl -tag -width Er | ||
152 | .It Bq Er ERANGE | ||
153 | The given string was out of range; the value converted has been clamped. | ||
154 | .El | ||
155 | .Sh SEE ALSO | ||
156 | .Xr atof 3 , | ||
157 | .Xr atoi 3 , | ||
158 | .Xr atol 3 , | ||
159 | .Xr strtod 3 , | ||
160 | .Xr strtoul 3 | ||
161 | .Sh STANDARDS | ||
162 | The | ||
163 | .Fn strtol | ||
164 | function | ||
165 | conforms to | ||
166 | .St -ansiC . | ||
167 | .Sh BUGS | ||
168 | Ignores the current locale. | ||
diff --git a/src/lib/libc/stdlib/strtol.c b/src/lib/libc/stdlib/strtol.c new file mode 100644 index 0000000000..e4ad557fd5 --- /dev/null +++ b/src/lib/libc/stdlib/strtol.c | |||
@@ -0,0 +1,150 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1990 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: strtol.c,v 1.4 1996/08/19 08:33:51 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <ctype.h> | ||
39 | #include <errno.h> | ||
40 | #include <limits.h> | ||
41 | #include <stdlib.h> | ||
42 | |||
43 | |||
44 | /* | ||
45 | * Convert a string to a long integer. | ||
46 | * | ||
47 | * Ignores `locale' stuff. Assumes that the upper and lower case | ||
48 | * alphabets and digits are each contiguous. | ||
49 | */ | ||
50 | long | ||
51 | strtol(nptr, endptr, base) | ||
52 | const char *nptr; | ||
53 | char **endptr; | ||
54 | register int base; | ||
55 | { | ||
56 | register const char *s; | ||
57 | register long acc, cutoff; | ||
58 | register int c; | ||
59 | register int neg, any, cutlim; | ||
60 | |||
61 | /* | ||
62 | * Skip white space and pick up leading +/- sign if any. | ||
63 | * If base is 0, allow 0x for hex and 0 for octal, else | ||
64 | * assume decimal; if base is already 16, allow 0x. | ||
65 | */ | ||
66 | s = nptr; | ||
67 | do { | ||
68 | c = (unsigned char) *s++; | ||
69 | } while (isspace(c)); | ||
70 | if (c == '-') { | ||
71 | neg = 1; | ||
72 | c = *s++; | ||
73 | } else { | ||
74 | neg = 0; | ||
75 | if (c == '+') | ||
76 | c = *s++; | ||
77 | } | ||
78 | if ((base == 0 || base == 16) && | ||
79 | c == '0' && (*s == 'x' || *s == 'X')) { | ||
80 | c = s[1]; | ||
81 | s += 2; | ||
82 | base = 16; | ||
83 | } | ||
84 | if (base == 0) | ||
85 | base = c == '0' ? 8 : 10; | ||
86 | |||
87 | /* | ||
88 | * Compute the cutoff value between legal numbers and illegal | ||
89 | * numbers. That is the largest legal value, divided by the | ||
90 | * base. An input number that is greater than this value, if | ||
91 | * followed by a legal input character, is too big. One that | ||
92 | * is equal to this value may be valid or not; the limit | ||
93 | * between valid and invalid numbers is then based on the last | ||
94 | * digit. For instance, if the range for longs is | ||
95 | * [-2147483648..2147483647] and the input base is 10, | ||
96 | * cutoff will be set to 214748364 and cutlim to either | ||
97 | * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated | ||
98 | * a value > 214748364, or equal but the next digit is > 7 (or 8), | ||
99 | * the number is too big, and we will return a range error. | ||
100 | * | ||
101 | * Set any if any `digits' consumed; make it negative to indicate | ||
102 | * overflow. | ||
103 | */ | ||
104 | cutoff = neg ? LONG_MIN : LONG_MAX; | ||
105 | cutlim = cutoff % base; | ||
106 | cutoff /= base; | ||
107 | if (neg) { | ||
108 | if (cutlim > 0) { | ||
109 | cutlim -= base; | ||
110 | cutoff += 1; | ||
111 | } | ||
112 | cutlim = -cutlim; | ||
113 | } | ||
114 | for (acc = 0, any = 0;; c = (unsigned char) *s++) { | ||
115 | if (isdigit(c)) | ||
116 | c -= '0'; | ||
117 | else if (isalpha(c)) | ||
118 | c -= isupper(c) ? 'A' - 10 : 'a' - 10; | ||
119 | else | ||
120 | break; | ||
121 | if (c >= base) | ||
122 | break; | ||
123 | if (any < 0) | ||
124 | continue; | ||
125 | if (neg) { | ||
126 | if (acc < cutoff || acc == cutoff && c > cutlim) { | ||
127 | any = -1; | ||
128 | acc = LONG_MIN; | ||
129 | errno = ERANGE; | ||
130 | } else { | ||
131 | any = 1; | ||
132 | acc *= base; | ||
133 | acc -= c; | ||
134 | } | ||
135 | } else { | ||
136 | if (acc > cutoff || acc == cutoff && c > cutlim) { | ||
137 | any = -1; | ||
138 | acc = LONG_MAX; | ||
139 | errno = ERANGE; | ||
140 | } else { | ||
141 | any = 1; | ||
142 | acc *= base; | ||
143 | acc += c; | ||
144 | } | ||
145 | } | ||
146 | } | ||
147 | if (endptr != 0) | ||
148 | *endptr = (char *) (any ? s - 1 : nptr); | ||
149 | return (acc); | ||
150 | } | ||
diff --git a/src/lib/libc/stdlib/strtoq.c b/src/lib/libc/stdlib/strtoq.c new file mode 100644 index 0000000000..44aabd73f0 --- /dev/null +++ b/src/lib/libc/stdlib/strtoq.c | |||
@@ -0,0 +1,152 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1992 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char rcsid[] = "$OpenBSD: strtoq.c,v 1.4 1996/08/19 08:33:52 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <sys/types.h> | ||
39 | |||
40 | #include <ctype.h> | ||
41 | #include <errno.h> | ||
42 | #include <limits.h> | ||
43 | #include <stdlib.h> | ||
44 | |||
45 | /* | ||
46 | * Convert a string to a quad integer. | ||
47 | * | ||
48 | * Ignores `locale' stuff. Assumes that the upper and lower case | ||
49 | * alphabets and digits are each contiguous. | ||
50 | */ | ||
51 | quad_t | ||
52 | strtoq(nptr, endptr, base) | ||
53 | const char *nptr; | ||
54 | char **endptr; | ||
55 | register int base; | ||
56 | { | ||
57 | register const char *s; | ||
58 | register quad_t acc, cutoff; | ||
59 | register int c; | ||
60 | register int neg, any, cutlim; | ||
61 | |||
62 | /* | ||
63 | * Skip white space and pick up leading +/- sign if any. | ||
64 | * If base is 0, allow 0x for hex and 0 for octal, else | ||
65 | * assume decimal; if base is already 16, allow 0x. | ||
66 | */ | ||
67 | s = nptr; | ||
68 | do { | ||
69 | c = (unsigned char) *s++; | ||
70 | } while (isspace(c)); | ||
71 | if (c == '-') { | ||
72 | neg = 1; | ||
73 | c = *s++; | ||
74 | } else { | ||
75 | neg = 0; | ||
76 | if (c == '+') | ||
77 | c = *s++; | ||
78 | } | ||
79 | if ((base == 0 || base == 16) && | ||
80 | c == '0' && (*s == 'x' || *s == 'X')) { | ||
81 | c = s[1]; | ||
82 | s += 2; | ||
83 | base = 16; | ||
84 | } | ||
85 | if (base == 0) | ||
86 | base = c == '0' ? 8 : 10; | ||
87 | |||
88 | /* | ||
89 | * Compute the cutoff value between legal numbers and illegal | ||
90 | * numbers. That is the largest legal value, divided by the | ||
91 | * base. An input number that is greater than this value, if | ||
92 | * followed by a legal input character, is too big. One that | ||
93 | * is equal to this value may be valid or not; the limit | ||
94 | * between valid and invalid numbers is then based on the last | ||
95 | * digit. For instance, if the range for quads is | ||
96 | * [-9223372036854775808..9223372036854775807] and the input base | ||
97 | * is 10, cutoff will be set to 922337203685477580 and cutlim to | ||
98 | * either 7 (neg==0) or 8 (neg==1), meaning that if we have | ||
99 | * accumulated a value > 922337203685477580, or equal but the | ||
100 | * next digit is > 7 (or 8), the number is too big, and we will | ||
101 | * return a range error. | ||
102 | * | ||
103 | * Set any if any `digits' consumed; make it negative to indicate | ||
104 | * overflow. | ||
105 | */ | ||
106 | cutoff = neg ? QUAD_MIN : QUAD_MAX; | ||
107 | cutlim = cutoff % base; | ||
108 | cutoff /= base; | ||
109 | if (neg) { | ||
110 | if (cutlim > 0) { | ||
111 | cutlim -= base; | ||
112 | cutoff += 1; | ||
113 | } | ||
114 | cutlim = -cutlim; | ||
115 | } | ||
116 | for (acc = 0, any = 0;; c = (unsigned char) *s++) { | ||
117 | if (isdigit(c)) | ||
118 | c -= '0'; | ||
119 | else if (isalpha(c)) | ||
120 | c -= isupper(c) ? 'A' - 10 : 'a' - 10; | ||
121 | else | ||
122 | break; | ||
123 | if (c >= base) | ||
124 | break; | ||
125 | if (any < 0) | ||
126 | continue; | ||
127 | if (neg) { | ||
128 | if (acc < cutoff || acc == cutoff && c > cutlim) { | ||
129 | any = -1; | ||
130 | acc = QUAD_MIN; | ||
131 | errno = ERANGE; | ||
132 | } else { | ||
133 | any = 1; | ||
134 | acc *= base; | ||
135 | acc -= c; | ||
136 | } | ||
137 | } else { | ||
138 | if (acc > cutoff || acc == cutoff && c > cutlim) { | ||
139 | any = -1; | ||
140 | acc = QUAD_MAX; | ||
141 | errno = ERANGE; | ||
142 | } else { | ||
143 | any = 1; | ||
144 | acc *= base; | ||
145 | acc += c; | ||
146 | } | ||
147 | } | ||
148 | } | ||
149 | if (endptr != 0) | ||
150 | *endptr = (char *) (any ? s - 1 : nptr); | ||
151 | return (acc); | ||
152 | } | ||
diff --git a/src/lib/libc/stdlib/strtoul.3 b/src/lib/libc/stdlib/strtoul.3 new file mode 100644 index 0000000000..b8234122a2 --- /dev/null +++ b/src/lib/libc/stdlib/strtoul.3 | |||
@@ -0,0 +1,163 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" Chris Torek and the American National Standards Committee X3, | ||
6 | .\" on Information Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: strtoul.3,v 1.2 1996/08/19 08:33:52 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 25, 1992 | ||
39 | .Dt STRTOUL 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm strtoul, strtouq | ||
43 | .Nd convert a string to an unsigned long or uquad_t integer | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Fd #include <limits.h> | ||
47 | .Ft unsigned long | ||
48 | .Fn strtoul "const char *nptr" "char **endptr" "int base" | ||
49 | |||
50 | .Fd #include <sys/types.h> | ||
51 | .Fd #include <stdlib.h> | ||
52 | .Fd #include <limits.h> | ||
53 | .Ft u_quad_t | ||
54 | .Fn strtouq "const char *nptr" "char **endptr" "int base" | ||
55 | .Sh DESCRIPTION | ||
56 | The | ||
57 | .Fn strtoul | ||
58 | function | ||
59 | converts the string in | ||
60 | .Fa nptr | ||
61 | to an | ||
62 | .Em unsigned long | ||
63 | value. | ||
64 | The | ||
65 | .Fn strtouq | ||
66 | function | ||
67 | converts the string in | ||
68 | .Fa nptr | ||
69 | to a | ||
70 | .Em u_quad_t | ||
71 | value. | ||
72 | The conversion is done according to the given | ||
73 | .Fa base , | ||
74 | which must be between 2 and 36 inclusive, | ||
75 | or be the special value 0. | ||
76 | .Pp | ||
77 | The string may begin with an arbitrary amount of white space | ||
78 | (as determined by | ||
79 | .Xr isspace 3 ) | ||
80 | followed by a single optional | ||
81 | .Ql + | ||
82 | or | ||
83 | .Ql - | ||
84 | sign. | ||
85 | If | ||
86 | .Fa base | ||
87 | is zero or 16, | ||
88 | the string may then include a | ||
89 | .Ql 0x | ||
90 | prefix, | ||
91 | and the number will be read in base 16; otherwise, a zero | ||
92 | .Fa base | ||
93 | is taken as 10 (decimal) unless the next character is | ||
94 | .Ql 0 , | ||
95 | in which case it is taken as 8 (octal). | ||
96 | .Pp | ||
97 | The remainder of the string is converted to an | ||
98 | .Em unsigned long | ||
99 | value in the obvious manner, | ||
100 | stopping at the end of the string | ||
101 | or at the first character that does not produce a valid digit | ||
102 | in the given base. | ||
103 | (In bases above 10, the letter | ||
104 | .Ql A | ||
105 | in either upper or lower case | ||
106 | represents 10, | ||
107 | .Ql B | ||
108 | represents 11, and so forth, with | ||
109 | .Ql Z | ||
110 | representing 35.) | ||
111 | .Pp | ||
112 | If | ||
113 | .Fa endptr | ||
114 | is non nil, | ||
115 | .Fn strtoul | ||
116 | stores the address of the first invalid character in | ||
117 | .Fa *endptr . | ||
118 | If there were no digits at all, however, | ||
119 | .Fn strtoul | ||
120 | stores the original value of | ||
121 | .Fa nptr | ||
122 | in | ||
123 | .Fa *endptr . | ||
124 | (Thus, if | ||
125 | .Fa *nptr | ||
126 | is not | ||
127 | .Ql \e0 | ||
128 | but | ||
129 | .Fa **endptr | ||
130 | is | ||
131 | .Ql \e0 | ||
132 | on return, the entire string was valid.) | ||
133 | .Sh RETURN VALUES | ||
134 | The | ||
135 | .Fn strtoul | ||
136 | function | ||
137 | returns either the result of the conversion | ||
138 | or, if there was a leading minus sign, | ||
139 | the negation of the result of the conversion, | ||
140 | unless the original (non-negated) value would overflow; | ||
141 | in the latter case, | ||
142 | .Fn strtoul | ||
143 | returns | ||
144 | .Dv ULONG_MAX | ||
145 | and sets the global variable | ||
146 | .Va errno | ||
147 | to | ||
148 | .Er ERANGE . | ||
149 | .Sh ERRORS | ||
150 | .Bl -tag -width Er | ||
151 | .It Bq Er ERANGE | ||
152 | The given string was out of range; the value converted has been clamped. | ||
153 | .El | ||
154 | .Sh SEE ALSO | ||
155 | .Xr strtol 3 | ||
156 | .Sh STANDARDS | ||
157 | The | ||
158 | .Fn strtoul | ||
159 | function | ||
160 | conforms to | ||
161 | .St -ansiC . | ||
162 | .Sh BUGS | ||
163 | Ignores the current locale. | ||
diff --git a/src/lib/libc/stdlib/strtoul.c b/src/lib/libc/stdlib/strtoul.c new file mode 100644 index 0000000000..d3b363fa04 --- /dev/null +++ b/src/lib/libc/stdlib/strtoul.c | |||
@@ -0,0 +1,112 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1990 Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: strtoul.c,v 1.4 1996/08/19 08:33:52 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <ctype.h> | ||
39 | #include <errno.h> | ||
40 | #include <limits.h> | ||
41 | #include <stdlib.h> | ||
42 | |||
43 | /* | ||
44 | * Convert a string to an unsigned long integer. | ||
45 | * | ||
46 | * Ignores `locale' stuff. Assumes that the upper and lower case | ||
47 | * alphabets and digits are each contiguous. | ||
48 | */ | ||
49 | unsigned long | ||
50 | strtoul(nptr, endptr, base) | ||
51 | const char *nptr; | ||
52 | char **endptr; | ||
53 | register int base; | ||
54 | { | ||
55 | register const char *s; | ||
56 | register unsigned long acc, cutoff; | ||
57 | register int c; | ||
58 | register int neg, any, cutlim; | ||
59 | |||
60 | /* | ||
61 | * See strtol for comments as to the logic used. | ||
62 | */ | ||
63 | s = nptr; | ||
64 | do { | ||
65 | c = (unsigned char) *s++; | ||
66 | } while (isspace(c)); | ||
67 | if (c == '-') { | ||
68 | neg = 1; | ||
69 | c = *s++; | ||
70 | } else { | ||
71 | neg = 0; | ||
72 | if (c == '+') | ||
73 | c = *s++; | ||
74 | } | ||
75 | if ((base == 0 || base == 16) && | ||
76 | c == '0' && (*s == 'x' || *s == 'X')) { | ||
77 | c = s[1]; | ||
78 | s += 2; | ||
79 | base = 16; | ||
80 | } | ||
81 | if (base == 0) | ||
82 | base = c == '0' ? 8 : 10; | ||
83 | |||
84 | cutoff = ULONG_MAX / (unsigned long)base; | ||
85 | cutlim = ULONG_MAX % (unsigned long)base; | ||
86 | for (acc = 0, any = 0;; c = (unsigned char) *s++) { | ||
87 | if (isdigit(c)) | ||
88 | c -= '0'; | ||
89 | else if (isalpha(c)) | ||
90 | c -= isupper(c) ? 'A' - 10 : 'a' - 10; | ||
91 | else | ||
92 | break; | ||
93 | if (c >= base) | ||
94 | break; | ||
95 | if (any < 0) | ||
96 | continue; | ||
97 | if (acc > cutoff || acc == cutoff && c > cutlim) { | ||
98 | any = -1; | ||
99 | acc = ULONG_MAX; | ||
100 | errno = ERANGE; | ||
101 | } else { | ||
102 | any = 1; | ||
103 | acc *= (unsigned long)base; | ||
104 | acc += c; | ||
105 | } | ||
106 | } | ||
107 | if (neg && any > 0) | ||
108 | acc = -acc; | ||
109 | if (endptr != 0) | ||
110 | *endptr = (char *) (any ? s - 1 : nptr); | ||
111 | return (acc); | ||
112 | } | ||
diff --git a/src/lib/libc/stdlib/strtouq.c b/src/lib/libc/stdlib/strtouq.c new file mode 100644 index 0000000000..1f29a22f33 --- /dev/null +++ b/src/lib/libc/stdlib/strtouq.c | |||
@@ -0,0 +1,114 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1992 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char rcsid[] = "$OpenBSD: strtouq.c,v 1.4 1996/08/19 08:33:53 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <sys/types.h> | ||
39 | |||
40 | #include <ctype.h> | ||
41 | #include <errno.h> | ||
42 | #include <limits.h> | ||
43 | #include <stdlib.h> | ||
44 | |||
45 | /* | ||
46 | * Convert a string to an unsigned quad integer. | ||
47 | * | ||
48 | * Ignores `locale' stuff. Assumes that the upper and lower case | ||
49 | * alphabets and digits are each contiguous. | ||
50 | */ | ||
51 | u_quad_t | ||
52 | strtouq(nptr, endptr, base) | ||
53 | const char *nptr; | ||
54 | char **endptr; | ||
55 | register int base; | ||
56 | { | ||
57 | register const char *s; | ||
58 | register u_quad_t acc, cutoff; | ||
59 | register int c; | ||
60 | register int neg, any, cutlim; | ||
61 | |||
62 | /* | ||
63 | * See strtoq for comments as to the logic used. | ||
64 | */ | ||
65 | s = nptr; | ||
66 | do { | ||
67 | c = (unsigned char) *s++; | ||
68 | } while (isspace(c)); | ||
69 | if (c == '-') { | ||
70 | neg = 1; | ||
71 | c = *s++; | ||
72 | } else { | ||
73 | neg = 0; | ||
74 | if (c == '+') | ||
75 | c = *s++; | ||
76 | } | ||
77 | if ((base == 0 || base == 16) && | ||
78 | c == '0' && (*s == 'x' || *s == 'X')) { | ||
79 | c = s[1]; | ||
80 | s += 2; | ||
81 | base = 16; | ||
82 | } | ||
83 | if (base == 0) | ||
84 | base = c == '0' ? 8 : 10; | ||
85 | |||
86 | cutoff = UQUAD_MAX / (u_quad_t)base; | ||
87 | cutlim = UQUAD_MAX % (u_quad_t)base; | ||
88 | for (acc = 0, any = 0;; c = (unsigned char) *s++) { | ||
89 | if (isdigit(c)) | ||
90 | c -= '0'; | ||
91 | else if (isalpha(c)) | ||
92 | c -= isupper(c) ? 'A' - 10 : 'a' - 10; | ||
93 | else | ||
94 | break; | ||
95 | if (c >= base) | ||
96 | break; | ||
97 | if (any < 0) | ||
98 | continue; | ||
99 | if (acc > cutoff || acc == cutoff && c > cutlim) { | ||
100 | any = -1; | ||
101 | acc = UQUAD_MAX; | ||
102 | errno = ERANGE; | ||
103 | } else { | ||
104 | any = 1; | ||
105 | acc *= (u_quad_t)base; | ||
106 | acc += c; | ||
107 | } | ||
108 | } | ||
109 | if (neg && any > 0) | ||
110 | acc = -acc; | ||
111 | if (endptr != 0) | ||
112 | *endptr = (char *) (any ? s - 1 : nptr); | ||
113 | return (acc); | ||
114 | } | ||
diff --git a/src/lib/libc/stdlib/system.3 b/src/lib/libc/stdlib/system.3 new file mode 100644 index 0000000000..985adb07de --- /dev/null +++ b/src/lib/libc/stdlib/system.3 | |||
@@ -0,0 +1,98 @@ | |||
1 | .\" Copyright (c) 1990, 1991 The Regents of the University of California. | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" This code is derived from software contributed to Berkeley by | ||
5 | .\" the American National Standards Committee X3, on Information | ||
6 | .\" Processing Systems. | ||
7 | .\" | ||
8 | .\" Redistribution and use in source and binary forms, with or without | ||
9 | .\" modification, are permitted provided that the following conditions | ||
10 | .\" are met: | ||
11 | .\" 1. Redistributions of source code must retain the above copyright | ||
12 | .\" notice, this list of conditions and the following disclaimer. | ||
13 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
14 | .\" notice, this list of conditions and the following disclaimer in the | ||
15 | .\" documentation and/or other materials provided with the distribution. | ||
16 | .\" 3. All advertising materials mentioning features or use of this software | ||
17 | .\" must display the following acknowledgement: | ||
18 | .\" This product includes software developed by the University of | ||
19 | .\" California, Berkeley and its contributors. | ||
20 | .\" 4. Neither the name of the University nor the names of its contributors | ||
21 | .\" may be used to endorse or promote products derived from this software | ||
22 | .\" without specific prior written permission. | ||
23 | .\" | ||
24 | .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
25 | .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
26 | .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
27 | .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
28 | .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
29 | .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
30 | .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
31 | .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
32 | .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
33 | .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
34 | .\" SUCH DAMAGE. | ||
35 | .\" | ||
36 | .\" $OpenBSD: system.3,v 1.5 1996/12/11 23:09:53 tholo Exp $ | ||
37 | .\" | ||
38 | .Dd June 29, 1991 | ||
39 | .Dt SYSTEM 3 | ||
40 | .Os | ||
41 | .Sh NAME | ||
42 | .Nm system | ||
43 | .Nd pass a command to the shell | ||
44 | .Sh SYNOPSIS | ||
45 | .Fd #include <stdlib.h> | ||
46 | .Ft int | ||
47 | .Fn system "const char *string" | ||
48 | .Sh DESCRIPTION | ||
49 | The | ||
50 | .Fn system | ||
51 | function | ||
52 | hands the argument | ||
53 | .Fa string | ||
54 | to the command interpreter | ||
55 | .Xr sh 1 . | ||
56 | The calling process waits for the shell to finish executing the command, | ||
57 | ignoring | ||
58 | .Dv SIGINT | ||
59 | and | ||
60 | .Dv SIGQUIT , | ||
61 | and blocking | ||
62 | .Dv SIGCHLD . | ||
63 | .Pp | ||
64 | If | ||
65 | .Fa string | ||
66 | is a | ||
67 | .Dv NULL | ||
68 | pointer, | ||
69 | .Fn system | ||
70 | will return non-zero. | ||
71 | Otherwise, | ||
72 | .Fn system | ||
73 | returns the termination status of the shell in the format specified by | ||
74 | .Xr waitpid 2 . | ||
75 | .Sh RETURN VALUES | ||
76 | If a child process cannot be created, or the termination status of | ||
77 | the shell cannot be obtained, | ||
78 | .Fn system | ||
79 | returns -1 and sets | ||
80 | .Va errno | ||
81 | to indicate the error. | ||
82 | If execution of the shell fails, | ||
83 | .Fn system | ||
84 | returns the termination status for a program that terminates with a call of | ||
85 | .Fn exit 127 . | ||
86 | .Sh SEE ALSO | ||
87 | .Xr sh 1 , | ||
88 | .Xr execve 2 , | ||
89 | .Xr waitpid 2 , | ||
90 | .Xr popen 3 | ||
91 | .Sh STANDARDS | ||
92 | The | ||
93 | .Fn system | ||
94 | function | ||
95 | conforms to | ||
96 | .St -ansiC | ||
97 | and | ||
98 | .St -p1003.2-92 . | ||
diff --git a/src/lib/libc/stdlib/system.c b/src/lib/libc/stdlib/system.c new file mode 100644 index 0000000000..3e1b047393 --- /dev/null +++ b/src/lib/libc/stdlib/system.c | |||
@@ -0,0 +1,80 @@ | |||
1 | /* | ||
2 | * Copyright (c) 1988 The Regents of the University of California. | ||
3 | * All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. All advertising materials mentioning features or use of this software | ||
14 | * must display the following acknowledgement: | ||
15 | * This product includes software developed by the University of | ||
16 | * California, Berkeley and its contributors. | ||
17 | * 4. Neither the name of the University nor the names of its contributors | ||
18 | * may be used to endorse or promote products derived from this software | ||
19 | * without specific prior written permission. | ||
20 | * | ||
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
31 | * SUCH DAMAGE. | ||
32 | */ | ||
33 | |||
34 | #if defined(LIBC_SCCS) && !defined(lint) | ||
35 | static char *rcsid = "$OpenBSD: system.c,v 1.3 1996/09/15 09:31:52 tholo Exp $"; | ||
36 | #endif /* LIBC_SCCS and not lint */ | ||
37 | |||
38 | #include <sys/types.h> | ||
39 | #include <sys/wait.h> | ||
40 | #include <signal.h> | ||
41 | #include <stdlib.h> | ||
42 | #include <unistd.h> | ||
43 | #include <paths.h> | ||
44 | |||
45 | extern char **environ; | ||
46 | |||
47 | int | ||
48 | system(command) | ||
49 | const char *command; | ||
50 | { | ||
51 | pid_t pid; | ||
52 | sig_t intsave, quitsave; | ||
53 | int omask; | ||
54 | int pstat; | ||
55 | char *argp[] = {"sh", "-c", NULL, NULL}; | ||
56 | |||
57 | if (!command) /* just checking... */ | ||
58 | return(1); | ||
59 | |||
60 | argp[2] = (char *)command; | ||
61 | |||
62 | omask = sigblock(sigmask(SIGCHLD)); | ||
63 | switch(pid = vfork()) { | ||
64 | case -1: /* error */ | ||
65 | (void)sigsetmask(omask); | ||
66 | return(-1); | ||
67 | case 0: /* child */ | ||
68 | (void)sigsetmask(omask); | ||
69 | execve(_PATH_BSHELL, argp, environ); | ||
70 | _exit(127); | ||
71 | } | ||
72 | |||
73 | intsave = signal(SIGINT, SIG_IGN); | ||
74 | quitsave = signal(SIGQUIT, SIG_IGN); | ||
75 | pid = waitpid(pid, (int *)&pstat, 0); | ||
76 | (void)sigsetmask(omask); | ||
77 | (void)signal(SIGINT, intsave); | ||
78 | (void)signal(SIGQUIT, quitsave); | ||
79 | return(pid == -1 ? -1 : pstat); | ||
80 | } | ||
diff --git a/src/lib/libc/stdlib/tfind.c b/src/lib/libc/stdlib/tfind.c new file mode 100644 index 0000000000..9e5bd4b0f2 --- /dev/null +++ b/src/lib/libc/stdlib/tfind.c | |||
@@ -0,0 +1,41 @@ | |||
1 | /* | ||
2 | * Tree search generalized from Knuth (6.2.2) Algorithm T just like | ||
3 | * the AT&T man page says. | ||
4 | * | ||
5 | * The node_t structure is for internal use only, lint doesn't grok it. | ||
6 | * | ||
7 | * Written by reading the System V Interface Definition, not the code. | ||
8 | * | ||
9 | * Totally public domain. | ||
10 | */ | ||
11 | /*LINTLIBRARY*/ | ||
12 | #include <search.h> | ||
13 | |||
14 | typedef struct node_t | ||
15 | { | ||
16 | char *key; | ||
17 | struct node_t *llink, *rlink; | ||
18 | } node; | ||
19 | |||
20 | /* find a node, or return 0 */ | ||
21 | void * | ||
22 | tfind(vkey, vrootp, compar) | ||
23 | const void *vkey; /* key to be found */ | ||
24 | void *const *vrootp; /* address of the tree root */ | ||
25 | int (*compar) __P((const void *, const void *)); | ||
26 | { | ||
27 | char *key = (char *)vkey; | ||
28 | node **rootp = (node **)vrootp; | ||
29 | |||
30 | if (rootp == (struct node_t **)0) | ||
31 | return ((struct node_t *)0); | ||
32 | while (*rootp != (struct node_t *)0) { /* T1: */ | ||
33 | int r; | ||
34 | if ((r = (*compar)(key, (*rootp)->key)) == 0) /* T2: */ | ||
35 | return (*rootp); /* key found */ | ||
36 | rootp = (r < 0) ? | ||
37 | &(*rootp)->llink : /* T3: follow left branch */ | ||
38 | &(*rootp)->rlink; /* T4: follow right branch */ | ||
39 | } | ||
40 | return (node *)0; | ||
41 | } | ||
diff --git a/src/lib/libc/stdlib/tsearch.3 b/src/lib/libc/stdlib/tsearch.3 new file mode 100644 index 0000000000..dbdae7943c --- /dev/null +++ b/src/lib/libc/stdlib/tsearch.3 | |||
@@ -0,0 +1,116 @@ | |||
1 | .\" Copyright (c) 1997 Todd C. Miller <Todd.Miller@courtesan.com> | ||
2 | .\" All rights reserved. | ||
3 | .\" | ||
4 | .\" Redistribution and use in source and binary forms, with or without | ||
5 | .\" modification, are permitted provided that the following conditions | ||
6 | .\" are met: | ||
7 | .\" 1. Redistributions of source code must retain the above copyright | ||
8 | .\" notice, this list of conditions and the following disclaimer. | ||
9 | .\" 2. Redistributions in binary form must reproduce the above copyright | ||
10 | .\" notice, this list of conditions and the following disclaimer in the | ||
11 | .\" documentation and/or other materials provided with the distribution. | ||
12 | .\" 3. The name of the author may not be used to endorse or promote products | ||
13 | .\" derived from this software without specific prior written permission. | ||
14 | .\" | ||
15 | .\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, | ||
16 | .\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY | ||
17 | .\" AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL | ||
18 | .\" THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
19 | .\" EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
20 | .\" PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | ||
21 | .\" OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | ||
22 | .\" WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | ||
23 | .\" OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | ||
24 | .\" ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
25 | .\" | ||
26 | .\" $OpenBSD: tsearch.3,v 1.2 1998/06/21 22:13:49 millert Exp $ | ||
27 | .\" | ||
28 | .Dd June 15, 1997 | ||
29 | .Dt TSEARCH 3 | ||
30 | .Os | ||
31 | .Sh NAME | ||
32 | .Nm tsearch, tfind, tdelete, twalk | ||
33 | .Nd manipulate binary search trees | ||
34 | .Sh SYNOPSIS | ||
35 | .Fd #include <search.h> | ||
36 | .Ft void * | ||
37 | .Fn tdelete "const void *key" "void **rootp", "int (*compar) (const void *, const void *)" | ||
38 | .Ft void * | ||
39 | .Fn tfind "const void *key" "void * const *rootp", "int (*compar) (const void *, const void *)" | ||
40 | .Ft void * | ||
41 | .Fn tsearch "const void *key" "void **rootp", "int (*compar) (const void *, const void *)" | ||
42 | .Ft void | ||
43 | .Fn twalk "const void *root" "void (*compar) (const void *, VISIT, int)" | ||
44 | .Sh DESCRIPTION | ||
45 | The | ||
46 | .Fn tdelete , | ||
47 | .Fn tfind , | ||
48 | .Fn tsearch , | ||
49 | and | ||
50 | .Fn twalk | ||
51 | functions manage binary search trees based on algorithms T and D | ||
52 | from Knuth (6.2.2). The comparison function passed in by | ||
53 | the user has the same style of return values as | ||
54 | .Xr strcmp 3 . | ||
55 | .Pp | ||
56 | .Fn Tfind | ||
57 | searches for the datum matched by the argument | ||
58 | .Fa key | ||
59 | in the binary tree rooted at | ||
60 | .Fa rootp , | ||
61 | returning a pointer to the datum if it is found and NULL | ||
62 | if it is not. | ||
63 | .Pp | ||
64 | .Fn Tsearch | ||
65 | is identical to | ||
66 | .Fn tfind | ||
67 | except that if no match is found, | ||
68 | .Fa key | ||
69 | is inserted into the tree and a pointer to it is returned. If | ||
70 | .Fa rootp | ||
71 | points to a NULL value a new binary search tree is created. | ||
72 | .Pp | ||
73 | .Fn Tdelete | ||
74 | deletes a node from the specified binary search tree and returns | ||
75 | a pointer to the parent of the node to be deleted. | ||
76 | It takes the same arguments as | ||
77 | .Fn tfind | ||
78 | and | ||
79 | .Fn tsearch . | ||
80 | If the node to be deleted is the root of the binary search tree, | ||
81 | .Fa rootp | ||
82 | will be adjusted. | ||
83 | .Pp | ||
84 | .Fn Twalk | ||
85 | walks the binary search tree rooted in | ||
86 | .fa root | ||
87 | and calls the function | ||
88 | .Fa action | ||
89 | on each node. | ||
90 | .Fa Action | ||
91 | is called with three arguments: a pointer to the current node, | ||
92 | a value from the enum | ||
93 | .Sy "typedef enum { preorder, postorder, endorder, leaf } VISIT;" | ||
94 | specifying the traversal type, and a node level (where level | ||
95 | zero is the root of the tree). | ||
96 | .Sh SEE ALSO | ||
97 | .Xr bsearch 3 , | ||
98 | .Xr hsearch 3 , | ||
99 | .Xr lsearch 3 | ||
100 | .Sh RETURN VALUES | ||
101 | The | ||
102 | .Fn tsearch | ||
103 | function returns NULL if allocation of a new node fails (usually | ||
104 | due to a lack of free memory). | ||
105 | .Pp | ||
106 | .Fn Tfind , | ||
107 | .Fn tsearch , | ||
108 | and | ||
109 | .Fn tdelete | ||
110 | return NULL if | ||
111 | .Fa rootp | ||
112 | is NULL or the datum cannot be found. | ||
113 | .Pp | ||
114 | The | ||
115 | .Fn twalk | ||
116 | function returns no value. | ||
diff --git a/src/lib/libc/stdlib/tsearch.c b/src/lib/libc/stdlib/tsearch.c new file mode 100644 index 0000000000..562ace1845 --- /dev/null +++ b/src/lib/libc/stdlib/tsearch.c | |||
@@ -0,0 +1,126 @@ | |||
1 | /* | ||
2 | * Tree search generalized from Knuth (6.2.2) Algorithm T just like | ||
3 | * the AT&T man page says. | ||
4 | * | ||
5 | * The node_t structure is for internal use only, lint doesn't grok it. | ||
6 | * | ||
7 | * Written by reading the System V Interface Definition, not the code. | ||
8 | * | ||
9 | * Totally public domain. | ||
10 | */ | ||
11 | /*LINTLIBRARY*/ | ||
12 | |||
13 | #include <search.h> | ||
14 | #include <stdlib.h> | ||
15 | |||
16 | typedef struct node_t { | ||
17 | char *key; | ||
18 | struct node_t *left, *right; | ||
19 | } node; | ||
20 | |||
21 | /* find or insert datum into search tree */ | ||
22 | void * | ||
23 | tsearch(vkey, vrootp, compar) | ||
24 | const void *vkey; /* key to be located */ | ||
25 | void **vrootp; /* address of tree root */ | ||
26 | int (*compar) __P((const void *, const void *)); | ||
27 | { | ||
28 | register node *q; | ||
29 | char *key = (char *)vkey; | ||
30 | node **rootp = (node **)vrootp; | ||
31 | |||
32 | if (rootp == (struct node_t **)0) | ||
33 | return ((void *)0); | ||
34 | while (*rootp != (struct node_t *)0) { /* Knuth's T1: */ | ||
35 | int r; | ||
36 | |||
37 | if ((r = (*compar)(key, (*rootp)->key)) == 0) /* T2: */ | ||
38 | return ((void *)*rootp); /* we found it! */ | ||
39 | rootp = (r < 0) ? | ||
40 | &(*rootp)->left : /* T3: follow left branch */ | ||
41 | &(*rootp)->right; /* T4: follow right branch */ | ||
42 | } | ||
43 | q = (node *) malloc(sizeof(node)); /* T5: key not found */ | ||
44 | if (q != (struct node_t *)0) { /* make new node */ | ||
45 | *rootp = q; /* link new node to old */ | ||
46 | q->key = key; /* initialize new node */ | ||
47 | q->left = q->right = (struct node_t *)0; | ||
48 | } | ||
49 | return ((void *)q); | ||
50 | } | ||
51 | |||
52 | /* delete node with given key */ | ||
53 | void * | ||
54 | tdelete(vkey, vrootp, compar) | ||
55 | const void *vkey; /* key to be deleted */ | ||
56 | void **vrootp; /* address of the root of tree */ | ||
57 | int (*compar) __P((const void *, const void *)); | ||
58 | { | ||
59 | node **rootp = (node **)vrootp; | ||
60 | char *key = (char *)vkey; | ||
61 | node *p; | ||
62 | register node *q; | ||
63 | register node *r; | ||
64 | int cmp; | ||
65 | |||
66 | if (rootp == (struct node_t **)0 || (p = *rootp) == (struct node_t *)0) | ||
67 | return ((struct node_t *)0); | ||
68 | while ((cmp = (*compar)(key, (*rootp)->key)) != 0) { | ||
69 | p = *rootp; | ||
70 | rootp = (cmp < 0) ? | ||
71 | &(*rootp)->left : /* follow left branch */ | ||
72 | &(*rootp)->right; /* follow right branch */ | ||
73 | if (*rootp == (struct node_t *)0) | ||
74 | return ((void *)0); /* key not found */ | ||
75 | } | ||
76 | r = (*rootp)->right; /* D1: */ | ||
77 | if ((q = (*rootp)->left) == (struct node_t *)0) /* Left (struct node_t *)0? */ | ||
78 | q = r; | ||
79 | else if (r != (struct node_t *)0) { /* Right link is null? */ | ||
80 | if (r->left == (struct node_t *)0) { /* D2: Find successor */ | ||
81 | r->left = q; | ||
82 | q = r; | ||
83 | } else { /* D3: Find (struct node_t *)0 link */ | ||
84 | for (q = r->left; q->left != (struct node_t *)0; q = r->left) | ||
85 | r = q; | ||
86 | r->left = q->right; | ||
87 | q->left = (*rootp)->left; | ||
88 | q->right = (*rootp)->right; | ||
89 | } | ||
90 | } | ||
91 | free((struct node_t *) *rootp); /* D4: Free node */ | ||
92 | *rootp = q; /* link parent to new node */ | ||
93 | return(p); | ||
94 | } | ||
95 | |||
96 | /* Walk the nodes of a tree */ | ||
97 | static void | ||
98 | trecurse(root, action, level) | ||
99 | register node *root; /* Root of the tree to be walked */ | ||
100 | register void (*action)(); /* Function to be called at each node */ | ||
101 | register int level; | ||
102 | { | ||
103 | if (root->left == (struct node_t *)0 && root->right == (struct node_t *)0) | ||
104 | (*action)(root, leaf, level); | ||
105 | else { | ||
106 | (*action)(root, preorder, level); | ||
107 | if (root->left != (struct node_t *)0) | ||
108 | trecurse(root->left, action, level + 1); | ||
109 | (*action)(root, postorder, level); | ||
110 | if (root->right != (struct node_t *)0) | ||
111 | trecurse(root->right, action, level + 1); | ||
112 | (*action)(root, endorder, level); | ||
113 | } | ||
114 | } | ||
115 | |||
116 | /* Walk the nodes of a tree */ | ||
117 | void | ||
118 | twalk(vroot, action) | ||
119 | const void *vroot; /* Root of the tree to be walked */ | ||
120 | void (*action) __P((const void *, VISIT, int)); | ||
121 | { | ||
122 | node *root = (node *)vroot; | ||
123 | |||
124 | if (root != (node *)0 && action != (void(*)())0) | ||
125 | trecurse(root, action, 0); | ||
126 | } | ||