![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to d49a.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / ph|
Return to d49a.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / ph |
1.1 root 1: /* The Plum Hall Validation Suite for C
2: * Unpublished copyright (c) 1986-1991, Chiron Systems Inc and Plum Hall Inc.
3: * VERSION: 4
4: * DATE: 1993-01-01
5: * The "ANSI" mode of this suite corresponds to official ANSI C, X3.159-1989.
6: * As per your license agreement, your distribution is not to be moved or copied outside the Designated Site
7: * without specific permission from Plum Hall Inc.
8: */
9:
10: /*
11: * d49a - formatting tests
12: */
13:
14: #include "flags.h"
15: #ifndef SKIP49
16: #include <stdio.h>
17: #define LIB_TEST 1
18: #include "defs.h"
19: #if ANSI
20: #include <float.h> /* to get DBL_MAX_10_EXP, which non-ANSI machine.h defines */
21: #else
22: #define remove unlink
23: #endif
24: char *save_name();
25:
26: #define T_0 0 /* no data needed */
27: #define T_I1 1 /* int */
28: #define T_I2 2 /* int (negative) */
29: #define T_L1 3 /* long */
30: #define T_SI 4 /* short */
31: #define T_D1 5 /* double */
32: #define T_P 6 /* char * */
33: #define T_S 7 /* string */
34: #define T_STAR1 8 /* width as argument */
35: #define T_STAR2 9 /* precision as argument */
36: #define T_STAR3 10 /* width and precision as arguments */
37: #define T_C1 11 /* character */
38: #define T_C2 12 /* character */
39: #define T_F 13 /* float */
40: #define T_U 14 /* unsigned int */
41: #define T_D2 15 /* very large double */
42: #define T_D3 16 /* double with zero value */
43: #define T_D4 17 /* double with integral value */
44: #define T_D5 18 /* double with exponent < -4 */
45: #define T_D6 19 /* double with exponent == precision */
46: #define T_D7 20 /* double with exponent > precision */
47: #define T_D8 21 /* long double */
48: #define T_SU 22 /* unsigned short */
49: #define T_I0 23 /* integer arg with value of 0 */
50: #define T_STARD 24 /* width and precision as arguments */
51: #define T_STARN 25 /* width and precision with a neg number */
52:
53: static int Ival1 = 77;
54: static int Ival2 = -77;
55: static long Lval1 = 65000;
56: static short Sval = 0x7fff;
57: static unsigned short Suval = 0x7fff;
58: static double Dval1 = 12.3456789;
59: static float Fval = 3.0;
60: static int *Pval = &Ival1;
61: static char *String = "this is a string\n";
62: static char Cval = 'a';
63: static unsigned int Ui = 65000;
64: static double Dval2 = 0.0; /* assigned dynamically below */
65: static double Dval3 = 0.0;
66: static double Dval4 = 1.0;
67: static double Dval5 = 1.23e-6;
68: static double Dval6 = 9.876e+2;
69: static double Dval7 = 9.876e+3;
70: #if ANSI
71: static long double Dval8 = 98.7654L;
72: #endif
73: void fpsteq();
74:
75:
76: static struct output
77: {
78: int type;
79: char *fmt;
80: char *out;
81: int line;
82: } Output[] =
83: {
84: /* %[-+ #][width|*][precision|*][h|l|L][diouxXfeEgGcspn%] */
85:
86: T_0, "", "", __LINE__,
87: T_0, "no format chars", "no format chars", __LINE__,
88: T_I1, "%d", "77", __LINE__,
89: T_I1, "%-3d", "77 ", __LINE__,
90: T_I1, "%+d", "+77", __LINE__,
91: T_I2, "%+d", "-77", __LINE__,
92: T_I2, "%+4d", " -77", __LINE__,
93: T_I1, "% 4d", " 77", __LINE__,
94: T_I2, "% 4d", " -77", __LINE__,
95: T_I1, "% +4d", " +77", __LINE__,
96: T_I1, "%+ 4d", " +77", __LINE__,
97: T_I1, "%+04d", "+077", __LINE__,
98: T_I2, "%04d", "-077", __LINE__,
99: T_I1, "%04.2d", " 77", __LINE__,
100: T_I1, "%.d", "77", __LINE__,
101: T_I1, "%04.d", " 77", __LINE__,
102: T_I0, "%.d", "", __LINE__,
103: T_I1, "%.4d", "0077", __LINE__,
104: T_I1, "%6.4d", " 0077", __LINE__,
105: T_I1, "% 6.4d", " 0077", __LINE__,
106: T_I1, "%06.4d", " 0077", __LINE__,
107: T_I1, "%3d", " 77", __LINE__,
108: T_I1, "%0d", "77", __LINE__,
109: T_I1, "%1d", "77", __LINE__,
110: T_I1, "%-1d", "77", __LINE__,
111: T_I1, "%x", "4d", __LINE__,
112: T_I1, "%#x", "0x4d", __LINE__,
113: T_I1, "%#X", "0X4D", __LINE__,
114: T_I1, "%o", "115", __LINE__,
115: T_I1, "%#o", "0115", __LINE__,
116: T_I1, "%d", "77", __LINE__,
117: T_I1, "%u", "77", __LINE__,
118: T_I1, "%.6d", "000077", __LINE__,
119: T_I1, "%.d", "77", __LINE__,
120: T_I2, "%.6d", "-000077", __LINE__,
121: T_I1, "%.1d", "77", __LINE__,
122: T_I1, "%.6o", "000115", __LINE__,
123: T_I1, "%.d", "77", __LINE__,
124: T_I1, "%4.6d", "000077", __LINE__,
125: T_I1, "%6.4d", " 0077", __LINE__,
126: T_I1, "%-6.4d", "0077 ", __LINE__,
127: T_I1, "%06d", "000077", __LINE__,
128: T_I1, "%-06d", "77 ", __LINE__,
129: T_L1, "%ld", "65000", __LINE__,
130: T_D1, "%f", "12.345679", __LINE__,
131: T_D1, "%6.3f", "12.346", __LINE__,
132: T_D1, "%.0f", "12", __LINE__,
133: T_D2, "%e", "1.234568e+100", __LINE__,
134: T_D2, "%E", "1.234568E+100", __LINE__,
135: T_D2, "%.3e", "1.235e+100", __LINE__,
136: T_D2, "%.10e", "1.2345678900e+100", __LINE__,
137: T_D1, "%e", "1.234568e+01", __LINE__,
138: T_D1, "%+e", "+1.234568e+01", __LINE__,
139: T_D1, "%15.4e", " 1.2346e+01", __LINE__,
140: T_D1, "%E", "1.234568E+01", __LINE__,
141: T_D1, "%.3e", "1.235e+01", __LINE__,
142: T_D1, "%.10e", "1.2345678900e+01", __LINE__,
143: T_D3, "%e", "0.000000e+00", __LINE__,
144: T_D1, "%.0e", "1e+01", __LINE__,
145: T_D1, "%.e", "1e+01", __LINE__,
146: T_D1, "%#.0e", "1.e+01", __LINE__,
147: T_D5, "%.2g", "1.2e-06", __LINE__,
148: T_D6, "%.2g", "9.9e+02", __LINE__,
149: T_D7, "%.2g", "9.9e+03", __LINE__,
150: T_D7, "%.2G", "9.9E+03", __LINE__,
151: T_D4, "%.0g", "1", __LINE__,
152: T_D1, "%.1g", "1e+01", __LINE__,
153: T_D4, "%#.0g", "1.", __LINE__,
154: T_D1, "%.2g", "12", __LINE__,
155: T_D4, "%.2g", "1", __LINE__,
156: T_D4, "%#.4g", "1.000", __LINE__,
157: T_S, "free form input", "free form input", __LINE__,
158: T_S, "%%%s%%d", "%this is a string\n%d",__LINE__,
159: T_S, "%-20s", "this is a string\n ",__LINE__,
160: T_S, "%20s", " this is a string\n",__LINE__,
161: T_S, "%20.6s", " this i", __LINE__,
162: T_S, "%.6s", "this i", __LINE__,
163: T_C1, "%c", "a", __LINE__,
164: T_C1, "%2c", " a", __LINE__,
165: #if ANSI
166: T_STAR1,"%.*d", "000077", __LINE__,
167: T_STAR1,"%*d", " 77", __LINE__,
168: T_STAR1,"%-*d", "77 ", __LINE__,
169: T_STAR2,"%.*d", "77", __LINE__,
170: T_STAR2,"%*d", "77 ", __LINE__,
171: T_STAR3,"%*.*d", " 0077", __LINE__,
172: T_STAR3,"%-*.*d", "0077 ", __LINE__,
173: T_STARN,"%.*e", "1.234568e+01", __LINE__,
174: T_STARD,"%*.*e", " 1.2346e+01", __LINE__,
175: T_I1, "%06.4d", " 0077", __LINE__,
176: T_I1, "%i", "77", __LINE__,
177: T_SI, "%#hx", "0x7fff", __LINE__,
178: T_U, "%u", "65000", __LINE__,
179: T_SU, "%ho", "77777", __LINE__,
180: T_SU, "%hu", "32767", __LINE__,
181: T_SU, "%hx", "7fff", __LINE__,
182: T_L1, "%lo", "176750", __LINE__,
183: T_L1, "%lu", "65000", __LINE__,
184: T_L1, "%lx", "fde8", __LINE__,
185: T_D8, "%Le", "9.876540e+01", __LINE__,
186: T_D8, "%Lf", "98.765400", __LINE__,
187: T_D8, "%Lg", "98.7654", __LINE__,
188: #endif
189: 0, 0, 0, __LINE__,
190: };
191:
192: /*
193: * PRINT - this test the printf, etc. scanf, etc. formatting.
194: * We make the reasonable assumption that the formatting routines
195: * for sprintf are common with those for sprintf, fprintf, etc. and only
196: * test one set.
197: */
198: void print()
199: {
200: #ifndef SKIP_PRINT
201: int i;
202: struct output *po;
203: char buffer[64];
204:
205: Filename = "d49a.c";
206: if (DBL_MAX_10_EXP >= 100)
207: Dval2 = 1.23456789 * dpowu(10., 100);
208:
209: for (po = Output; po->fmt; ++po)
210: {
211: if (po->type == T_D2 && DBL_MAX_10_EXP < 100)
212: {
213: /* See update item #533, Review Board meeting 8/92 */
214: checkthat(__LINE__, 1); /* count one successful test */
215: continue;
216: }
217: switch (po->type)
218: {
219: case T_0: sprintf(buffer, po->fmt); break;
220: case T_U: sprintf(buffer, po->fmt, Ui); break;
221: case T_I0: sprintf(buffer, po->fmt, 0); break;
222: case T_I1: sprintf(buffer, po->fmt, Ival1); break;
223: case T_I2: sprintf(buffer, po->fmt, Ival2); break;
224: case T_L1: sprintf(buffer, po->fmt, Lval1); break;
225: case T_SI: sprintf(buffer, po->fmt, Sval); break;
226: case T_SU: sprintf(buffer, po->fmt, Suval); break;
227: case T_D1: sprintf(buffer, po->fmt, Dval1); break;
228: case T_D2: sprintf(buffer, po->fmt, Dval2); break;
229: case T_D3: sprintf(buffer, po->fmt, Dval3); break;
230: case T_D4: sprintf(buffer, po->fmt, Dval4); break;
231: case T_D5: sprintf(buffer, po->fmt, Dval5); break;
232: case T_D6: sprintf(buffer, po->fmt, Dval6); break;
233: case T_D7: sprintf(buffer, po->fmt, Dval7); break;
234: #if ANSI
235: case T_D8: sprintf(buffer, po->fmt, Dval8); break;
236: #endif
237: case T_P: sprintf(buffer, po->fmt, Pval); break;
238: case T_S: sprintf(buffer, po->fmt, String); break;
239: case T_STAR1: sprintf(buffer, po->fmt, 6, Ival1); break;
240: case T_STAR2: sprintf(buffer, po->fmt, -6, Ival1); break;
241: case T_STAR3: sprintf(buffer, po->fmt, 6, 4, Ival1); break;
242: case T_STARD: sprintf(buffer, po->fmt, 15, 4, Dval1); break;
243: case T_STARN: sprintf(buffer, po->fmt, -4, Dval1); break;
244: case T_C1: sprintf(buffer, po->fmt, Cval); break;
245: }
246:
247: switch (po->type)
248: {
249: case T_D1:
250: case T_D2:
251: case T_D3:
252: case T_D4:
253: case T_D5:
254: case T_D6:
255: case T_D7:
256: case T_D8:
257: case T_STARD:
258: case T_STARN:
259: fpsteq(po->line, buffer, po->out);
260: break;
261: default:
262: stequals(po->line, buffer, po->out);
263: }
264: }
265:
266: #if ANSI
267: {
268: char *buffer_p;
269: int t1; short t2; long t3;
270: /* some special cases not covered above */
271:
272: buffer[0] = 0;
273: sprintf(buffer, "%p", buffer);
274: /* implementation defined format, but it should have written something */
275: inotequals(__LINE__, buffer[0], 0);
276: sscanf(buffer, "%p", &buffer_p);
277: aequals(__LINE__, buffer, buffer_p);
278:
279: #if ANSI8712 /* added h and l modifiers to n */
280: /* %.0d of 0 produces no characters */
281: sprintf(buffer, "%.0d", 0);
282: stequals(__LINE__, buffer, "");
283: #endif
284:
285: #if ANSI8703 /* added h and l modifiers to n */
286: sprintf(buffer, "%nabc%hn%d%ln", &t1, &t2, 123, &t3);
287: stequals(__LINE__, buffer, "abc123");
288: iequals(__LINE__, t1, 0);
289: iequals(__LINE__, t2, 3);
290: lequals(__LINE__, t3, 6L);
291: #endif /* ANSI8703 */
292: }
293: #endif
294: #endif /* SKIP_PRINT */
295: }
296:
297:
298:
299:
300: static struct input
301: {
302: int type;
303: char *fmt;
304: char *in;
305: int line;
306: } Input[] =
307: {
308: T_I1, "%d", "77", __LINE__,
309: T_I1, "%d", " 77", __LINE__,
310: #if ANSI
311: T_I1, "%d", "+77", __LINE__,
312: T_SI, "%hd", "32767", __LINE__,
313: #endif
314: T_I2, "%d", "-77", __LINE__,
315: T_I1, "abc%d", "abc77", __LINE__,
316: T_L1, "%ld", "65000", __LINE__,
317: #if ANSI
318: T_I1, "%i", "77", __LINE__,
319: T_I1, "%i", "+77", __LINE__,
320: T_I2, "%i", "-77", __LINE__,
321: T_I1, "%i", "0115", __LINE__,
322: T_I1, "%i", "0x4d", __LINE__,
323: T_I1, "%i", "0X4d", __LINE__,
324: T_SI, "%hi", "0x7fff", __LINE__,
325: T_SU, "%ho", "077777", __LINE__,
326: T_SU, "%hu", "32767", __LINE__,
327: T_SU, "%hx", "7fff", __LINE__,
328: T_L1, "%lo", "0176750", __LINE__,
329: T_L1, "%lu", "65000", __LINE__,
330: T_L1, "%lx", "fde8", __LINE__,
331: #endif
332: T_I1, "%o", "0115", __LINE__,
333: T_I1, "%u", "77", __LINE__,
334: T_I1, "%x", "4d", __LINE__,
335: T_I1, "%x", "4D", __LINE__,
336: T_I1, "%X", "4d", __LINE__,
337: T_I1, "%X", "4D", __LINE__,
338: T_S, "%s", " this is", __LINE__,
339: T_C1, "%c", "athis is", __LINE__,
340: T_C2, "%c", " this is", __LINE__,
341: T_F, "%f", "3.", __LINE__,
342: T_F, "%e", "3.", __LINE__,
343: T_F, "%f", ".3e+01", __LINE__,
344: T_F, "%e", ".3e+01", __LINE__,
345: T_F, "%f", "3.0", __LINE__,
346: T_F, "%g", "3.0", __LINE__,
347: T_D1, "%le", "12.3456789", __LINE__,
348: T_D1, "%lf", "12.3456789", __LINE__,
349: T_D1, "%lg", "1.23456789e+01", __LINE__,
350: #if ANSI
351: T_F, "%E", ".3e+01", __LINE__,
352: T_F, "%G", "3.0", __LINE__,
353: T_D8, "%Le", "98.7654", __LINE__,
354: T_D8, "%Lf", "98.7654", __LINE__,
355: T_D8, "%Lg", "9.87654e+01", __LINE__,
356: #endif
357: 0, (char *)0, (char *)0, __LINE__,
358: };
359:
360:
361:
362: /*
363: * SCAN - this test the scanf, etc. scanf, etc. number cracking.
364: * We make the reasonable assumption that the scanning routines
365: * for sscanf are common with those for scanf, fscanf, etc. and only
366: * test one set.
367: */
368: void scan()
369: {
370: #ifndef SKIP_SCAN
371: int i, n;
372: struct input *pi;
373: char buffer[64];
374: char ctmp;
375: short stmp;
376: unsigned short sutmp;
377: int itmp;
378: long ltmp;
379: double dtmp;
380: #if ANSI
381: long double ldtmp;
382: #endif
383: float ftmp;
384: int *ptmp;
385: char *p = buffer;
386: char *q = 0;
387:
388: Filename = "d49a.c";
389:
390: for (pi = Input; pi->fmt; ++pi)
391: {
392: switch (pi->type)
393: {
394: case T_I1 :
395: sscanf(pi->in, pi->fmt, &itmp);
396: iequals(pi->line, itmp, Ival1);
397: itmp = 0;
398: break;
399: case T_SI :
400: sscanf(pi->in, pi->fmt, &stmp);
401: iequals(pi->line, stmp, Sval);
402: stmp = 0;
403: break;
404: case T_SU :
405: sscanf(pi->in, pi->fmt, &sutmp);
406: iequals(pi->line, sutmp, Suval);
407: sutmp = 0;
408: break;
409: case T_L1 :
410: sscanf(pi->in, pi->fmt, <mp);
411: lequals(pi->line, ltmp, Lval1);
412: ltmp = 0;
413: break;
414: case T_D1 :
415: sscanf(pi->in, pi->fmt, &dtmp);
416: dequals(pi->line, dtmp, Dval1);
417: dtmp = 0;
418: break;
419: #if ANSI
420: case T_D8 :
421: sscanf(pi->in, pi->fmt, &ldtmp);
422: ldequals(pi->line, ldtmp, Dval8);
423: ldtmp = 0;
424: break;
425: #endif
426: case T_F :
427: sscanf(pi->in, pi->fmt, &ftmp);
428: dequals(pi->line, ftmp, Fval);
429: ftmp = 0;
430: break;
431: case T_S :
432: sscanf(pi->in, pi->fmt, buffer);
433: stequals(pi->line, buffer, "this");
434: buffer[0] = 0;
435: break;
436: case T_C1 :
437: sscanf(pi->in, pi->fmt, &ctmp);
438: iequals(pi->line, ctmp, 'a');
439: ctmp = 0;
440: break;
441: case T_C2 :
442: sscanf(pi->in, pi->fmt, &ctmp);
443: iequals(pi->line, ctmp, ' ');
444: ctmp = 0;
445: break;
446: }
447: }
448:
449: /* special cases */
450:
451: /* if a directive fails, no more input is consumed */
452: {
453: char filename[256];
454: FILE *fd;
455: int tmp1 = 0;
456: int tmp2 = 0;
457: char c = 0;
458:
459: save_name(tmpnam(filename));
460: fd = fopen(filename, "w+");
461: fprintf(fd, "xxx 17 yyy 18");
462: rewind(fd);
463: fscanf(fd, "xxx %d zzz %d", &tmp1, &tmp2);
464: iequals(__LINE__, tmp1, 17);
465: iequals(__LINE__, tmp2, 0);
466: fscanf(fd, "yyy %d", &tmp2);
467: iequals(__LINE__, tmp2, 18);
468: fscanf(fd, "%c", &c);
469: iequals(__LINE__, c, 0);
470:
471: fclose(fd);
472: remove(filename);
473: }
474:
475: #if ANSI
476: /* skip white space unless %c, %n, or %[ ] */
477: sscanf(" \f\n\r\t\v10", "%d", &Ival1);
478: iequals(__LINE__, Ival1, 10);
479: sscanf(" \f\n\r\t\vA", "%c%c%c%c%c%c%c", p+0, p+1, p+2, p+3, p+4, p+5, p+6);
480: iequals(__LINE__, p[0], ' ');
481: iequals(__LINE__, p[1], '\f');
482: iequals(__LINE__, p[2], '\n');
483: iequals(__LINE__, p[3], '\r');
484: iequals(__LINE__, p[4], '\t');
485: iequals(__LINE__, p[5], '\v');
486: iequals(__LINE__, p[6], 'A');
487:
488: sscanf("xxx yyy", "xxx%n%c", &Ival1, &Cval);
489: iequals(__LINE__, Ival1, 3);
490: iequals(__LINE__, Cval, ' ');
491:
492: p = " \f\n\r\t\vXXX";
493: sscanf(p, "%s", buffer);
494: stequals(__LINE__, buffer, "XXX");
495: sscanf(p, "%[ \f\n\r\t\v]", buffer);
496: stequals(__LINE__, buffer, " \f\n\r\t\v");
497:
498: /* assignment supression */
499: Ival1 = 1;
500: Ival2 = 2;
501: sscanf("77 78", "%*d%d", &Ival1, &Ival2);
502: iequals(__LINE__, Ival1, 78);
503: iequals(__LINE__, Ival2, 2);
504:
505: /* field widths */
506: sscanf("123456", "%3d%d", &Ival1, &Ival2);
507: iequals(__LINE__, Ival1, 123);
508: iequals(__LINE__, Ival2, 456);
509: str_cpye(buffer+30, "XXXXXXX");
510: sscanf("123456789", "%3d%3s%2c", &Ival2, buffer, buffer+30);
511: iequals(__LINE__, Ival2, 123);
512: stequals(__LINE__, buffer, "456");
513: iequals(__LINE__, buffer[30], '7');
514: iequals(__LINE__, buffer[31], '8');
515: iequals(__LINE__, buffer[32], 'X');
516: sscanf("abcabcabc", "%4[abc]", buffer);
517: stequals(__LINE__, buffer, "abca");
518: sscanf("xyzxyzxyz", "%4[^abc]", buffer);
519: stequals(__LINE__, buffer, "xyzx");
520:
521: /* conversion count */
522: sscanf("123 5", "%d%n", &i, &n);
523: iequals(__LINE__, i, 123);
524: iequals(__LINE__, n, 3);
525:
526: sscanf("123 5", "%d%hn", &i, &stmp);
527: iequals(__LINE__, i, 123);
528: iequals(__LINE__, stmp, 3);
529:
530: sscanf("123 5", "%d%ln", &i, <mp);
531: iequals(__LINE__, i, 123);
532: lequals(__LINE__, ltmp, 3L);
533:
534: /* '%%' is an escape for '%' */
535: str_cpye(buffer, "xxxxxx");
536: sscanf("%%aaa", "%%%%%s", buffer);
537: stequals(__LINE__, buffer, "aaa");
538:
539: /* scan sets */
540: sscanf("ddccbbaaxxxxx", "%[abcd]", buffer);
541: stequals(__LINE__, buffer, "ddccbbaa");
542:
543: sscanf("xxyyzzaabbccdd", "%[^abcd]", buffer);
544: stequals(__LINE__, buffer, "xxyyzz");
545:
546: sscanf("dd]cc]bb]aaxxxxx", "%[]abcd]", buffer);
547: stequals(__LINE__, buffer, "dd]cc]bb]aa");
548:
549: sscanf("xxyyzz]aabbccdd", "%[^]abcd]", buffer);
550: stequals(__LINE__, buffer, "xxyyzz");
551:
552: /* exceptional behaviour of '-' is implementation defined */
553: sscanf("-", "%[a-z]", buffer);
554: stequals(- __LINE__, buffer, "-");
555:
556: /* %p should be idempotent */
557: sprintf(buffer, "%p", p);
558: sscanf(buffer, "%p", &q);
559: aequals(__LINE__, p, q);
560: #endif
561: #endif /* SKIP_SCAN */
562: }
563:
564: #define IS_SPACE(c) ((c) == ' ') /* Standard only allows space padding */
565: /*
566: * fpsteq - When checking floating point output, the standard requires
567: * a minimum of 2 digits for the exponent. More is OK, so this routine
568: * checks for conformance without being sensitive to the exact number
569: * of digits. When we know that the string is wrong, we call
570: * stequals to create a meaningful error message. Also, compensate
571: * for differing number of white space in filling up the field width.
572: */
573: void fpsteq(line, pval, pres)
574: int line;
575: char *pval;
576: char *pres;
577: {
578: char result[32], value[32];
579: int len;
580: char *p, *q;
581:
582: /* check for field width (only on leading space) */
583: if (IS_SPACE(*pval) && str_len(pres) != str_len(pval))
584: {
585: /* this will fail */
586: stequals(line, pval, pres);
587: return;
588: }
589:
590: /* get rid of leading whitespace */
591: while (IS_SPACE(*pval))
592: ++pval;
593: while (IS_SPACE(*pres))
594: ++pres;
595: if (str_str(pres, "E+") || str_str(pres, "E-") ||
596: str_str(pres, "e+") || str_str(pres, "e-"))
597: {
598: len = str_cspn(pres, "Ee");
599: if (len != str_cspn(pval, "Ee"))
600: {
601: /* this will fail */
602: stequals(line, pval, pres);
603: return;
604: }
605: st_ncpy(result, pres, len);
606: result[len] = 0;
607: st_ncpy(value, pval, len);
608: value[len] = 0;
609: if (str_cmp(result, value))
610: {
611: /* this will fail */
612: stequals(line, pval, pres);
613: }
614: else /* OK so far, result matches value */
615: {
616: /* does pval have at least 2 digits of exponent? */
617: p = pval + len + 2;
618: if (str_len(p) < 2)
619: {
620: /* this will fail */
621: stequals(line, pval, pres);
622: }
623: else /* OK so far, exponent >= 2 digits */
624: {
625: while (*p == '0')
626: ++p;
627: q = pres + len + 2;
628: while (*q == '0')
629: ++q;
630: if (str_cmp(p, q))
631: {
632: /* this will fail */
633: stequals(line, pval, pres);
634: }
635: else /* complete success, exponents match numerically */
636: stequals(line, pval, pval); /* just to get trace */
637: }
638: }
639: }
640: else /* no exponent in output format */
641: stequals(line, pval, pres);
642: }
643:
644: #endif /* !SKIP49 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.