Chameleon Applications

Chameleon Applications Svn Source Tree

Root/branches/iFabio/i386/libsa/strtol.c

Source at commit 169 created 13 years 6 months ago.
By ifabio, Update my branch folder with last changes: - Update all language with last _title and _description (need translation). - Comment (disabled) in the main make the option for advanced pkg - Added Options (from scrax's basics folder) - Added Chameleon Prefpanel - Correct some minus error - Comment (disabled) the copy for the resourced folder.
1/*
2 * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights
7 * Reserved. This file contains Original Code and/or Modifications of
8 * Original Code as defined in and that are subject to the Apple Public
9 * Source License Version 2.0 (the "License"). You may not use this file
10 * except in compliance with the License. Please obtain a copy of the
11 * License at http://www.apple.com/publicsource and read it before using
12 * this file.
13 *
14 * The Original Code and all software distributed under the License are
15 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the
19 * License for the specific language governing rights and limitations
20 * under the License.
21 *
22 * @APPLE_LICENSE_HEADER_END@
23 */
24/*-
25 * Copyright (c) 1990, 1993
26 *The Regents of the University of California. All rights reserved.
27 *
28 * Redistribution and use in source and binary forms, with or without
29 * modification, are permitted provided that the following conditions
30 * are met:
31 * 1. Redistributions of source code must retain the above copyright
32 * notice, this list of conditions and the following disclaimer.
33 * 2. Redistributions in binary form must reproduce the above copyright
34 * notice, this list of conditions and the following disclaimer in the
35 * documentation and/or other materials provided with the distribution.
36 * 3. All advertising materials mentioning features or use of this software
37 * must display the following acknowledgement:
38 *This product includes software developed by the University of
39 *California, Berkeley and its contributors.
40 * 4. Neither the name of the University nor the names of its contributors
41 * may be used to endorse or promote products derived from this software
42 * without specific prior written permission.
43 *
44 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
45 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
46 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
47 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
48 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
49 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
50 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
51 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
52 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
53 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
54 * SUCH DAMAGE.
55 */
56
57/* Copyright (c) 1995 NeXT Computer, Inc. All rights reserved.
58 *
59 * HISTORY
60 * Modified by Curtis Galloway at NeXT June 1993,
61 * for use in the standalone library.
62 *
63 * 30-Nov-1995 Dean Reece at NeXT
64 * Created based on BSD4.4's strtol.c & strtoul.c.
65 * Removed dependency on _ctype_ by static versions of isupper()...
66 * Added support for "0b101..." binary constants.
67 * Commented out references to errno.
68 */
69
70#if defined(LIBC_SCCS) && !defined(lint)
71static char sccsid[] = "@(#)strtol.c5.4 (Berkeley) 2/23/91";
72#endif /* LIBC_SCCS and not lint */
73
74#include "libsa.h"
75#include <limits.h>
76
77/*
78 * Convert a string to a long integer.
79 *
80 * Ignores `locale' stuff. Assumes that the upper and lower case
81 * alphabets and digits are each contiguous.
82 */
83long
84strtol(nptr, endptr, base)
85const char *nptr;
86char **endptr;
87register int base;
88{
89register const char *s = nptr;
90register unsigned long acc;
91register int c;
92register unsigned long cutoff;
93register int neg = 0, any, cutlim;
94
95/*
96 * Skip white space and pick up leading +/- sign if any.
97 * If base is 0, allow 0x for hex and 0 for octal, else
98 * assume decimal; if base is already 16, allow 0x.
99 */
100do {
101c = *s++;
102} while (isspace(c));
103if (c == '-') {
104neg = 1;
105c = *s++;
106} else if (c == '+')
107c = *s++;
108if ((base == 0 || base == 16) &&
109 c == '0' && (*s == 'x' || *s == 'X')) {
110c = s[1];
111s += 2;
112base = 16;
113} else if ((base == 0 || base == 2) &&
114 c == '0' && (*s == 'b' || *s == 'B')) {
115c = s[1];
116s += 2;
117base = 2;
118}
119if (base == 0)
120base = c == '0' ? 8 : 10;
121
122/*
123 * Compute the cutoff value between legal numbers and illegal
124 * numbers. That is the largest legal value, divided by the
125 * base. An input number that is greater than this value, if
126 * followed by a legal input character, is too big. One that
127 * is equal to this value may be valid or not; the limit
128 * between valid and invalid numbers is then based on the last
129 * digit. For instance, if the range for longs is
130 * [-2147483648..2147483647] and the input base is 10,
131 * cutoff will be set to 214748364 and cutlim to either
132 * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
133 * a value > 214748364, or equal but the next digit is > 7 (or 8),
134 * the number is too big, and we will return a range error.
135 *
136 * Set any if any `digits' consumed; make it negative to indicate
137 * overflow.
138 */
139cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
140cutlim = cutoff % (unsigned long)base;
141cutoff /= (unsigned long)base;
142for (acc = 0, any = 0;; c = *s++) {
143if (isdigit(c))
144c -= '0';
145else if (isalpha(c))
146c -= isupper(c) ? 'A' - 10 : 'a' - 10;
147else
148break;
149if (c >= base)
150break;
151if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
152any = -1;
153else {
154any = 1;
155acc *= base;
156acc += c;
157}
158}
159if (any < 0) {
160acc = neg ? LONG_MIN : LONG_MAX;
161//errno = ERANGE;
162} else if (neg)
163acc = -acc;
164if (endptr != 0)
165*endptr = (char *)(any ? s - 1 : nptr);
166return (acc);
167}
168
169
170/*
171 * Convert a string to an unsigned long integer.
172 *
173 * Ignores `locale' stuff. Assumes that the upper and lower case
174 * alphabets and digits are each contiguous.
175 */
176unsigned long
177strtoul(nptr, endptr, base)
178const char *nptr;
179char **endptr;
180register int base;
181{
182register const char *s = nptr;
183register unsigned long acc;
184register int c;
185register unsigned long cutoff;
186register int neg = 0, any, cutlim;
187
188/*
189 * See strtol for comments as to the logic used.
190 */
191do {
192c = *s++;
193} while (isspace(c));
194if (c == '-') {
195neg = 1;
196c = *s++;
197} else if (c == '+')
198c = *s++;
199if ((base == 0 || base == 16) &&
200 c == '0' && (*s == 'x' || *s == 'X')) {
201c = s[1];
202s += 2;
203base = 16;
204} else if ((base == 0 || base == 2) &&
205 c == '0' && (*s == 'b' || *s == 'B')) {
206c = s[1];
207s += 2;
208base = 2;
209}
210if (base == 0)
211base = c == '0' ? 8 : 10;
212cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;
213cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;
214for (acc = 0, any = 0;; c = *s++) {
215if (isdigit(c))
216c -= '0';
217else if (isalpha(c))
218c -= isupper(c) ? 'A' - 10 : 'a' - 10;
219else
220break;
221if (c >= base)
222break;
223if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
224any = -1;
225else {
226any = 1;
227acc *= base;
228acc += c;
229}
230}
231if (any < 0) {
232acc = ULONG_MAX;
233//errno = ERANGE;
234} else if (neg)
235acc = -acc;
236if (endptr != 0)
237*endptr = (char *)(any ? s - 1 : nptr);
238return (acc);
239}
240
241/*
242 * Convert a string to an unsigned quad integer.
243 *
244 * Ignores `locale' stuff. Assumes that the upper and lower case
245 * alphabets and digits are each contiguous.
246 */
247unsigned long long
248strtouq(nptr, endptr, base)
249const char *nptr;
250char **endptr;
251register int base;
252{
253register const char *s = nptr;
254register unsigned long long acc;
255register int c;
256register unsigned long long qbase, cutoff;
257register int neg, any, cutlim;
258
259/*
260 * See strtoq for comments as to the logic used.
261 */
262s = nptr;
263do {
264c = *s++;
265} while (isspace(c));
266if (c == '-') {
267neg = 1;
268c = *s++;
269} else {
270neg = 0;
271if (c == '+')
272c = *s++;
273}
274if ((base == 0 || base == 16) &&
275 c == '0' && (*s == 'x' || *s == 'X')) {
276c = s[1];
277s += 2;
278base = 16;
279}
280if (base == 0)
281base = c == '0' ? 8 : 10;
282qbase = (unsigned)base;
283cutoff = (unsigned long long)UQUAD_MAX / qbase;
284cutlim = (unsigned long long)UQUAD_MAX % qbase;
285for (acc = 0, any = 0;; c = *s++) {
286if (isdigit(c))
287c -= '0';
288else if (isalpha(c))
289c -= isupper(c) ? 'A' - 10 : 'a' - 10;
290else
291break;
292if (c >= base)
293break;
294if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
295any = -1;
296else {
297any = 1;
298acc *= qbase;
299acc += c;
300}
301}
302if (any < 0) {
303acc = UQUAD_MAX;
304//errno = ERANGE;
305} else if (neg)
306acc = -acc;
307if (endptr != 0)
308*endptr = (char *)(any ? s - 1 : nptr);
309return (acc);
310}
311

Archive Download this file

Revision: 169