/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* This file contains the common part of the functions string_to_decimal,
* func_to_decimal, and file_to_decimal. Much of this code has been dupli-
* cated in wstring_to_decimal (see wstod.c) with some simplifications and
* appropriate modifications for wide characters. DO NOT fix a bug here
* without fixing the same bug in wstring_to_decimal, if it applies.
*
* The code below makes the following assumptions.
*
* 1. The first six parameters to the function are declared with the
* following names and types:
*
* char **ppc;
* int nmax;
* int fortran_conventions;
* decimal_record *pd;
* enum decimal_string_form *pform;
* char **pechar;
*
* 2. Before this file is #included, the following variables have been
* defined and initialized as shown:
*
* char *cp;
* char *good = *ppc - 1;
* int current;
* int nread;
*
* If the first character can be read successfully, then current is set
* to the value of the first character, cp is set to *ppc, (char)current
* is stored at *cp, and nread = 1. If the first character cannot be
* read successfully, then current = EOF and nread = 0.
*
* 3. The macro NEXT is defined to expand to code that implements
* the following logic:
*
* if (nread < nmax) {
* current = <next character>;
* if (current != EOF) {
* *++cp = (char)current;
* nread++;
* }
* } else
* current = EOF;
*
* Note that nread always reflects the number of characters successfully
* read, the buffer pointed to by *ppc gets filled only with characters
* that have been successfully read, and cp always points to the location
* in the buffer that was filled by the last character successfully read.
* current == EOF if and only if we can't read any more, either because
* we've reached the end of the input file or the buffer is full (i.e.,
* we've read nmax characters).
*
* 4. After this file is #included, the following variables may be used
* and will have the specified values:
*
* *ppc, *pd, *pform, and *pechar will be set as documented in the
* manual page;
* nmax and fortran_conventions will be unchanged;
* nread will be the number of characters actually read;
* cp will point to the last character actually read, provided at least
* one character was read successfully (in which case cp >= *ppc).
*/
(('a' <= c && c <= 'f') || ('A' <= c && c <= 'F'))))
{
int ids = 0;
int i, agree;
char decpt;
char *pfast;
int e, esign;
int expshift = 0;
/*
* This routine assumes that the radix point is a single
* ASCII character, so that following this assignment, the
* condition (current == decpt) will correctly detect it.
*/
if (fortran_conventions > 0)
decpt = '.';
else
/* input is invalid until we find something */
/* skip white space */
spacefound = 1;
NEXT;
}
/*
* We found at least one white space character. For
* Fortran formatted input, accept this; if we don't
* find anything else, we'll interpret it as a valid zero.
*/
sigfound = 0; /* 0 = only zeros found so far */
goto done;
} else {
}
} else {
}
/* look for optional leading sign */
if (current == '+') {
NEXT;
} else if (current == '-') {
NEXT;
}
/*
* Admissible first non-white-space, non-sign characters are
* 0-9, i, I, n, N, or the radix point.
*/
NEXT;
} else {
switch (current) {
case ' ':
if (fortran_conventions < 2)
goto done;
/*
* When fortran_conventions >= 2, treat leading
* blanks the same as leading zeroes.
*/
/*FALLTHRU*/
case '0':
/*
* Accept the leading zero and set pd->fpclass
* accordingly, but don't set sigfound until we
* determine that this isn't a "fake" hex string
* (i.e., 0x.p...).
*/
if (fortran_conventions < 0) {
/* look for a hex fp string */
NEXT;
/* assume hex fp form */
expshift = 2;
NEXT;
/*
* Only a digit or radix point can
* follow "0x".
*/
sigfound = 1;
NEXT;
break;
NEXT;
goto afterpoint;
} else if (current != '0') {
/* not hex fp after all */
expshift = 0;
goto done;
}
} else {
}
} else {
}
/* skip all leading zeros */
fortran_conventions >= 2)) {
NEXT;
}
sigfound = 0; /* 0 = only zeros found so far */
goto done;
} else {
}
break;
case 'i':
case 'I':
/* look for inf or infinity */
NEXT;
agree = 1;
while (agree <= 7 &&
NEXT;
agree++;
}
if (agree < 3)
goto done;
/* found valid infinity */
sigfound = 1;
__inf_read = 1;
if (agree < 8) {
} else {
}
/*
* Accept trailing blanks if no extra characters
* intervene.
*/
agree == 8)) {
while (current == ' ') {
NEXT;
}
}
goto done;
case 'n':
case 'N':
/* look for nan or nan(string) */
NEXT;
agree = 1;
while (agree <= 2 &&
NEXT;
agree++;
}
if (agree < 3)
goto done;
/* found valid NaN */
sigfound = 1;
__nan_read = 1;
if (current == '(') {
/* accept parenthesized string */
NEXT;
if (fortran_conventions < 0) {
current == '_') &&
NEXT;
}
current == '_') {
NEXT;
}
} else {
NEXT;
}
NEXT;
}
}
if (current != ')')
goto done;
/* prepare for loop below */
if (fortran_conventions >= 2) {
NEXT;
}
}
/* accept trailing blanks */
if (fortran_conventions >= 2) {
while (current == ' ') {
NEXT;
}
}
goto done;
default:
/*
* Don't accept the radix point just yet;
* we need to see at least one digit.
*/
NEXT;
goto afterpoint;
}
goto done;
}
}
/*
* Admissible characters after the first digit are a valid digit,
* an exponent delimiter (E or e for any decimal form; +, -, D, d,
* Q, or q when fortran_conventions >= 2; P or p for hex form),
* or the radix point. (Note that we can't get here unless we've
* already found a digit.)
*/
/*
* Found another nonzero digit. If there's enough room
* in pd->ds, store any intervening zeros we've found so far
* and then store this digit. Otherwise, stop storing
* digits in pd->ds and set pd->more.
*/
for (i = 0; i < nzbp; i++)
} else {
if (ids < DECIMAL_STRING_LENGTH) {
/* don't store any more digits */
}
}
sigfound = 1;
nzbp = 0;
NEXT;
/*
* Use an optimized loop to grab a consecutive sequence
* of nonzero digits quickly.
*/
nfast++) {
NEXT;
}
if (current == '0')
goto nextnumberzero; /* common case */
/* advance good to the last accepted digit */
goto nextnumber;
} else {
switch (current) {
case ' ':
if (fortran_conventions < 2)
goto done;
if (fortran_conventions == 2) {
while (current == ' ') {
NEXT;
}
goto nextnumber;
}
/*
* When fortran_conventions > 2, treat internal
* blanks the same as zeroes.
*/
/*FALLTHRU*/
case '0':
/*
* Count zeros before the radix point. Later we
* will either put these zeros into pd->ds or add
* nzbp to pd->exponent to account for them.
*/
fortran_conventions > 2)) {
nzbp++;
NEXT;
}
goto nextnumber;
case '+':
case '-':
case 'D':
case 'd':
case 'Q':
case 'q':
/*
* Only accept these as the start of the exponent
* field if fortran_conventions is positive.
*/
if (fortran_conventions <= 0)
goto done;
/*FALLTHRU*/
case 'E':
case 'e':
if ((int)form < 0)
goto done;
goto exponent;
case 'P':
case 'p':
if ((int)form > 0)
goto done;
goto exponent;
default:
/* accept the radix point */
if (form == fixed_int_form)
NEXT;
goto afterpoint;
}
goto done;
}
}
/*
* Admissible characters after the radix point are a valid digit
* or an exponent delimiter. (Note that it is possible to get
* here even though we haven't found any digits yet.)
*/
/* found a digit after the point; revise form */
else if (form == fixed_intdot_form)
if (sigfound < 1) {
/* no significant digits found until now */
sigfound = 1;
} else {
/* significant digits have been found */
} else {
if (ids < DECIMAL_STRING_LENGTH) {
/* don't store any more digits */
}
}
}
nzbp = 0;
nzap = 0;
NEXT;
/*
* Use an optimized loop to grab a consecutive sequence
* of nonzero digits quickly.
*/
nfast++) {
NEXT;
}
if (current == '0')
goto zeroafterpoint;
/* advance good to the last accepted digit */
goto afterpoint;
} else {
switch (current) {
case ' ':
if (fortran_conventions < 2)
goto done;
if (fortran_conventions == 2) {
/*
* Treat a radix point followed by blanks
* but no digits as zero so we'll pass FCVS.
*/
if (sigfound == -1) {
sigfound = 0;
}
while (current == ' ') {
NEXT;
}
goto afterpoint;
}
/*
* when fortran_conventions > 2, treat internal
* blanks the same as zeroes
*/
/*FALLTHRU*/
case '0':
/* found a digit after the point; revise form */
else if (form == fixed_intdot_form)
if (sigfound == -1) {
sigfound = 0;
}
/*
* Count zeros after the radix point. If we find
* any more nonzero digits later, we will put these
* zeros into pd->ds and decrease pd->exponent by
* nzap.
*/
fortran_conventions > 2)) {
nzap++;
NEXT;
}
goto done;
} else {
}
goto afterpoint;
case '+':
case '-':
case 'D':
case 'd':
case 'Q':
case 'q':
/*
* Only accept these as the start of the exponent
* field if fortran_conventions is positive.
*/
if (fortran_conventions <= 0)
goto done;
/*FALLTHRU*/
case 'E':
case 'e':
/* don't accept exponent without preceding digits */
goto done;
break;
case 'P':
case 'p':
/* don't accept exponent without preceding digits */
goto done;
break;
default:
goto done;
}
}
/*
* Set *pechar to point to the character that looks like the
* beginning of the exponent field, then attempt to parse it.
*/
/* skip the exponent character and following blanks */
NEXT;
while (current == ' ') {
NEXT;
}
if (fortran_conventions > 2)
}
}
e = 0;
esign = 0;
/* look for optional exponent sign */
if (current == '+') {
NEXT;
} else if (current == '-') {
esign = 1;
NEXT;
}
/*
* Accumulate explicit exponent. Note that if we don't find at
* least one digit, good won't be updated and e will remain 0.
* Also, we keep e from getting too large so we don't overflow
* the range of int (but notice that the threshold is large
* enough that any larger e would cause the result to underflow
* or overflow anyway).
*/
if (current == ' ') {
if (fortran_conventions < 2)
break;
if (fortran_conventions == 2) {
NEXT;
continue;
}
current = '0';
}
if (e <= 1000000)
NEXT;
/* accept trailing blanks */
while (current == ' ') {
NEXT;
}
}
}
if (esign == 1)
else
/*
* If we successfully parsed an exponent field, update form
* accordingly. If we didn't, don't set *pechar.
*/
switch (form) {
case whitespace_form:
case fixed_int_form:
break;
case fixed_intdot_form:
break;
case fixed_dotfrac_form:
break;
case fixed_intdotfrac_form:
break;
}
} else {
}
done:
/*
* If we found any zeros before the radix point that were not
* accounted for earlier, adjust the exponent. (This is only
* relevant when pd->fpclass == fp_normal, but it's harmless
* in all other cases.)
*/
/* terminate pd->ds if we haven't already */
if (ids < DECIMAL_STRING_LENGTH) {
}
/*
* If we accepted any characters, advance *ppc to point to the
* first character we didn't accept; otherwise, pass back a
* signaling nan.
*/
} else {
form = invalid_form;
}
}