/src/ghostpdl/psi/iscannum.c

Source (jump to first uncovered line)
/* Copyright (C) 2001-2024 Artifex Software, Inc.
   All Rights Reserved.

   This software is provided AS-IS with no warranty, either express or
   implied.

   This software is distributed under license and may not be copied,
   modified or distributed except as expressly authorized under the terms
   of the license contained in the file LICENSE in this distribution.

   Refer to licensing information at http://www.artifex.com or contact
   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,
   CA 94129, USA, for further information.
*/


/* Number scanner for Ghostscript interpreter */
#include "math_.h"
#include "ghost.h"
#include "ierrors.h"
#include "scommon.h"
#include "iscan.h"
#include "iscannum.h"   /* defines interface */
#include "scanchar.h"
#include "store.h"

/*
 * Warning: this file has a "spaghetti" control structure.  But since this
 * code accounts for over 10% of the execution time of some PostScript
 * files, this is one of the few places we feel this is justified.
 */

/*
 * Scan a number.  If the number consumes the entire string, return 0;
 * if not, set *psp to the first character beyond the number and return 1.
 */
int
scan_number(const byte * str, const byte * end, int sign,
            ref * pref, const byte ** psp, int scanner_options)
{
    const byte *sp = str;
#define GET_NEXT(cvar, sp, end_action)\
  if (sp >= end) { end_action; } else cvar = *sp++

    /*
     * Powers of 10 up to 6 can be represented accurately as
     * a single-precision float.
     */
#define NUM_POWERS_10 6
    static const float powers_10[NUM_POWERS_10 + 1] = {
        1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6
    };
    static const double neg_powers_10[NUM_POWERS_10 + 1] = {
        1e0, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6
    };

    ps_int ival;
    double dval;
    int exp10;
    int code = 0;
    int c, d;
    ps_int max_ps_int_scan, min_ps_int_scan;
    const byte *const decoder = scan_char_decoder;
#define IS_DIGIT(d, c)\
  ((d = decoder[c]) < 10)
#define WOULD_OVERFLOW(val, d, maxv)\
  (val >= maxv / 10 && (val > maxv / 10 || d > (int64_t)(maxv % 10)))

    GET_NEXT(c, sp, return_error(gs_error_syntaxerror));
    if (!IS_DIGIT(d, c)) {
        if (c != '.')
            return_error(gs_error_syntaxerror);
        /* Might be a number starting with '.'. */
        GET_NEXT(c, sp, return_error(gs_error_syntaxerror));
        if (!IS_DIGIT(d, c))
            return_error(gs_error_syntaxerror);
        ival = 0;
        goto i2r;
    }
    /* Accumulate an integer in ival. */
    /* Do up to 4 digits without a loop, */
    /* since we know this can't overflow and since */
    /* most numbers have 4 (integer) digits or fewer. */
    ival = d;
    if (end - sp >= 3) { /* just check once */
        if (!IS_DIGIT(d, (c = *sp))) {
            sp++;
            goto ind;
        }
        ival = ival * 10 + d;
        if (!IS_DIGIT(d, (c = sp[1]))) {
            sp += 2;
            goto ind;
        }
        ival = ival * 10 + d;
        sp += 3;
        if (!IS_DIGIT(d, (c = sp[-1])))
            goto ind;
        ival = ival * 10 + d;
    }

    max_ps_int_scan = scanner_options & SCAN_CPSI_MODE ? MAX_PS_INT32 : MAX_PS_INT;
    min_ps_int_scan = scanner_options & SCAN_CPSI_MODE ? MIN_PS_INT32 : MIN_PS_INT;

    for (;; ival = ival * 10 + d) {
        GET_NEXT(c, sp, goto iret);
        if (!IS_DIGIT(d, c))
            break;
        if (WOULD_OVERFLOW(((ps_uint)ival), d, max_ps_int_scan)) {
            if (ival == max_ps_int_scan / 10 && d == (max_ps_int_scan % 10) + 1 && sign < 0) {
                GET_NEXT(c, sp, c = EOFC);
                dval = -(double)min_ps_int_scan;
                if (c == 'e' || c == 'E') {
                    exp10 = 0;
                    goto fs;
                } else if (c == '.') {
                    GET_NEXT(c, sp, c = EOFC);
                    exp10 = 0;
                    goto fd;
                } else if (!IS_DIGIT(d, c)) {
                    ival = min_ps_int_scan;
                    break;
                }
            } else
                dval = (double)ival;
            goto l2d;
        }
    }
  ind:        /* We saw a non-digit while accumulating an integer in ival. */
    switch (c) {
        case '.':
            GET_NEXT(c, sp, c = EOFC);
            goto i2r;
        default:
            *psp = sp;
            code = 1;
            break;
        case EOFC:
            break;
        case 'e':
        case 'E':
            if (sign < 0)
                ival = -ival;
            dval = (double)ival;
            exp10 = 0;
            goto fe;
        case '#':
            {
                const int radix = ival;
                ps_int uval = 0, imax;

                if (sign || radix < min_radix || radix > max_radix)
                    return_error(gs_error_syntaxerror);
                /* Avoid multiplies for power-of-2 radix. */
                if (!(radix & (radix - 1))) {
                    int shift;

                    switch (radix) {
                        case 2:
                            shift = 1, imax = MAX_PS_UINT >> 1;
                            break;
                        case 4:
                            shift = 2, imax = MAX_PS_UINT >> 2;
                            break;
                        case 8:
                            shift = 3, imax = MAX_PS_UINT >> 3;
                            break;
                        case 16:
                            shift = 4, imax = MAX_PS_UINT >> 4;
                            break;
                        case 32:
                            shift = 5, imax = MAX_PS_UINT >> 5;
                            break;
                        default:  /* can't happen */
                            return_error(gs_error_rangecheck);
                    }
                    for (;; uval = (uval << shift) + d) {
                        GET_NEXT(c, sp, break);
                        d = decoder[c];
                        if (d >= radix) {
                            *psp = sp;
                            code = 1;
                            break;
                        }
                        if (uval > imax)
                            return_error(gs_error_limitcheck);
                    }
                } else {
                    ps_int irem = MAX_PS_UINT % radix;

                    imax = MAX_PS_UINT / radix;
                    for (;; uval = uval * radix + d) {
                        GET_NEXT(c, sp, break);
                        d = decoder[c];
                        if (d >= radix) {
                            *psp = sp;
                            code = 1;
                            break;
                        }
                        if (uval >= imax &&
                            (uval > imax || d > irem)
                            )
                            return_error(gs_error_limitcheck);
                    }
                }
                if (scanner_options & SCAN_CPSI_MODE) {
                    ps_uint32 int1 = 0;
                    int1 |= (uval & 0xffffffff);
                    make_int(pref, (ps_int)((ps_int32)int1));
                }
                else
                    make_int(pref, uval);

                return code;
            }
    }
iret:
    if (scanner_options & SCAN_CPSI_MODE) {
        make_int(pref, (sign < 0 ? (ps_int32)-ival : (ps_int32)ival));
    }
    else {
        make_int(pref, (sign < 0 ? (ps_int)-ival : (ps_int)ival));
    }
    return code;

    /* Accumulate a double in dval. */
l2d:
    exp10 = 0;
    for (;;) {
        dval = dval * 10 + d;
        GET_NEXT(c, sp, c = EOFC);
        if (!IS_DIGIT(d, c))
            break;
    }
    switch (c) {
        case '.':
            GET_NEXT(c, sp, c = EOFC);
            exp10 = 0;
            goto fd;
        default:
            *psp = sp;
            code = 1;
            /* falls through */
        case EOFC:
            if (sign < 0)
                dval = -dval;
            goto rret;
        case 'e':
        case 'E':
            exp10 = 0;
            goto fs;
        case '#':
            return_error(gs_error_syntaxerror);
    }

    /* We saw a '.' while accumulating an integer in ival. */
i2r:
    exp10 = 0;
    while (IS_DIGIT(d, c) || c == '-') {
        /*
         * PostScript gives an error on numbers with a '-' following a '.'
         * Adobe Acrobat Reader (PDF) apparently doesn't treat this as an
         * error. Experiments show that the numbers following the '-' are
         * ignored, so we swallow the fractional part. SCAN_PDF_INV_NUM
         *  enables this compatibility kloodge.
         */
        if (c == '-') {
            if ((SCAN_PDF_INV_NUM & scanner_options) == 0)
                break;
            do {
                GET_NEXT(c, sp, c = EOFC);
            } while (IS_DIGIT(d, c));
            break;
        }
        if (WOULD_OVERFLOW(ival, d, max_int)) {
            dval = (double)ival;
            goto fd;
        }
        ival = ival * 10 + d;
        exp10--;
        GET_NEXT(c, sp, c = EOFC);
    }
    if (sign < 0)
        ival = -ival;
    /* Take a shortcut for the common case */
    if (!(c == 'e' || c == 'E' || exp10 < -NUM_POWERS_10)) { /* Check for trailing garbage */
        if (c != EOFC)
            *psp = sp, code = 1;
        make_real(pref, ival * neg_powers_10[-exp10]);
        return code;
    }
    dval = (double)ival;
    goto fe;

    /* Now we are accumulating a double in dval. */
fd:
    while (IS_DIGIT(d, c)) {
        dval = dval * 10 + d;
        exp10--;
        GET_NEXT(c, sp, c = EOFC);
    }
fs:
    if (sign < 0)
        dval = -dval;
fe:
    /* Now dval contains the value, negated if necessary. */
    switch (c) {
        case 'e':
        case 'E':
            {     /* Check for a following exponent. */
                int esign = 0;
                int iexp;

                GET_NEXT(c, sp, return_error(gs_error_syntaxerror));
                switch (c) {
                    case '-':
                        esign = 1;
                        /* fall through */
                    case '+':
                        GET_NEXT(c, sp, return_error(gs_error_syntaxerror));
                }
                /* Scan the exponent.  We limit it arbitrarily to 999. */
                if (!IS_DIGIT(d, c))
                    return_error(gs_error_syntaxerror);
                iexp = d;
                for (;; iexp = iexp * 10 + d) {
                    GET_NEXT(c, sp, break);
                    if (!IS_DIGIT(d, c)) {
                        *psp = sp;
                        code = 1;
                        break;
                    }
                    if (iexp > 99)
                        return_error(gs_error_limitcheck);
                }
                if (esign)
                    exp10 -= iexp;
                else
                    exp10 += iexp;
                break;
            }
        default:
            *psp = sp;
            code = 1;
        case EOFC:
            ;
    }
    /* Compute dval * 10^exp10. */
    if (exp10 > 0) {
        while (exp10 > NUM_POWERS_10)
            dval *= powers_10[NUM_POWERS_10],
                exp10 -= NUM_POWERS_10;
        dval *= powers_10[exp10];
    } else if (exp10 < 0) {
        while (exp10 < -NUM_POWERS_10)
            dval /= powers_10[NUM_POWERS_10],
                exp10 += NUM_POWERS_10;
        dval /= powers_10[-exp10];
    }
    /*
     * Check for an out-of-range result.  Currently we don't check for
     * absurdly large numbers of digits in the accumulation loops,
     * but we should.
     */
    if (dval >= 0) {
        if (dval > MAX_FLOAT)
            return_error(gs_error_limitcheck);
    } else {
        if (dval < -MAX_FLOAT)
            return_error(gs_error_limitcheck);
    }
rret:
    make_real(pref, dval);
    return code;
}

Coverage Report

Created: 2025-06-10 06:59

Line	Count	Source (jump to first uncovered line)
1		/* Copyright (C) 2001-2024 Artifex Software, Inc.
2		All Rights Reserved.
3
4		This software is provided AS-IS with no warranty, either express or
5		implied.
6
7		This software is distributed under license and may not be copied,
8		modified or distributed except as expressly authorized under the terms
9		of the license contained in the file LICENSE in this distribution.
10
11		Refer to licensing information at http://www.artifex.com or contact
12		Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
13		CA 94129, USA, for further information.
14		*/
15
16
17		/* Number scanner for Ghostscript interpreter */
18		#include "math_.h"
19		#include "ghost.h"
20		#include "ierrors.h"
21		#include "scommon.h"
22		#include "iscan.h"
23		#include "iscannum.h" /* defines interface */
24		#include "scanchar.h"
25		#include "store.h"
26
27		/*
28		* Warning: this file has a "spaghetti" control structure. But since this
29		* code accounts for over 10% of the execution time of some PostScript
30		* files, this is one of the few places we feel this is justified.
31		*/
32
33		/*
34		* Scan a number. If the number consumes the entire string, return 0;
35		* if not, set *psp to the first character beyond the number and return 1.
36		*/
37		int
38		scan_number(const byte * str, const byte * end, int sign,
39		ref * pref, const byte ** psp, int scanner_options)
40	268M	{
41	268M	const byte *sp = str;
42	268M	#define GET_NEXT(cvar, sp, end_action)\
43	1.08G	if (sp >= end) { end_action; } else cvar = *sp++
44
45		/*
46		* Powers of 10 up to 6 can be represented accurately as
47		* a single-precision float.
48		*/
49	268M	#define NUM_POWERS_10 6
50	268M	static const float powers_10[NUM_POWERS_10 + 1] = {
51	268M	1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6
52	268M	};
53	268M	static const double neg_powers_10[NUM_POWERS_10 + 1] = {
54	268M	1e0, 1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6
55	268M	};
56
57	268M	ps_int ival;
58	268M	double dval;
59	268M	int exp10;
60	268M	int code = 0;
61	268M	int c, d;
62	268M	ps_int max_ps_int_scan, min_ps_int_scan;
63	268M	const byte *const decoder = scan_char_decoder;
64	268M	#define IS_DIGIT(d, c)\
65	719M	((d = decoder[c]) < 10)
66	268M	#define WOULD_OVERFLOW(val, d, maxv)\
67	268M	(val >= maxv / 10 && (val > maxv / 10 \|\| d > (int64_t)(maxv % 10)))
68
69	268M	GET_NEXT(c, sp, return_error(gs_error_syntaxerror));
70	268M	if (!IS_DIGIT(d, c)) {
71	53.6M	if (c != '.')
72	8.55k	return_error(gs_error_syntaxerror);
73		/* Might be a number starting with '.'. */
74	53.5M	GET_NEXT(c, sp, return_error(gs_error_syntaxerror));
75	53.5M	if (!IS_DIGIT(d, c))
76	53.5M	return_error(gs_error_syntaxerror);
77	1.83k	ival = 0;
78	1.83k	goto i2r;
79	53.5M	}
80		/* Accumulate an integer in ival. */
81		/* Do up to 4 digits without a loop, */
82		/* since we know this can't overflow and since */
83		/* most numbers have 4 (integer) digits or fewer. */
84	215M	ival = d;
85	215M	if (end - sp >= 3) { /* just check once */
86	210M	if (!IS_DIGIT(d, (c = *sp))) {
87	44.6M	sp++;
88	44.6M	goto ind;
89	44.6M	}
90	165M	ival = ival * 10 + d;
91	165M	if (!IS_DIGIT(d, (c = sp[1]))) {
92	159M	sp += 2;
93	159M	goto ind;
94	159M	}
95	5.75M	ival = ival * 10 + d;
96	5.75M	sp += 3;
97	5.75M	if (!IS_DIGIT(d, (c = sp[-1])))
98	3.21M	goto ind;
99	2.53M	ival = ival * 10 + d;
100	2.53M	}
101
102	7.56M	max_ps_int_scan = scanner_options & SCAN_CPSI_MODE ? MAX_PS_INT32 : MAX_PS_INT;
103	7.56M	min_ps_int_scan = scanner_options & SCAN_CPSI_MODE ? MIN_PS_INT32 : MIN_PS_INT;
104
105	11.5M	for (;; ival = ival * 10 + d) {
106	11.5M	GET_NEXT(c, sp, goto iret);
107	6.16M	if (!IS_DIGIT(d, c))
108	2.18M	break;
109	3.98M	if (WOULD_OVERFLOW(((ps_uint)ival), d, max_ps_int_scan)) {
110	4.83k	if (ival == max_ps_int_scan / 10 && d == (max_ps_int_scan % 10) + 1 && sign < 0) {
111	396	GET_NEXT(c, sp, c = EOFC);
112	396	dval = -(double)min_ps_int_scan;
113	396	if (c == 'e' \|\| c == 'E') {
114	2	exp10 = 0;
115	2	goto fs;
116	394	} else if (c == '.') {
117	9	GET_NEXT(c, sp, c = EOFC);
118	9	exp10 = 0;
119	9	goto fd;
120	385	} else if (!IS_DIGIT(d, c)) {
121	384	ival = min_ps_int_scan;
122	384	break;
123	384	}
124	396	} else
125	4.43k	dval = (double)ival;
126	4.43k	goto l2d;
127	4.83k	}
128	3.98M	}
129	209M	ind: /* We saw a non-digit while accumulating an integer in ival. */
130	209M	switch (c) {
131	1.35M	case '.':
132	1.35M	GET_NEXT(c, sp, c = EOFC);
133	1.35M	goto i2r;
134	52.2M	default:
135	52.2M	*psp = sp;
136	52.2M	code = 1;
137	52.2M	break;
138	7	case EOFC:
139	7	break;
140	2.25k	case 'e':
141	2.77k	case 'E':
142	2.77k	if (sign < 0)
143	371	ival = -ival;
144	2.77k	dval = (double)ival;
145	2.77k	exp10 = 0;
146	2.77k	goto fe;
147	156M	case '#':
148	156M	{
149	156M	const int radix = ival;
150	156M	ps_int uval = 0, imax;
151
152	156M	if (sign \|\| radix < min_radix \|\| radix > max_radix)
153	91	return_error(gs_error_syntaxerror);
154		/* Avoid multiplies for power-of-2 radix. */
155	156M	if (!(radix & (radix - 1))) {
156	156M	int shift;
157
158	156M	switch (radix) {
159	125	case 2:
160	125	shift = 1, imax = MAX_PS_UINT >> 1;
161	125	break;
162	81	case 4:
163	81	shift = 2, imax = MAX_PS_UINT >> 2;
164	81	break;
165	111	case 8:
166	111	shift = 3, imax = MAX_PS_UINT >> 3;
167	111	break;
168	156M	case 16:
169	156M	shift = 4, imax = MAX_PS_UINT >> 4;
170	156M	break;
171	85	case 32:
172	85	shift = 5, imax = MAX_PS_UINT >> 5;
173	85	break;
174	0	default: /* can't happen */
175	0	return_error(gs_error_rangecheck);
176	156M	}
177	741M	for (;; uval = (uval << shift) + d) {
178	741M	GET_NEXT(c, sp, break);
179	663M	d = decoder[c];
180	663M	if (d >= radix) {
181	77.9M	*psp = sp;
182	77.9M	code = 1;
183	77.9M	break;
184	77.9M	}
185	585M	if (uval > imax)
186	2	return_error(gs_error_limitcheck);
187	585M	}
188	156M	} else {
189	596	ps_int irem = MAX_PS_UINT % radix;
190
191	596	imax = MAX_PS_UINT / radix;
192	1.34k	for (;; uval = uval * radix + d) {
193	1.34k	GET_NEXT(c, sp, break);
194	1.05k	d = decoder[c];
195	1.05k	if (d >= radix) {
196	298	*psp = sp;
197	298	code = 1;
198	298	break;
199	298	}
200	755	if (uval >= imax &&
201	755	(uval > imax \|\| d > irem)
202	755	)
203	6	return_error(gs_error_limitcheck);
204	755	}
205	596	}
206	156M	if (scanner_options & SCAN_CPSI_MODE) {
207	0	ps_uint32 int1 = 0;
208	0	int1 \|= (uval & 0xffffffff);
209	0	make_int(pref, (ps_int)((ps_int32)int1));
210	0	}
211	156M	else
212	156M	make_int(pref, uval);
213
214	156M	return code;
215	156M	}
216	209M	}
217	57.6M	iret:
218	57.6M	if (scanner_options & SCAN_CPSI_MODE) {
219	0	make_int(pref, (sign < 0 ? (ps_int32)-ival : (ps_int32)ival));
220	0	}
221	57.6M	else {
222	57.6M	make_int(pref, (sign < 0 ? (ps_int)-ival : (ps_int)ival));
223	57.6M	}
224	57.6M	return code;
225
226		/* Accumulate a double in dval. */
227	4.43k	l2d:
228	4.43k	exp10 = 0;
229	66.0k	for (;;) {
230	66.0k	dval = dval * 10 + d;
231	66.0k	GET_NEXT(c, sp, c = EOFC);
232	66.0k	if (!IS_DIGIT(d, c))
233	4.43k	break;
234	66.0k	}
235	4.43k	switch (c) {
236	467	case '.':
237	467	GET_NEXT(c, sp, c = EOFC);
238	467	exp10 = 0;
239	467	goto fd;
240	3.42k	default:
241	3.42k	*psp = sp;
242	3.42k	code = 1;
243		/* falls through */
244	3.92k	case EOFC:
245	3.92k	if (sign < 0)
246	703	dval = -dval;
247	3.92k	goto rret;
248	26	case 'e':
249	39	case 'E':
250	39	exp10 = 0;
251	39	goto fs;
252	3	case '#':
253	3	return_error(gs_error_syntaxerror);
254	4.43k	}
255
256		/* We saw a '.' while accumulating an integer in ival. */
257	1.36M	i2r:
258	1.36M	exp10 = 0;
259	5.03M	while (IS_DIGIT(d, c) \|\| c == '-') {
260		/*
261		* PostScript gives an error on numbers with a '-' following a '.'
262		* Adobe Acrobat Reader (PDF) apparently doesn't treat this as an
263		* error. Experiments show that the numbers following the '-' are
264		* ignored, so we swallow the fractional part. SCAN_PDF_INV_NUM
265		* enables this compatibility kloodge.
266		*/
267	3.68M	if (c == '-') {
268	15	if ((SCAN_PDF_INV_NUM & scanner_options) == 0)
269	15	break;
270	0	do {
271	0	GET_NEXT(c, sp, c = EOFC);
272	0	} while (IS_DIGIT(d, c));
273	0	break;
274	15	}
275	3.68M	if (WOULD_OVERFLOW(ival, d, max_int)) {
276	2.09k	dval = (double)ival;
277	2.09k	goto fd;
278	2.09k	}
279	3.67M	ival = ival * 10 + d;
280	3.67M	exp10--;
281	3.67M	GET_NEXT(c, sp, c = EOFC);
282	3.67M	}
283	1.35M	if (sign < 0)
284	104k	ival = -ival;
285		/* Take a shortcut for the common case */
286	1.35M	if (!(c == 'e' \|\| c == 'E' \|\| exp10 < -NUM_POWERS_10)) { /* Check for trailing garbage */
287	1.35M	if (c != EOFC)
288	1.15M	*psp = sp, code = 1;
289	1.35M	make_real(pref, ival * neg_powers_10[-exp10]);
290	1.35M	return code;
291	1.35M	}
292	1.91k	dval = (double)ival;
293	1.91k	goto fe;
294
295		/* Now we are accumulating a double in dval. */
296	2.56k	fd:
297	25.2k	while (IS_DIGIT(d, c)) {
298	22.6k	dval = dval * 10 + d;
299	22.6k	exp10--;
300	22.6k	GET_NEXT(c, sp, c = EOFC);
301	22.6k	}
302	2.61k	fs:
303	2.61k	if (sign < 0)
304	989	dval = -dval;
305	7.29k	fe:
306		/* Now dval contains the value, negated if necessary. */
307	7.29k	switch (c) {
308	4.04k	case 'e':
309	4.60k	case 'E':
310	4.60k	{ /* Check for a following exponent. */
311	4.60k	int esign = 0;
312	4.60k	int iexp;
313
314	4.60k	GET_NEXT(c, sp, return_error(gs_error_syntaxerror));
315	4.55k	switch (c) {
316	1.45k	case '-':
317	1.45k	esign = 1;
318		/* fall through */
319	1.52k	case '+':
320	1.52k	GET_NEXT(c, sp, return_error(gs_error_syntaxerror));
321	4.55k	}
322		/* Scan the exponent. We limit it arbitrarily to 999. */
323	4.50k	if (!IS_DIGIT(d, c))
324	283	return_error(gs_error_syntaxerror);
325	4.22k	iexp = d;
326	4.92k	for (;; iexp = iexp * 10 + d) {
327	4.92k	GET_NEXT(c, sp, break);
328	4.30k	if (!IS_DIGIT(d, c)) {
329	3.60k	*psp = sp;
330	3.60k	code = 1;
331	3.60k	break;
332	3.60k	}
333	708	if (iexp > 99)
334	5	return_error(gs_error_limitcheck);
335	708	}
336	4.22k	if (esign)
337	1.44k	exp10 -= iexp;
338	2.78k	else
339	2.78k	exp10 += iexp;
340	4.22k	break;
341	4.22k	}
342	2.46k	default:
343	2.46k	*psp = sp;
344	2.46k	code = 1;
345	2.69k	case EOFC:
346	2.69k	;
347	7.29k	}
348		/* Compute dval * 10^exp10. */
349	6.91k	if (exp10 > 0) {
350	3.47k	while (exp10 > NUM_POWERS_10)
351	943	dval *= powers_10[NUM_POWERS_10],
352	943	exp10 -= NUM_POWERS_10;
353	2.52k	dval *= powers_10[exp10];
354	4.38k	} else if (exp10 < 0) {
355	21.5k	while (exp10 < -NUM_POWERS_10)
356	17.4k	dval /= powers_10[NUM_POWERS_10],
357	17.4k	exp10 += NUM_POWERS_10;
358	4.10k	dval /= powers_10[-exp10];
359	4.10k	}
360		/*
361		* Check for an out-of-range result. Currently we don't check for
362		* absurdly large numbers of digits in the accumulation loops,
363		* but we should.
364		*/
365	6.91k	if (dval >= 0) {
366	5.57k	if (dval > MAX_FLOAT)
367	14	return_error(gs_error_limitcheck);
368	5.57k	} else {
369	1.33k	if (dval < -MAX_FLOAT)
370	3	return_error(gs_error_limitcheck);
371	1.33k	}
372	10.8k	rret:
373	10.8k	make_real(pref, dval);
374	10.8k	return code;
375	6.91k	}