开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
fioLib.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：82k
源码类别：

VxWorks

开发平台：

C/C++

fioLib.c：源码内容
  1. /* fioLib.c - formatted I/O library */
  3. /* Copyright 1984-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 06c,24jul02,tpr  Remove sarcastic comment of fioFormatV.
  10. 06b,14mar02,pfl  changed long long arg support to use 'll' format
  11. 06a,21dec01,an   enabled long long arg support for printf/scanf using 'L' format flag 
  12. 05z,17dec01,max  Simple change just to make WRS doctool happy
  13. 05y,20jun01,kab  Code review cleanup
  14. 05x,19apr01,max  printf & scanf support for ALTIVEC vector data types
  15. 05w,14jun99,pai  removed blocking call to printErr() in printExc() (SPR 22735).
  16. 05v,14mar99,jdi  doc: removed refs to config.h and/or configAll.h (SPR 25663).
  17. 05v,05sep97,dgp  doc: fix SPR 9258, remove NOTE from sprintf()
  18. 05u,04oct95,kvk  fix for PPC architecture varargs float problem.
  19. 05t,21sep95,jdi  doc tweak of man page for fioLibInit().
  20. 05s,14may95,p_m  added fioLibInit().
  21. 05r,03feb95,jdi  doc format tweaks.
  22. 05q,24jan95,rhp  doc: avoid 'L' in printf() and sscanf(), no long doubles 
  23.                  in VxWorks (see SPR#3886)
  24. 05p,13jan95,rhp  make self-refs in sscanf man page refer to sscanf, not fscanf
  25. 05o,12jan95,rhp  fix RETURNS section of fioRdString() man page (SPR#2511)
  26. 05n,21nov94,kdl  made scanCharSet() NOMANUAL.
  27. 05m,19jul94,dvs  doc tweak - added stdio.h to list of include files (SPR #2391).
  28. 05l,02dec93,pad  temporary fixed fioFormatV() to avoid a cc29k problem.
  29. 05k,17aug94,ism  fixed problem with assignment suppression (SPR#2562)
  30. -fixed problem with [] not failing when no characters are scanned
  31. -(SPR#3561)
  32. 05j,21oct93,jmm  fixed return value for scanCharSet
  33. 05i,10mar93,jdi  more documentation cleanup for 5.1.
  34. 05h,22jan93,jdi  documentation cleanup for 5.1.
  35. 05g,13nov92,dnw  added include of taskLib.h
  36. 05f,29oct92,jcf  bumped BUF to 400 to format real big numbers.
  37. 05e,01oct92,jcf  fixed printExc().
  38. 05d,02aug92,jcf  moved printExc() to here.
  39. 05c,30jul92,kdl  prevent printing leading zeroes for "Inf", "Nan".
  40. 05b,30jul92,jcf  redone for the new stdio library.
  41.            +smb
  42. 05a,26may92,rrr  the tree shuffle
  43. 04z,10feb92,kdl  fixed scanf %n problems (SPR 1172).
  44. 04y,29jan92,kdl  made fioRdString return EOF in case of read error (SPR 1142);
  45.  changed copyright date.
  46. 04x,10dec91,gae  removed some ANSI warnings.
  47. 04w,04dec91,rrr  removed VARARG_OK, no longer needed with ansi c.
  48. 04v,19nov91,rrr  shut up some ansi warnings.
  49. 04u,04oct91,rrr  passed through the ansification filter
  50.                   -changed functions to ansi style
  51.   -changed includes to have absolute path from h/
  52.   -changed VOID to void
  53.   -changed copyright notice
  54. 04t,14jul91,del  removed va_end in fioScanV.
  55. 04s,09jun91,del  integrated Intel's mods to interface to floatLib.c.
  56. 04r,18may91,gae  fixed sscanf/varargs for 960.
  57.  redid conditionals with VARARG_OK.
  58. 04q,05may91,jdi  documentation tweak.
  59. 04p,05apr91,jdi  documentation -- removed header parens and x-ref numbers;
  60.  doc review by dnw.
  61. 04o,24mar91,del  made functions work with gnu960 tools for I960 architecture.
  62. 04n,06feb91,jaa  documentation cleanup.
  63. 04m,05oct90,dnw  documentation
  64. 04l,18sep90,kdl  removed forward declarations for digtobin and fioToUpper.
  65. 04k,08aug90,dnw  changed to call floatFormat with &vaList instead of vaList.
  66.  changed to call floatFormat with sizeof(buffer)-prefix instead
  67.    of sizeof(buffer)
  68. 04j,04jun90,dnw  extensive rewrite/reorg of printf/scanf family of rtns:
  69.    - consolidation and clean-up,
  70.    - adherence to ANSI definitions for format semantics,
  71.    - use varargs correctly,
  72.    - removed all floating pt refs.
  73.  BUG FIXES:
  74.    spr 501: fixed printf precision bug
  75.    spr 640: printf, fdprintf, printErr return num chars printed
  76.    spr 754: vararg routines no longer limited to 16 args
  77.    spr 766: deleted obsolete fioStd{In,Out,Err} routines
  78.    spr 767: scanf, sscanf, fscanf return EOF properly
  79.    unreported: printf with both "left justify" & "0 fill" flags
  80.    would 0 fill to the right! ("5000" instead of "5   ")
  81.  ANSI STANDARD CHANGES, *NOT* COMPATIBLE WITH 4.0.2:
  82.    - scanf %EFG now same as %efg (no longer means "double"!)
  83.    - sprintf returns number of chars in buffer NOT INCLUDING
  84.        EOS (4.0.2 included EOS in count)
  85.    - printf precision parameter only has effect on %s and %efg
  86.  ANSI STANDARD CHANGES, BACKWARD COMPATIBLE:
  87.    - added vprintf, vfprintf, vsprintf vararg routines
  88.    - printf now supports %i %p %n
  89.    - scanf now supports %i %p %n %% %X
  90.    - scanf now allows optional leading "0x"
  91.  OTHER CHANGES:
  92.    - deleted unused internal routines fioToUpper() & digtobin()
  93.    - fioRead() doesn't set S_fioLib_UNEXPECTED_EOF anymore
  94.    - changes to allow void be defined as void
  95. 04i,07mar90,jdi  documentation cleanup.
  96. 04h,09aug89,gae  did varargs stuff right.
  97.     06jul89,ecs  updated to track 4.0.2.
  98.     07sep88,ecs  varargs.
  99.  added include of varargs.h.
  100. 04g,19aug88,gae  documentation.
  101. 04f,13aug88,gae  fixed bug in convert() for E and F.
  102. 04e,30jun88,gae  fixed bug in sscanf () and convert() for number specifier.
  103. 04d,30may88,dnw  changed to v4 names.
  104. 04c,28may88,dnw  removed NOT_GENERIC stuff.
  105.  removed obsolete rtns: bcdtoi,itobcd,atoi,atow,atos,bprintf
  106.  removed obsolete: fioSet{In,Out,Err},
  107.  removed skipHexSpecifier to bootConfig.
  108.  removed skipSpace to bootConfig and bootLib.
  109.  made itob NOMANUAL.
  110.  made digtobin LOCAL.
  111. 04b,21apr88,gae  added conversion of 'g' for scanf().
  112. 04a,02apr88,gae  rewrote convert and support routines to work with stdio.
  113.  changed fprintf() to fdprintf().
  114.  changed fio{Std,Set}{In,Out,Err}() to use new 0,1,2 I/O scheme.
  115.  made putbuf() local.
  116. 03i,16mar88,gae  fixed bug in convert() to return FALSE for invalid specifier.
  117.          fixed fatal bug in atos() of not handling unterminated table.
  118.  made atos() return ERROR when given invalid table.
  119.  sscanf can now do flag:       "<*>".
  120.  sscanf can now do specifiers: "E|F|c|u|o".
  121.  printf can now do flags:      "<+><sp><#>".
  122.  printf can now do specifiers: "u|E|G|X".
  123.  added nindex() and fioToUpper().
  124. 03h,16feb88,llk  fixed sscanf so that it handles double precision floats.
  125. 03g,10dec87,gae  changed some VARARGS routines to have standard "args"
  126.    parameter for parsing by C interface generator.
  127. 03f,16nov87,jcf  added skipHexSpecifier to aid in hex parsing
  128. 03e,05nov87,jlf  documentation
  129. 03d,12oct87,jlf  added [...] strings to scanf.
  130. 03c,01aug87,gae  moved floating-point support to fltLib.c.
  131.  added fioFltInstall().
  132. 03b,31jul87,gae  replaced homebrew atof() with the real thing.
  133.  renamed gcvtb() to gcvt().  fixed bug in ftob().
  134. 03a,07may87,jlf  added floating point support, with #ifdef's.
  135.    +gae  This involved: %e and %f to format() and convert().
  136.  New routines: ecvtb, fcvtb, gcvt, atof, atoe, ftob, etob,
  137.  frexp, ldexp, and modf.
  138. 02x,04apr87,dnw  fixed bug in format() that limited fields to 128 characters.
  139. 02w,23mar87,jlf  documentation.
  140. 02v,17jan87,gae  made timeConvert and format handle 12 hour clock time code.
  141. 02u,20dec86,dnw  changed to not get include files from default directories.
  142. 02t,10oct86,dnw  documentation.
  143. 02s,04sep86,jlf  documentation.
  144. 02r,29jul86,llk  documentation changes
  145. 02q,27jul86,llk  added standard error file descriptor (std_err)
  146.  added fioSetErr, fioStdErr, printErr
  147. 02p,01jul86,jlf  minor documentation
  148. 02o,27mar86,ecs  changed timeConvert to check for legality of time entered.
  149.  changed timeDecode to return integer rather than bcd.
  150. 02n,11mar86,jlf  changed GENERIC stuff to NOT_GENERIC.
  151. */
  153. /*
  154. DESCRIPTION
  155. This library provides the basic formatting and scanning I/O functions.  It
  156. includes some routines from the ANSI-compliant printf()/scanf()
  157. family of routines.  It also includes several utility routines.
  159. If the floating-point format specifications `e', `E', `f', `g', and `G' are
  160. to be used with these routines, the routine floatInit() must be called
  161. first.  If the configuration macro INCLUDE_FLOATING_POINT is defined,
  162. floatInit() is called by the root task, usrRoot(), in usrConfig.c.
  164. These routines do not use the buffered I/O facilities provided by the
  165. standard I/O facility.  Thus, they can be invoked even if the standard I/O
  166. package has not been included.  This includes printf(), which in most UNIX
  167. systems is part of the buffered standard I/O facilities.  Because printf()
  168. is so commonly used, it has been implemented as an unbuffered I/O function.
  169. This allows minimal formatted I/O to be achieved without the overhead of
  170. the entire standard I/O package.  For more information, see the manual
  171. entry for ansiStdio.
  173. INCLUDE FILES: fioLib.h, stdio.h
  175. SEE ALSO: ansiStdio, floatLib,
  176. .pG "I/O System"
  177. */
  179. #include "vxWorks.h"
  180. #include "ctype.h"
  181. #include "errno.h"
  182. #include "ioLib.h"
  183. #include "string.h"
  184. #include "stdarg.h"
  185. #include "limits.h"
  186. #include "stdio.h"
  187. #include "stdlib.h"
  188. #include "unistd.h"
  189. #include "fioLib.h"
  190. #include "intLib.h"
  191. #include "sysLib.h"
  192. #include "qLib.h"
  193. #include "taskLib.h"
  194. #include "private/kernelLibP.h"
  195. #include "private/vmLibP.h"
  196. #include "private/floatioP.h"
  198. /* Macros for converting digits to letters and vice versa */
  200. #define BUF 400 /* buffer for %dfg etc */
  201. #define PADSIZE 16 /* pad chunk size */
  203. #define to_digit(c) ((c) - '0')
  204. #define is_digit(c) ((unsigned)to_digit(c) <= 9)
  205. #define to_char(n) ((n) + '0')
  207. #define PAD(howmany, with) 
  208.     { 
  209.     if ((n = (howmany)) > 0) 
  210. { 
  211. while (n > PADSIZE)
  212.     {
  213.     if ((*outRoutine) (with, PADSIZE, outarg) != OK)
  214. return (ERROR);
  215.     n -= PADSIZE; 
  216.     }
  217. if ((*outRoutine) (with, n, outarg) != OK)
  218.     return (ERROR);
  219. }
  220.     }
  222. /* to extend shorts, signed and unsigned arg extraction methods are needed */
  223. #define SARG() ((doLongLongInt) ? (long long) va_arg(vaList, long long) : 
  224.  (doLongInt) ? (long long)(long)va_arg(vaList, long) : 
  225.  (doShortInt) ? (long long)(short)va_arg(vaList, int) : 
  226.  (long long)(int) va_arg(vaList, int))
  228. #define UARG() ((doLongLongInt) ? (unsigned long long) va_arg(vaList, unsigned long long) : 
  229.  (doLongInt) ? (unsigned long long)(ulong_t)va_arg(vaList,ulong_t):
  230.  (doShortInt) ? (unsigned long long)(ushort_t)va_arg(vaList,int):
  231.  (unsigned long long)(uint_t) va_arg(vaList, uint_t))
  234. #define GET_CHAR(ch, ix)        ((ix)++, (ch) = (* getRtn) (getArg, -1))
  236. #define ll  1 /* long long format */ 
  238. /* globals */
  240. /* The fieldSzIncludeSign indicates whether the sign should be included
  241.  * in the precision of a number.
  242.  */
  244. BOOL fieldSzIncludeSign = TRUE;
  247. /* locals */
  249. LOCAL FUNCPTR fioFltFormatRtn;
  250. LOCAL FUNCPTR fioFltScanRtn;
  252. /* Choose PADSIZE to trade efficiency vs size.  If larger printf fields occur
  253.  * frequently, increase PADSIZE (and make the initialisers below longer).
  254.  */
  256. LOCAL char blanks[PADSIZE] =
  257.     {
  258.     ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '
  259.     };
  261. LOCAL char zeroes[PADSIZE] =
  262.     {
  263.     '0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'
  264.     };
  267. /* forwards */
  269. LOCAL int    getbuf (char ** str);
  270. LOCAL STATUS putbuf (char *inbuf, int length, char ** outptr);
  271. LOCAL STATUS printbuf (char *buf, int nbytes, int fd);
  273. /*LOCAL*/ BOOL scanField (const char **ppFmt, void *pReturn, FUNCPTR getRtn, 
  274.       int getArg, BOOL *pSuppress, int *pCh, int *pNchars);
  275. LOCAL BOOL scanChar (char *pResult, int fieldwidth, FUNCPTR getRtn, 
  276.      int getArg, int *pCh, int *pNchars);
  277. LOCAL BOOL scanString (char *pResult, int fieldwidth, FUNCPTR getRtn, 
  278.        int getArg, int *pCh, int *pNchars);
  279. /*LOCAL*/ BOOL scanCharSet (char *pResult, int fieldwidth, 
  280. const char *charsAllowed, FUNCPTR getRtn, 
  281. int getArg, int *pCh, int *pNchars);
  282. LOCAL BOOL scanNum (int base, void *pReturn, int returnSpec, int fieldwidth,
  283.     FUNCPTR getRtn, int getArg, int *pCh, int *pNchars);
  285. /*******************************************************************************
  286. *
  287. * fioLibInit - initialize the formatted I/O support library
  288. *
  289. * This routine initializes the formatted I/O support library.  It should be
  290. * called once in usrRoot() when formatted I/O functions such as printf() and
  291. * scanf() are used.
  292. *
  293. * RETURNS: N/A
  294. */
  296. void fioLibInit (void)
  298.     {
  299.     _func_printErr = (FUNCPTR) printErr;
  300.     }
  302. /*******************************************************************************
  303. *
  304. * fioFltInstall - install routines to print and scan floating-point numbers
  305. *
  306. * This routine is a hook for floatLib to install its special floating-point
  307. * formatting & scanning routines.  It should only be called by floatInit().
  308. *
  309. * NOMANUAL
  310. */
  312. void fioFltInstall
  313.     (
  314.     FUNCPTR formatRtn,          /* routine to format floats for output */
  315.     FUNCPTR scanRtn             /* routine to scan input for floats */
  316.     )
  317.     {
  318.     fioFltFormatRtn = formatRtn;
  319.     fioFltScanRtn   = scanRtn;
  320.     }
  322. /*******************************************************************************
  323. *
  324. * printf - write a formatted string to the standard output stream (ANSI)
  325. *
  326. * This routine writes output to standard output under control of the string
  327. * <fmt>. The string <fmt> contains ordinary characters, which are written
  328. * unchanged, plus conversion specifications, which cause the arguments that
  329. * follow <fmt> to be converted and printed as part of the formatted string.
  330. *
  331. * The number of arguments for the format is arbitrary, but they must
  332. * correspond to the conversion specifications in <fmt>.  If there are
  333. * insufficient arguments, the behavior is undefined.  If the format is
  334. * exhausted while arguments remain, the excess arguments are evaluated but
  335. * otherwise ignored.  The routine returns when the end of the format string
  336. * is encountered.
  337. *
  338. * The format is a multibyte character sequence, beginning and ending in its
  339. * initial shift state.  The format is composed of zero or more directives:
  340. * ordinary multibyte characters (not `%') that are copied unchanged to the
  341. * output stream; and conversion specification, each of which results in
  342. * fetching zero or more subsequent arguments.  Each conversion specification
  343. * is introduced by the `%' character.  After the `%', the following appear in
  344. * sequence:
  345. * .iP "" 4
  346. * Zero or more flags (in any order) that modify the meaning of the 
  347. * conversion specification.
  348. * .iP
  349. * An optional minimum field width.  If the converted value has fewer
  350. * characters than the field width, it will be padded with spaces (by
  351. * default) on the left (or right, if the left adjustment flag, 
  352. * described later, has been given) to the field width. The field
  353. * width takes the form of an asterisk (`*') (described later) or a decimal
  354. * integer.
  355. * .iP
  356. * An optional precision that gives the minimum number of digits to
  357. * appear for the `d', `i', `o', `u', `x', and `X' conversions, the number of 
  358. * digits to appear after the decimal-point character for `e', `E', and `f'
  359. * conversions, the maximum number of significant digits for the `g' and
  360. * `G' conversions, or the maximum number of characters to be written 
  361. * from a string in the `s' conversion.  The precision takes the form of a 
  362. * period (`.') followed either by an asterisk (`*') (described later) or by
  363. * an optional decimal integer; if only the period is specified, the 
  364. * precision is taken as zero.  If a precision appears with any other
  365. * conversion specifier, the behavior is undefined.
  366. * .iP
  367. * An optional `h' specifying that a following `d', `i', `o', `u', `x', and
  368. * `X' conversion specifier applies to a `short int' or `unsigned short int'
  369. * argument (the argument will have been promoted according to the integral
  370. * promotions, and its value converted to `short int' or `unsigned short int'
  371. * before printing); an optional `h' specifying that a following `n' 
  372. * conversion specifier applies to a pointer to a `short int' argument.  An
  373. * optional `l' (ell) specifying that a following `d', `i', `o', `u', `x', and
  374. * `X' conversion specifier applies to a `long int' or `unsigned long int'
  375. * argument; or an optional `l' specifying that a following `n' conversion
  376. * specifier applies to a pointer to a `long int' argument.  An optional `ll' 
  377. * (ell-ell) specifying that a following `d', `i', `o', `u', `x', and
  378. * `X' conversion specifier applies to a `long long int' or `unsigned long 
  379. * long int' argument; or an optional `ll' specifying that a following `n' 
  380. * conversion specifier applies to a pointer to a `long long int' argument.  
  381. * If a `h', `l' or `ll' appears with any other conversion specifier, the 
  382. * behavior is undefined.
  383. * .iP
  384. * &WARNING: ANSI C also specifies an optional `L' in some of the same
  385. * contexts as `l' above, corresponding to a `long double' argument.
  386. * However, the current release of the VxWorks libraries does not support 
  387. * `long double' data; using the optional `L' gives unpredictable results.
  388. * .iP
  389. * A character that specifies the type of conversion to be applied.
  390. * .LP
  391. *
  392. * As noted above, a field width, or precision, or both, can be indicated by
  393. * an asterisk (`*').  In this case, an `int' argument supplies the field width
  394. * or precision.  The arguments specifying field width, or precision, or both,
  395. * should appear (in that order) before the argument (if any) to be converted.
  396. * A negative field width argument is taken as a `-' flag followed by a positive
  397. * field width.  A negative precision argument is taken as if the precision
  398. * were omitted.
  399. *
  400. * The flag characters and their meanings are:
  401. * .iP `-'
  402. * The result of the conversion will be left-justified within the field.
  403. * (it will be right-justified if this flag is not specified.)
  404. * .iP `+'
  405. * The result of a signed conversion will always begin with a plus or 
  406. * minus sign.  (It will begin with a sign only when a negative value
  407. * is converted if this flag is not specified.)
  408. * .iP `space'
  409. * If the first character of a signed conversion is not a sign, or 
  410. * if a signed conversion results in no characters, a space will be 
  411. * prefixed to the result.  If the `space' and `+' flags both appear, the
  412. * `space' flag will be ignored.
  413. * .iP `#'
  414. * The result is to be converted to an "alternate form."  For `o' conversion
  415. * it increases the precision to force the first digit of the result to be a
  416. * zero.  For `x' (or `X') conversion, a non-zero result will have "0x" (or
  417. * "0X") prefixed to it.  For `e', `E', `f', `g', and `g' conversions, the
  418. * result will always contain a decimal-point character, even if no digits
  419. * follow it.  (Normally, a decimal-point character appears in the result of
  420. * these conversions only if no digit follows it).  For `g' and `G'
  421. * conversions, trailing zeros will not be removed from the result.  For
  422. * other conversions, the behavior is undefined.
  423. * .iP `0'
  424. * For `d', `i', `o', `u', `x', `X', `e', `E', `f', `g', and `G' conversions,
  425. * leading zeros (following any indication of sign or base) are used to pad
  426. * to the field width; no space padding is performed.  If the `0' and `-'
  427. * flags both appear, the `0' flag will be ignored.  For `d', `i', `o', `u',
  428. * `x', and `X' conversions, if a precision is specified, the `0' flag will
  429. * be ignored.  For other conversions, the behavior is undefined.
  430. * .LP
  431. *
  432. * The conversion specifiers and their meanings are:
  433. * .iP "`d', `i'"
  434. * The `int' argument is converted to signed decimal in the style
  435. * `[-]dddd'.  The precision specifies the minimum number of digits 
  436. * to appear; if the value being converted can be represented in
  437. * fewer digits, it will be expanded with leading zeros.  The
  438. * default precision is 1.  The result of converting a zero value
  439. * with a precision of zero is no characters.
  440. * .iP "`o', `u', `x', `X'"
  441. * The `unsigned int' argument is converted to unsigned octal (`o'),
  442. * unsigned decimal (`u'), or unsigned hexadecimal notation (`x' or `X')
  443. * in the style `dddd'; the letters abcdef are used for `x' conversion
  444. * and the letters ABCDEF for `X' conversion.  The precision specifies
  445. * the minimum number of digits to appear; if the value being 
  446. * converted can be represented in fewer digits, it will be 
  447. * expanded with leading zeros.  The default precision is 1.  The
  448. * result of converting a zero value with a precision of zero is 
  449. * no characters.
  450. * .iP `f'
  451. * The `double' argument is converted to decimal notation in the 
  452. * style `[-]ddd.ddd', where the number of digits after the decimal
  453. * point character is equal to the precision specification.  If the
  454. * precision is missing, it is taken as 6; if the precision is zero
  455. * and the `#' flag is not specified, no decimal-point character
  456. * appears.  If a decimal-point character appears, at least one 
  457. * digit appears before it.  The value is rounded to the appropriate
  458. * number of digits.
  459. * .iP "`e', `E'"
  460. * The `double' argument is converted in the style `[-]d.ddde+/-dd',
  461. * where there is one digit before the decimal-point character 
  462. * (which is non-zero if the argument is non-zero) and the number
  463. * of digits after it is equal to the precision; if the precision
  464. * is missing, it is taken as 6; if the precision is zero and the 
  465. * `#' flag is not specified, no decimal-point character appears.  The
  466. * value is rounded to the appropriate number of digits.  The `E'
  467. * conversion specifier will produce a number with `E' instead of `e'
  468. * introducing the exponent.  The exponent always contains at least
  469. * two digits.  If the value is zero, the exponent is zero.
  470. * .iP "`g', `G'"
  471. * The `double' argument is converted in style `f' or `e' (or in style 
  472. * `E' in the case of a `G' conversion specifier), with the precision
  473. * specifying the number of significant digits.  If the precision
  474. * is zero, it is taken as 1.  The style used depends on the 
  475. * value converted; style `e' (or `E') will be used only if the 
  476. * exponent resulting from such a conversion is less than -4 or 
  477. * greater than or equal to the precision.  Trailing zeros are
  478. * removed from the fractional portion of the result; a decimal-point
  479. * character appears only if it is followed by a digit.
  480. * .iP `c'
  481. * The `int' argument is converted to an `unsigned char', and the 
  482. * resulting character is written.
  483. * .iP `s'
  484. * The argument should be a pointer to an array of character type.
  485. * Characters from the array are written up to (but not including)
  486. * a terminating null character; if the precision is specified,
  487. * no more than that many characters are written.  If the precision
  488. * is not specified or is greater than the size of the array, the
  489. * array will contain a null character.
  490. * .iP `p'
  491. * The argument should be a pointer to `void'.  The value of the 
  492. * pointer is converted to a sequence of printable characters,
  493. * in hexadecimal representation (prefixed with "0x").
  494. * .iP `n'
  495. * The argument should be a pointer to an integer into which
  496. * the number of characters written to the output stream
  497. * so far by this call to fprintf() is written.  No argument is converted.
  498. * .iP `%'
  499. * A `%' is written.  No argument is converted.  The complete
  500. * conversion specification is %%.
  501. * .LP
  502. *
  503. * If a conversion specification is invalid, the behavior is undefined.
  504. *
  505. * If any argument is, or points to, a union or an aggregate (except for an 
  506. * array of character type using `s' conversion, or a pointer using `p' 
  507. * conversion), the behavior is undefined.
  508. *
  509. * In no case does a non-existent or small field width cause truncation of a
  510. * field if the result of a conversion is wider than the field width, the
  511. * field is expanded to contain the conversion result.
  512. *
  513. * INCLUDE FILES: fioLib.h 
  514. *
  515. * RETURNS:
  516. * The number of characters written, or a negative value if an
  517. * output error occurs.
  518. *
  519. * SEE ALSO: fprintf(),
  520. * .I "American National Standard for Information Systems -"
  521. * .I "Programming Language - C, ANSI X3.159-1989: Input/Output (stdio.h)"
  522. *
  523. * VARARGS1
  524. */
  526. int printf
  527.     (
  528.     const char *  fmt, /* format string to write */
  529.     ...       /* optional arguments to format string */
  530.     )
  531.     {
  532.     va_list vaList; /* traverses argument list */
  533.     int nChars;
  535.     va_start (vaList, fmt);
  536.     nChars = fioFormatV (fmt, vaList, printbuf, 1);
  537.     va_end (vaList);
  539.     return (nChars);
  540.     }
  542. /*******************************************************************************
  543. *
  544. * printErr - write a formatted string to the standard error stream
  545. *
  546. * This routine writes a formatted string to standard error.  Its function and
  547. * syntax are otherwise identical to printf().
  548. *
  549. * RETURNS: The number of characters output, or ERROR if there is an error
  550. * during output.
  551. *
  552. * SEE ALSO: printf()
  553. *
  554. * VARARGS1
  555. */
  557. int printErr
  558.     (
  559.     const char *  fmt,  /* format string to write */
  560.     ...       /* optional arguments to format */
  561.     )
  562.     {
  563.     va_list vaList; /* traverses argument list */
  564.     int nChars;
  566.     va_start (vaList, fmt);
  567.     nChars = fioFormatV (fmt, vaList, printbuf, 2);
  568.     va_end (vaList);
  570.     return (nChars);
  571.     }
  573. /*******************************************************************************
  574. *
  575. * printExc - print error message
  576. *
  577. * If at interrupt level or other invalid/fatal state, then "print"
  578. * into System Exception Message area.
  579. *
  580. * NOMANUAL
  581. */
  583. void printExc (fmt, arg1, arg2, arg3, arg4, arg5)
  584.     char *fmt; /* format string */
  585.     int arg1;
  586.     int arg2;
  587.     int arg3;
  588.     int arg4;
  589.     int arg5;
  591.     {
  592.     UINT state;
  593.     int pageSize;
  594.     char * pageAddr;
  596.     if ((INT_CONTEXT ()) || (Q_FIRST (&activeQHead) == NULL))
  597. {
  598. /* Exception happened during exception processing, or before
  599.  * any task could be initialized. Tack the message onto the end
  600.  * of a well-known location. 
  601.  */
  603. /* see if we need to write enable the memory */
  605. if (vmLibInfo.vmLibInstalled)
  606.     {
  607.     pageSize = VM_PAGE_SIZE_GET();
  608.     pageAddr = (char *) ((UINT) sysExcMsg / pageSize * pageSize);
  610.     if ((VM_STATE_GET (NULL, (void *) pageAddr, &state) != ERROR) &&
  611. ((state & VM_STATE_MASK_WRITABLE) == VM_STATE_WRITABLE_NOT))
  612. {
  613. TASK_SAFE(); /* safe from deletion */
  615. VM_STATE_SET (NULL, pageAddr, pageSize, VM_STATE_MASK_WRITABLE,
  616.       VM_STATE_WRITABLE);
  618. sysExcMsg += sprintf (sysExcMsg,fmt,arg1,arg2,arg3,arg4,arg5);
  620. VM_STATE_SET (NULL, pageAddr, pageSize, VM_STATE_MASK_WRITABLE,
  621.       VM_STATE_WRITABLE_NOT);
  623. TASK_UNSAFE(); /* unsafe from deletion */
  624. return;
  625. }
  626.     }
  628. sysExcMsg += sprintf (sysExcMsg, fmt, arg1, arg2, arg3, arg4, arg5);
  629. }
  630.     else
  631.         {
  632.         /* queue printErr() so that we do not block here (SPR 22735) */
  634.         excJobAdd ((VOIDFUNCPTR)printErr, (int)fmt, arg1,arg2,arg3,arg4,arg5);
  635.         }
  636.     }
  638. /*******************************************************************************
  639. *
  640. * fdprintf - write a formatted string to a file descriptor
  641. *
  642. * This routine writes a formatted string to a specified file descriptor.  Its
  643. * function and syntax are otherwise identical to printf().
  644. *
  645. * RETURNS: The number of characters output, or ERROR if there is an error
  646. * during output.
  647. *
  648. * SEE ALSO: printf()
  649. *
  650. * VARARGS2
  651. */
  653. int fdprintf
  654.     (
  655.     int fd, /* file descriptor to write to */
  656.     const char *  fmt, /* format string to write */
  657.     ... /* optional arguments to format */
  658.     )
  659.     {
  660.     va_list vaList; /* traverses argument list */
  661.     int nChars;
  663.     va_start (vaList, fmt);
  664.     nChars = fioFormatV (fmt, vaList, printbuf, fd);
  665.     va_end (vaList);
  667.     return (nChars);
  668.     }
  670. /*******************************************************************************
  671. *
  672. * sprintf - write a formatted string to a buffer (ANSI)
  673. *
  674. * This routine copies a formatted string to a specified buffer, which is
  675. * null-terminated.  Its function and syntax are otherwise identical
  676. * to printf().
  677. *
  678. * RETURNS:
  679. * The number of characters copied to <buffer>, not including the NULL 
  680. * terminator.
  681. *
  682. * SEE ALSO: printf(),
  683. * .I "American National Standard for Information Systems -"
  684. * .I "Programming Language - C, ANSI X3.159-1989: Input/Output (stdio.h)"
  685. *
  686. * VARARGS2
  687. */
  689. int sprintf
  690.     (
  691.     char *  buffer, /* buffer to write to */
  692.     const char *  fmt, /* format string */
  693.     ... /* optional arguments to format */
  694.     )
  695.     {
  696.     va_list vaList; /* traverses argument list */
  697.     int nChars;
  699.     va_start (vaList, fmt);
  700.     nChars = fioFormatV (fmt, vaList, putbuf, (int) &buffer);
  701.     va_end (vaList);
  703.     *buffer = EOS;
  705.     return (nChars);
  706.     }
  708. /*******************************************************************************
  709. *
  710. * vprintf - write a string formatted with a variable argument list to standard output (ANSI)
  711. *
  712. * This routine prints a string formatted with a variable argument list to
  713. * standard output.  It is identical to printf(), except that it takes
  714. * the variable arguments to be formatted as a list <vaList> of type `va_list'
  715. * rather than as in-line arguments.
  716. *
  717. * RETURNS: The number of characters output, or ERROR if there is an error
  718. * during output.
  719. *
  720. * SEE ALSO: printf(),
  721. * .I "American National Standard for Information Systems -"
  722. * .I "Programming Language - C, ANSI X3.159-1989: Input/Output (stdio.h)"
  723. */
  725. int vprintf
  726.     (
  727.     const char *  fmt, /* format string to write */
  728.     va_list   vaList /* arguments to format */
  729.     )
  730.     {
  731.     return (fioFormatV (fmt, vaList, printbuf, 1));
  732.     }
  733. /*******************************************************************************
  734. *
  735. * vfdprintf - write a string formatted with a variable argument list to a file descriptor
  736. *
  737. * This routine prints a string formatted with a variable argument list to a
  738. * specified file descriptor.  It is identical to fdprintf(), except
  739. * that it takes the variable arguments to be formatted as a list <vaList> of
  740. * type `va_list' rather than as in-line arguments.
  741. *
  742. * RETURNS: The number of characters output, or ERROR if there is an error
  743. * during output.
  744. *
  745. * SEE ALSO: fdprintf()
  746. */
  748. int vfdprintf
  749.     (
  750.     int   fd, /* file descriptor to print to */
  751.     const char *  fmt, /* format string for print */
  752.     va_list   vaList /* optional arguments to format */
  753.     )
  754.     {
  755.     return (fioFormatV (fmt, vaList, printbuf, fd));
  756.     }
  757. /*******************************************************************************
  758. *
  759. * vsprintf - write a string formatted with a variable argument list to a buffer (ANSI)
  760. *
  761. * This routine copies a string formatted with a variable argument list to
  762. * a specified buffer.  This routine is identical to sprintf(), except that it
  763. * takes the variable arguments to be formatted as a list <vaList> of type
  764. * `va_list' rather than as in-line arguments.
  765. *
  766. * RETURNS: 
  767. * The number of characters copied to <buffer>, not including the NULL 
  768. * terminator.
  769. *
  770. * SEE ALSO: sprintf(),
  771. * .I "American National Standard for Information Systems -"
  772. * .I "Programming Language - C, ANSI X3.159-1989: Input/Output (stdio.h)"
  773. */
  775. int vsprintf
  776.     (
  777.     char *   buffer, /* buffer to write to */
  778.     const char *  fmt, /* format string */
  779.     va_list   vaList /* optional arguments to format */
  780.     )
  781.     {
  782.     int nChars;
  784.     nChars = fioFormatV (fmt, vaList, putbuf, (int) &buffer);
  785.     *buffer = EOS;
  787.     return (nChars);
  788.     }
  790. #ifdef _WRS_ALTIVEC_SUPPORT
  791. typedef union {
  792.       __vector unsigned long  vul;
  793.       float  f32[4];
  794.       unsigned long  u32[4];
  795.       unsigned short  u16[8];
  796.       unsigned char  u8[16];
  797.       signed long  s32[4];
  798.       signed short  s16[8];
  799.       signed char  s8[16];
  800.     } VECTOR;
  801. #endif /* _WRS_ALTIVEC_SUPPORT */
  802. /*******************************************************************************
  803. *
  804. * fioFormatV - convert a format string
  805. *
  806. * This routine is used by the printf() family of routines to handle the
  807. * actual conversion of a format string.  The first argument is a format
  808. * string, as described in the entry for printf().  The second argument is a
  809. * variable argument list <vaList> that was previously established.
  810. *
  811. * As the format string is processed, the result will be passed to the output
  812. * routine whose address is passed as the third parameter, <outRoutine>.
  813. * This output routine may output the result to a device, or put it in a
  814. * buffer.  In addition to the buffer and length to output, the fourth
  815. * argument, <outarg>, will be passed through as the third parameter to the
  816. * output routine.  This parameter could be a file descriptor, a buffer 
  817. * address, or any other value that can be passed in an "int".
  818. *
  819. * The output routine should be declared as follows:
  820. * .CS
  821. *     STATUS outRoutine
  822. *         (
  823. *         char *buffer, /@ buffer passed to routine            @/
  824. *         int  nchars,  /@ length of buffer                    @/
  825. *         int  outarg   /@ arbitrary arg passed to fmt routine @/
  826. *         )
  827. * .CE
  828. * The output routine should return OK if successful, or ERROR if unsuccessful.
  829. *
  830. * RETURNS:
  831. * The number of characters output, or ERROR if the output routine 
  832. * returned ERROR.
  833. *
  834. * INTERNAL
  835. * Warning, this routine is extremely complex and its integrity is easily
  836. * destroyed. Do not change this code without absolute understanding of all
  837. * ramifications and consequences. 
  838. */
  839. int fioFormatV
  840.     (
  841.     FAST const char *fmt,  /* format string */
  842.     va_list vaList,        /* pointer to varargs list */
  843.     FUNCPTR outRoutine,    /* handler for args as they're formatted */
  844.     int outarg          /* argument to routine */
  845.     )
  846.     {
  847.     FAST int ch; /* character from fmt */
  848.     FAST int n; /* handy integer (short term usage) */
  849.     FAST char * cp; /* handy char pointer (short term usage) */
  850.     int width; /* width from format (%8d), or 0 */
  851.     char sign; /* sign prefix (' ', '+', '-', or ) */
  852.     unsigned long long
  853.         ulongLongVal;  /* unsigned 64 bit arguments %[diouxX] */
  854.     int prec; /* precision from format (%.3d), or -1 */
  855.     int oldprec; /* old precision from format (%.3d), or -1 */
  856.     int dprec; /* a copy of prec if [diouxX], 0 otherwise */
  857.     int fpprec; /* `extra' floating precision in [eEfgG] */
  858.     int size; /* size of converted field or string */
  859.     int fieldsz; /* field size expanded by sign, etc */
  860.     int realsz; /* field size expanded by dprec */
  862. #ifdef _WRS_ALTIVEC_SUPPORT
  863.     FAST int i; /* handy integer (short term usage) */
  864.     FAST char * vp; /* handy char pointer (short term usage) */
  865.     char Separator; /* separator for vector elements */
  866.     char C_Separator; /* separator for char vector elements */
  867.     VECTOR vec; /* vector argument */
  868.     BOOL doVector; /* AltiVec vector */
  869. #endif /* _WRS_ALTIVEC_SUPPORT */
  870.     char FMT[20]; /* To collect fmt info */
  871.     FAST char * Collect; /* char pointer to FMT */
  873.     BOOL doLongInt; /* long integer */
  874.     BOOL doLongLongInt; /* long long integer - 64 bit */
  875.     BOOL doShortInt; /* short integer */
  876.     BOOL doAlt; /* alternate form */
  877.     BOOL doLAdjust; /* left adjustment */
  878.     BOOL doZeroPad; /* zero (as opposed to blank) pad */
  879.     BOOL doHexPrefix; /* add 0x or 0X prefix */
  880.     BOOL doSign; /* change sign to '-' */
  881.     char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */
  882. #if (CPU_FAMILY != AM29XXX)
  883.     char ox[2]; /* space for 0x hex-prefix */
  884. #else
  885.     char ox[3]; /* space for 0x hex-prefix */
  886. #endif /*(CPU_FAMILY != AM29XXX)*/
  887.     char * xdigs = NULL; /* digits for [xX] conversion */
  888.     int ret = 0; /* return value accumulator */
  889.     enum {OCT, DEC, HEX} base; /* base for [diouxX] conversion */
  892.     FOREVER /* Scan the format for conversions (`%' character) */
  893. {
  894. for (cp = CHAR_FROM_CONST(fmt);((ch=*fmt) != EOS)&&(ch != '%'); fmt++)
  895.     ;
  897. if ((n = fmt - cp) != 0)
  898.     {
  899.     if ((*outRoutine) (cp, n, outarg) != OK)
  900. return (ERROR);
  902.     ret += n;
  903.     }
  905. if (ch == EOS)
  906.     return (ret); /* return total length */
  908. fmt++; /* skip over '%' */
  909. #ifdef _WRS_ALTIVEC_SUPPORT
  910. Separator = ' '; /* the default separator for vector elements */
  911. C_Separator = EOS; /* the default separator for char vector elements */
  912. doVector = FALSE; /* no vector modifier */
  913. #endif /* _WRS_ALTIVEC_SUPPORT */
  915. *FMT = EOS;
  916. Collect = FMT;
  917. doLongInt = FALSE; /* long integer */
  918. doLongLongInt = FALSE; /* 64 bit integer */
  919. doShortInt = FALSE; /* short integer */
  920. doAlt = FALSE; /* alternate form */
  921. doLAdjust = FALSE; /* left adjustment */
  922. doZeroPad = FALSE; /* zero (as opposed to blank) pad */
  923. doHexPrefix = FALSE; /* add 0x or 0X prefix */
  924. doSign = FALSE; /* change sign to '-' */
  925. dprec = 0;
  926. fpprec = 0;
  927. width = 0;
  928. prec = -1;
  929. oldprec = -1;
  930. sign = EOS;
  932. #define get_CHAR  (ch = *Collect++ = *fmt++)
  934. #ifdef _WRS_ALTIVEC_SUPPORT
  935. #define SET_VECTOR_FMT(VFMT,NO)
  936.   do
  937.     {
  938. char * to;
  940. vec.vul =  va_arg (vaList,__vector unsigned long);
  941. cp = buf;
  943. *Collect = EOS;
  944. i = (NO);
  945. to = VFMT = (char *) malloc (i*20);
  946. while(i-- > 0) {
  948. char * from = FMT;
  950. *to++ = '%';
  951. while (*to++ = *from++);
  952. *(char*)((int)(to)-1) = Separator;
  953. }
  954. *(--to) = EOS;
  955.     }
  956.   while (0)
  958. #define RESET_VECTOR_FMT(VFMT)
  960. size = strlen(cp);
  961. sign = EOS;
  963. free(VFMT)
  964. #endif /* _WRS_ALTIVEC_SUPPORT */
  966. rflag:
  967. get_CHAR;
  968. reswitch:
  969. switch (ch) 
  970.     {
  971.     case ' ':
  972.     /* If the space and + flags both appear, the space
  973.      * flag will be ignored. -- ANSI X3J11
  974.      */
  975.     if (!sign)
  976. sign = ' ';
  977.     goto rflag;
  978. #ifdef _WRS_ALTIVEC_SUPPORT
  979.     case ',':
  980.     case ';':
  981.     case ':':
  982.     case '_':
  983.     Collect--;
  984.          Separator = C_Separator = ch;
  985.     goto rflag;
  986. #endif /* _WRS_ALTIVEC_SUPPORT */
  987.     case '#':
  988.     doAlt = TRUE;
  989.     goto rflag;
  991.     case '*':
  992.     /* A negative field width argument is taken as a
  993.      * flag followed by a positive field width.
  994.      * -- ANSI X3J11
  995.      * They don't exclude field widths read from args.
  996.      */
  997.     if ((width = va_arg(vaList, int)) >= 0)
  998. goto rflag;
  1000.     width = -width; /* FALLTHROUGH */
  1002.     case '-':
  1003.     doLAdjust = TRUE;
  1004.     goto rflag;
  1006.     case '+':
  1007.     sign = '+';
  1008.     goto rflag;
  1010.     case '.':
  1011.     get_CHAR;
  1012.     if ( ch == '*' ) 
  1013. {
  1014. n = va_arg(vaList, int);
  1015. prec = (n < 0) ? -1 : n;
  1016. goto rflag;
  1017. }
  1019.     n = 0;
  1020.     while (is_digit(ch)) 
  1021. {
  1022. n = 10 * n + to_digit(ch);
  1023. get_CHAR;
  1024. }
  1025.     prec = n < 0 ? -1 : n;
  1026.     goto reswitch;
  1028.     case '0':
  1029.     /* Note that 0 is taken as a flag, not as the
  1030.      * beginning of a field width. -- ANSI X3J11
  1031.      */
  1032.     doZeroPad = TRUE;
  1033.     goto rflag;
  1035.     case '1':
  1036.     case '2':
  1037.     case '3':
  1038.     case '4':
  1039.     case '5':
  1040.     case '6':
  1041.     case '7':
  1042.     case '8':
  1043.     case '9':
  1044.     n = 0;
  1045.     do 
  1046. {
  1047. n = 10 * n + to_digit(ch);
  1048. get_CHAR;
  1049. } while (is_digit(ch));
  1051.     width = n;
  1052.     goto reswitch;
  1054.     case 'h':
  1055.     doShortInt = TRUE;
  1056.     goto rflag;
  1058.     case 'l':
  1059.     get_CHAR;
  1060.     if ( ch == 'l' )
  1061. {
  1062. doLongLongInt = TRUE;
  1063. goto rflag;
  1064. }
  1065.     else
  1066. {
  1067.         doLongInt = TRUE;
  1068.         goto reswitch;
  1069. }
  1071. #ifdef _WRS_ALTIVEC_SUPPORT
  1072.     case 'v':
  1073.     Collect--;
  1074.     doVector = TRUE;
  1075.     goto rflag;
  1076. #endif /* _WRS_ALTIVEC_SUPPORT */
  1078.     case 'c':
  1079. #ifdef _WRS_ALTIVEC_SUPPORT
  1080.     if (doVector)
  1081.     {
  1082. vec.vul =  va_arg (vaList,__vector unsigned long);
  1083. cp = buf;
  1084. vp = (unsigned char *)&vec.u8;
  1085. i = 15;
  1087. while(i-- > 0) {
  1089. *cp++ = *vp++;
  1090. if (C_Separator) *cp++ = C_Separator;
  1091. }
  1093. *cp++ = *vp++;
  1095. cp = buf;
  1096. size = 16 + (C_Separator ? 15:0);
  1097. sign = EOS;
  1098.     }
  1099.     else 
  1100.     {
  1101. #endif /* _WRS_ALTIVEC_SUPPORT */
  1102. *(cp = buf) = va_arg(vaList, int);
  1103. size = 1;
  1104. sign = EOS;
  1105. #ifdef _WRS_ALTIVEC_SUPPORT 
  1106.     }
  1107. #endif /* _WRS_ALTIVEC_SUPPORT */
  1108.     break;
  1110.     case 'D':
  1111.     doLongInt = TRUE;  /* FALLTHROUGH */
  1113.     case 'd':
  1114.     case 'i':
  1115. #ifdef _WRS_ALTIVEC_SUPPORT
  1116.     if (doVector)
  1117.     {
  1118. SET_VECTOR_FMT(vp,doShortInt?8:4);
  1120. if (doShortInt)
  1121. sprintf(cp,vp,vec.s16[0],vec.s16[1],vec.s16[2],vec.s16[3],
  1122.       vec.s16[4],vec.s16[5],vec.s16[6],vec.s16[7]);
  1123. else
  1124. sprintf(cp,vp,vec.s32[0],vec.s32[1],vec.s32[2],vec.s32[3]);
  1126. RESET_VECTOR_FMT(vp);
  1127. break;
  1128.     }
  1129. #endif /* _WRS_ALTIVEC_SUPPORT */
  1131.     ulongLongVal = SARG();
  1132.     if ((long long)ulongLongVal < 0) 
  1133. {
  1134. ulongLongVal = -ulongLongVal;
  1135. sign = '-';
  1136. }
  1137.     base = DEC;
  1138.     goto number;
  1140.     case 'n':
  1141.     /* ret is int, so effectively %lln = %ln */
  1142.     if (doLongLongInt)
  1143. *va_arg(vaList, long long *) = (long long) ret;
  1144.     else if (doLongInt)
  1145. *va_arg(vaList, long *) = ret;
  1146.     else if (doShortInt)
  1147. *va_arg(vaList, short *) = ret;
  1148.     else
  1149. *va_arg(vaList, int *) = ret;
  1150.     continue; /* no output */
  1152.     case 'O':
  1153.     doLongInt = TRUE; /* FALLTHROUGH */
  1155.     case 'o':
  1156. #ifdef _WRS_ALTIVEC_SUPPORT
  1157.     if (doVector)
  1158.     {
  1159. SET_VECTOR_FMT(vp,doShortInt?8:4);
  1161. if (doShortInt)
  1162. sprintf(cp,vp,vec.s16[0],vec.s16[1],vec.s16[2],vec.s16[3],
  1163.       vec.s16[4],vec.s16[5],vec.s16[6],vec.s16[7]);
  1164. else
  1165. sprintf(cp,vp,vec.s32[0],vec.s32[1],vec.s32[2],vec.s32[3]);
  1167. RESET_VECTOR_FMT(vp);
  1168. break;
  1169.     }
  1170. #endif /* _WRS_ALTIVEC_SUPPORT */
  1171.     ulongLongVal = UARG();
  1172.     base = OCT;
  1173.     goto nosign;
  1175.     case 'p':
  1176.     /* The argument shall be a pointer to void.  The
  1177.      * value of the pointer is converted to a sequence
  1178.      * of printable characters, in an implementation
  1179.      * defined manner. -- ANSI X3J11
  1180.      */
  1181. #ifdef _WRS_ALTIVEC_SUPPORT
  1182.     if (doVector)
  1183.     {
  1184. SET_VECTOR_FMT(vp,4);
  1186. sprintf(cp,vp,vec.u32[0],vec.u32[1],vec.u32[2],vec.u32[3]);
  1188. RESET_VECTOR_FMT(vp);
  1189. break;
  1190.     }
  1191. #endif /* _WRS_ALTIVEC_SUPPORT */
  1192.     ulongLongVal = (unsigned long long) (unsigned int)
  1193.            va_arg(vaList, void *);/* NOSTRICT */
  1194.     base = HEX;
  1195.     xdigs = "0123456789abcdef";
  1196.     doHexPrefix = TRUE;
  1197.     ch = 'x';
  1198.     goto nosign;
  1200.     case 's':
  1201.     if ((cp = va_arg(vaList, char *)) == NULL)
  1202. cp = "(null)";
  1204.     if (prec >= 0) 
  1205. {
  1206. /* can't use strlen; can only look for the
  1207.  * NUL in the first `prec' characters, and
  1208.  * strlen() will go further.
  1209.  */
  1211. char *p = (char *)memchr(cp, 0, prec);
  1213. if (p != NULL) 
  1214.     {
  1215.     size = p - cp;
  1216.     if (size > prec)
  1217. size = prec;
  1218.     }
  1219. else
  1220.     size = prec;
  1221. }
  1222.     else
  1223. size = strlen(cp);
  1225.     sign = EOS;
  1226.     break;
  1228.     case 'U':
  1229.     doLongInt = TRUE; /* FALLTHROUGH */
  1231.     case 'u':
  1232. #ifdef _WRS_ALTIVEC_SUPPORT
  1233.     if (doVector)
  1234.     {
  1235. SET_VECTOR_FMT(vp,doShortInt?8:4);
  1237. if (doShortInt)
  1238. sprintf(cp,vp,vec.u16[0],vec.u16[1],vec.u16[2],vec.u16[3],
  1239.       vec.u16[4],vec.u16[5],vec.u16[6],vec.u16[7]);
  1240. else
  1241. sprintf(cp,vp,vec.u32[0],vec.u32[1],vec.u32[2],vec.u32[3]);
  1243. RESET_VECTOR_FMT(vp);
  1244. break;
  1245.     }
  1246. #endif /* _WRS_ALTIVEC_SUPPORT */
  1247.     ulongLongVal = UARG();
  1248.     base = DEC;
  1249.     goto nosign;
  1251.     case 'X':
  1252.     xdigs = "0123456789ABCDEF";
  1253.     goto hex;
  1255.     case 'x':
  1256.     xdigs = "0123456789abcdef";
  1258. hex:
  1259. #ifdef _WRS_ALTIVEC_SUPPORT
  1260.     if (doVector)
  1261.     {
  1262. SET_VECTOR_FMT(vp,doShortInt?8:4);
  1264. if (doShortInt)
  1265. sprintf(cp,vp,vec.s16[0],vec.s16[1],vec.s16[2],vec.s16[3],
  1266.       vec.s16[4],vec.s16[5],vec.s16[6],vec.s16[7]);
  1267. else
  1268. sprintf(cp,vp,vec.s32[0],vec.s32[1],vec.s32[2],vec.s32[3]);
  1270. RESET_VECTOR_FMT(vp);
  1271. break;
  1272.     }
  1273. #endif /* _WRS_ALTIVEC_SUPPORT */
  1274.     ulongLongVal = UARG();
  1275.     base = HEX;
  1277.     /* leading 0x/X only if non-zero */
  1279.     if (doAlt && (ulongLongVal != 0))
  1280. doHexPrefix = TRUE;
  1282.     /* unsigned conversions */
  1283. nosign:     sign = EOS;
  1285.     /* ... diouXx conversions ... if a precision is
  1286.      * specified, the 0 flag will be ignored. -- ANSI X3J11
  1287.      */
  1289. number:     if ((dprec = prec) >= 0)
  1290. doZeroPad = FALSE;
  1292.     /* The result of converting a zero value with an
  1293.      * explicit precision of zero is no characters. 
  1294.      * -- ANSI X3J11
  1295.      */
  1296.     cp = buf + BUF;
  1297.     if ((ulongLongVal != 0) || (prec != 0)) 
  1298. {
  1299. /* unsigned mod is hard, and unsigned mod
  1300.  * by a constant is easier than that by
  1301.  * a variable; hence this switch.
  1302.  */
  1303. switch (base) 
  1304.     {
  1305.     case OCT:
  1306. do 
  1307.     {
  1308.     *--cp = to_char(ulongLongVal & 7);
  1309.     ulongLongVal >>= 3;
  1310.     } while (ulongLongVal);
  1312. /* handle octal leading 0 */
  1314. if (doAlt && (*cp != '0'))
  1315.     *--cp = '0';
  1316. break;
  1318.     case DEC:
  1319. /* many numbers are 1 digit */
  1321. while (ulongLongVal >= 10) 
  1322.     {
  1323.     *--cp = to_char(ulongLongVal % 10);
  1324.     ulongLongVal /= 10;
  1325.     }
  1327. *--cp = to_char(ulongLongVal);
  1328. break;
  1330.     case HEX:
  1331. do 
  1332.     {
  1333.     *--cp = xdigs[ulongLongVal & 15];
  1334.     ulongLongVal >>= 4;
  1335.     } while (ulongLongVal);
  1336. break;
  1338.     default:
  1339. cp = "bug in vfprintf: bad base";
  1340. size = strlen(cp);
  1341. goto skipsize;
  1342.     }
  1343. }
  1345.     size = buf + BUF - cp;
  1346. skipsize:
  1347.     break;
  1349.     case 'L':
  1350.     /* NOT IMPLEMENTED */
  1351.     goto rflag;
  1353.     case 'e':
  1354.     case 'E':
  1355.     case 'f':
  1356.     case 'g':
  1357.     case 'G':
  1358. #ifdef _WRS_ALTIVEC_SUPPORT
  1359.     if (doVector)
  1360.     {
  1361. SET_VECTOR_FMT(vp,4);
  1363. sprintf(cp,vp,vec.f32[0],vec.f32[1],vec.f32[2],vec.f32[3]);
  1365. RESET_VECTOR_FMT(vp);
  1366. break;
  1367.     }
  1368. #endif /* _WRS_ALTIVEC_SUPPORT */
  1369.     if (fioFltFormatRtn != NULL)
  1370. {
  1371. oldprec = prec; /* in case of strange float */
  1373. if (prec > MAXFRACT)  /* do realistic precision */
  1374.     {
  1375.     if (((ch != 'g') && (ch != 'G')) || doAlt)
  1376. fpprec = prec - MAXFRACT;
  1377.     prec = MAXFRACT; /* they asked for it! */
  1378.     }
  1379. else if (prec == -1)
  1380.     prec = 6; /* ANSI default precision */
  1382. cp  = buf; /* where to fill in result */
  1383. *cp = EOS; /* EOS terminate just in case */
  1384. #if ((CPU_FAMILY != I960) && (CPU_FAMILY != PPC))
  1385. size = (*fioFltFormatRtn) (&vaList,prec,doAlt,ch,
  1386.    &doSign,cp,buf+sizeof(buf));
  1387. #else
  1388. size = (*fioFltFormatRtn) (vaList, prec, doAlt, ch,
  1389.    &doSign,cp,buf+sizeof(buf));
  1390. #endif
  1391. if ((int)size < 0) /* strange value (Nan,Inf,..) */
  1392.     {
  1393.     size = -size; /* get string length */
  1394.     prec = oldprec; /* old precision (not default)*/
  1396.     doZeroPad = FALSE; /* don't pad with zeroes */
  1397.     if (doSign) /* is strange value signed? */
  1398. sign = '-';
  1399.     }
  1400. else
  1401.     {
  1402.     if (doSign)
  1403. sign = '-';
  1405.     if (*cp == EOS)
  1406. cp++;
  1407.     }
  1408. break;
  1409. }
  1410.     /* FALLTHROUGH if no floating point format routine */
  1412.     default: /* "%?" prints ?, unless ? is NULL */
  1413.     if (ch == EOS)
  1414. return (ret);
  1416.     /* pretend it was %c with argument ch */
  1418.     cp   = buf;
  1419.     *cp  = ch;
  1420.     size = 1;
  1421.     sign = EOS;
  1422.     break;
  1423.     }
  1425. /* All reasonable formats wind up here.  At this point,
  1426.  * `cp' points to a string which (if not doLAdjust)
  1427.  * should be padded out to `width' places.  If
  1428.  * doZeroPad, it should first be prefixed by any
  1429.  * sign or other prefix; otherwise, it should be blank
  1430.  * padded before the prefix is emitted.  After any
  1431.  * left-hand padding and prefixing, emit zeroes
  1432.  * required by a decimal [diouxX] precision, then print
  1433.  * the string proper, then emit zeroes required by any
  1434.  * leftover floating precision; finally, if doLAdjust,
  1435.  * pad with blanks.
  1436.  */
  1438. /*
  1439.  * compute actual size, so we know how much to pad.
  1440.  * fieldsz excludes decimal prec; realsz includes it
  1441.  */
  1443. fieldsz = size + fpprec;
  1445. if (sign)
  1446.     {
  1447.     fieldsz++;
  1448.     if (fieldSzIncludeSign)
  1449.         dprec++; 
  1450.     }
  1451. else if (doHexPrefix)
  1452.     fieldsz += 2;
  1454. realsz = (dprec > fieldsz) ? dprec : fieldsz;
  1456. /* right-adjusting blank padding */
  1458. if (!doLAdjust && !doZeroPad)
  1459.     PAD(width - realsz, blanks);
  1461. /* prefix */
  1463. if (sign)
  1464.     {
  1465.     if ((*outRoutine) (&sign, 1, outarg) != OK)
  1466. return (ERROR);
  1467.     }
  1468. else if (doHexPrefix) 
  1469.     {
  1470.     ox[0] = '0';
  1471.     ox[1] = ch;
  1472.     if ((*outRoutine) (ox, 2, outarg) != OK)
  1473. return (ERROR);
  1474.     }
  1476. /* right-adjusting zero padding */
  1478. if (!doLAdjust && doZeroPad)
  1479.     PAD(width - realsz, zeroes);
  1481. /* leading zeroes from decimal precision */
  1483. PAD(dprec - fieldsz, zeroes);
  1485. /* the string or number proper */
  1487. if ((*outRoutine) (cp, size, outarg) != OK)
  1488.     return (ERROR);
  1490. /* trailing floating point zeroes */
  1492. PAD(fpprec, zeroes);
  1494. /* left-adjusting padding (always blank) */
  1496. if (doLAdjust)
  1497.     PAD(width - realsz, blanks);
  1499. /* finally, adjust ret */
  1501. ret += (width > realsz) ? width : realsz;
  1502. }
  1503.     }
  1505. /*******************************************************************************
  1506. *
  1507. * putbuf - put characters in a buffer
  1508. *
  1509. * This routine is a support routine for sprintf().
  1510. * This routine copies length bytes from source to destination, leaving the
  1511. * destination buffer pointer pointing at byte following block copied.
  1512. */
  1514. LOCAL STATUS putbuf
  1515.     (
  1516.     char *inbuf,                /* pointer to source buffer */
  1517.     int length,                 /* number of bytes to copy */
  1518.     char **outptr               /* pointer to destination buffer */
  1519.     )
  1520.     {
  1521.     bcopy (inbuf, *outptr, length);
  1522.     *outptr += length;
  1524.     return (OK);
  1525.     }
  1527. /*******************************************************************************
  1528. *
  1529. * printbuf - printf() support routine: print characters in a buffer
  1530. */
  1532. LOCAL STATUS printbuf
  1533.     (
  1534.     char *buf,
  1535.     int nbytes,
  1536.     int fd
  1537.     )
  1538.     {
  1539.     return (write (fd, buf, nbytes) == nbytes ? OK : ERROR);
  1540.     }
  1542. /*******************************************************************************
  1543. *
  1544. * fioRead - read a buffer
  1545. *
  1546. * This routine repeatedly calls the routine read() until <maxbytes> have
  1547. * been read into <buffer>.  If EOF is reached, the number of bytes read
  1548. * will be less than <maxbytes>.
  1549. *
  1550. * RETURNS:
  1551. * The number of bytes read, or ERROR if there is an error during the read
  1552. * operation.
  1553. *
  1554. * SEE ALSO: read()
  1555. */
  1557. int fioRead
  1558.     (
  1559.     int fd, /* file descriptor of file to read */
  1560.     char * buffer, /* buffer to receive input */
  1561.     int maxbytes /* maximum number of bytes to read */
  1562.     )
  1563.     {
  1564.     int original_maxbytes = maxbytes;
  1565.     int nbytes;
  1567.     while (maxbytes > 0)
  1568. {
  1569. nbytes = read (fd, buffer, maxbytes);
  1571. if (nbytes < 0)
  1572.     return (ERROR);
  1574. if (nbytes == 0)
  1575.     return (original_maxbytes - maxbytes);
  1577. maxbytes -= nbytes;
  1578. buffer   += nbytes;
  1579. }
  1581.     return (original_maxbytes);
  1582.     }
  1584. /*******************************************************************************
  1585. *
  1586. * fioRdString - read a string from a file
  1587. *
  1588. * This routine puts a line of input into <string>.  The specified input
  1589. * file descriptor is read until <maxbytes>, an EOF, an EOS, or a newline
  1590. * character is reached.  A newline character or EOF is replaced with EOS,
  1591. * unless <maxbytes> characters have been read.
  1592. *
  1593. * RETURNS:
  1594. * The length of the string read, including the terminating EOS;
  1595. * or EOF if a read error occurred or end-of-file occurred without
  1596. * reading any other character.
  1597. */
  1599. int fioRdString
  1600.     (
  1601.     int fd,             /* fd of device to read */
  1602.     FAST char string[], /* buffer to receive input */
  1603.     int maxbytes        /* max no. of chars to read */
  1604.     )
  1605.     {
  1606.     char c;
  1607.     FAST int nchars = 0;
  1608.     FAST int i = 0;
  1610.     /* read characters until
  1611.      *    1) specified line limit is reached,
  1612.      *    2) end-of-file is reached,
  1613.      *    3) EOS character is read,
  1614.      *    4) newline character is read,
  1615.      * or 5) read error occurs.
  1616.      */
  1618.     while (i < maxbytes)
  1619. {
  1620. nchars = read (fd, &c, 1);
  1621. if (nchars == ERROR) /* if can't read file */
  1622.     break;
  1624. /* check for newline terminator */
  1626. if ((nchars != 1) || (c == 'n') || (c == EOS))
  1627.     {
  1628.     string [i++] = EOS;
  1629.     break;
  1630.     }
  1632. string [i++] = c;
  1633. }
  1636.     if (nchars == ERROR  || ((nchars == 0) && (i == 1)))
  1637. i = EOF;
  1639.     return (i);
  1640.     }
  1642. /*******************************************************************************
  1643. *
  1644. * sscanf - read and convert characters from an ASCII string (ANSI)
  1645. *
  1646. * This routine reads characters from the string <str>, interprets them
  1647. * according to format specifications in the string <fmt>, which specifies
  1648. * the admissible input sequences and how they are to be converted for
  1649. * assignment, using subsequent arguments as pointers to the objects to
  1650. * receive the converted input.
  1651. *
  1652. * If there are insufficient arguments for the format, the behavior is
  1653. * undefined.  If the format is exhausted while arguments remain, the excess
  1654. * arguments are evaluated but are otherwise ignored.
  1655. *
  1656. * The format is a multibyte character sequence, beginning and ending in
  1657. * its initial shift state.  The format is composed of zero or more directives:
  1658. * one or more white-space characters; an ordinary multibyte character (neither
  1659. * `%' nor a white-space character); or a conversion specification.  Each
  1660. * conversion specification is introduced by the `%' character.  After the `%',
  1661. * the following appear in sequence:
  1662. *
  1663. * .iP "" 4
  1664. * An optional assignment-suppressing character `*'.
  1665. * .iP
  1666. * An optional non-zero decimal integer that specifies the maximum field 
  1667. * width.
  1668. * .iP
  1669. * An optional `h', `l' (ell) or `ll' (ell-ell) indicating the size of the 
  1670. * receiving object.  The conversion specifiers `d', `i', and `n' should 
  1671. * be preceded by `h' if the corresponding argument is a pointer to `short 
  1672. * int' rather than a pointer to `int', or by `l' if it is a pointer to 
  1673. * `long int', or by `ll' if it is a pointer to `long long int'.  Similarly, 
  1674. * the conversion specifiers `o', `u', and `x' shall be preceded by `h' if 
  1675. * the corresponding argument is a pointer to `unsigned short int' rather 
  1676. * than a pointer to `unsigned int', or by `l' if it is a pointer to 
  1677. * `unsigned long int', or by `ll' if it is a pointer to `unsigned long 
  1678. * long int'.  Finally, the conversion specifiers `e', `f', and `g' shall 
  1679. * be preceded by `l' if the corresponding argument is a pointer to 
  1680. * `double' rather than a pointer to `float'.  If a `h', `l' or `ll' 
  1681. * appears with any other conversion specifier, the behavior is undefined.
  1682. * .iP
  1683. * &WARNING: ANSI C also specifies an optional `L' in some of the same
  1684. * contexts as `l' above, corresponding to a `long double *' argument.
  1685. * However, the current release of the VxWorks libraries does not support 
  1686. * `long double' data; using the optional `L' gives unpredictable results.
  1687. * .iP
  1688. * A character that specifies the type of conversion to be applied.  The
  1689. * valid conversion specifiers are described below.
  1690. * .LP
  1691. *
  1692. * The sscanf() routine executes each directive of the format in turn.  If a 
  1693. * directive fails, as detailed below, sscanf() returns.  Failures
  1694. * are described as input failures (due to the unavailability of input
  1695. * characters), or matching failures (due to inappropriate input).
  1696. * 
  1697. * A directive composed of white-space character(s) is executed by reading
  1698. * input up to the first non-white-space character (which remains unread),
  1699. * or until no more characters can be read.
  1700. *
  1701. * A directive that is an ordinary multibyte character is executed by reading
  1702. * the next characters of the stream.  If one of the characters differs from
  1703. * one comprising the directive, the directive fails, and the differing and
  1704. * subsequent characters remain unread.
  1705. *
  1706. * A directive that is a conversion specification defines a set of matching
  1707. * input sequences, as described below for each specifier.  A conversion
  1708. * specification is executed in the following steps:
  1709. *
  1710. * Input white-space characters (as specified by the isspace() function) are 
  1711. * skipped, unless the specification includes a `[', `c', or `n' specifier.
  1712. *
  1713. * An input item is read from the stream, unless the specification includes
  1714. * an `n' specifier.  An input item is defined as the longest matching
  1715. * sequence of input characters, unless that exceeds a specified field width,
  1716. * in which case it is the initial subsequence of that length in the
  1717. * sequence.  The first character, if any, after the input item remains
  1718. * unread.  If the length of the input item is zero, the execution of the
  1719. * directive fails:  this condition is a matching failure, unless an error
  1720. * prevented input from the stream, in which case it is an input failure.
  1721. *
  1722. * Except in the case of a `%' specifier, the input item is converted to a
  1723. * type appropriate to the conversion specifier.  If the input item is not a
  1724. * matching sequence, the execution of the directive fails:  this condition
  1725. * is a matching failure.  Unless assignment suppression was indicated by a
  1726. * `*', the result of the conversion is placed in the object pointed to by
  1727. * the first argument following the <fmt> argument that has not already
  1728. * received a conversion result.  If this object does not have an appropriate
  1729. * type, or if the result of the conversion cannot be represented in the
  1730. * space provided, the behavior is undefined.
  1731. *
  1732. * The following conversion specifiers are valid:
  1733. *
  1734. * .iP `d'
  1735. * Matches an optionally signed decimal integer whose format is
  1736. * the same as expected for the subject sequence of the strtol()
  1737. * function with the value 10 for the <base> argument.  The 
  1738. * corresponding argument should be a pointer to `int'.
  1739. * .iP `i'
  1740. * Matches an optionally signed integer, whose format is the
  1741. * same as expected for the subject sequence of the strtol()
  1742. * function with the value 0 for the <base> argument.  The 
  1743. * corresponding argument should be a pointer to `int'.
  1744. * .iP `o'
  1745. * Matches an optionally signed octal integer, whose format is the
  1746. * same as expected for the subject sequence of the strtoul()
  1747. * function with the value 8 for the <base> argument.  The
  1748. * corresponding argument should be a pointer to `unsigned int'.
  1749. * .iP `u'
  1750. * Matches an optionally signed decimal integer, whose format is 
  1751. * the same as expected for the subject sequence of the strtoul()
  1752. * function with the value 10 for the <base> argument.  The
  1753. * corresponding argument should be a pointer to `unsigned int'.
  1754. * .iP `x'
  1755. * Matches an optionally signed hexadecimal integer, whose format is
  1756. * the same as expected for the subject sequence of the strtoul()
  1757. * function with the value 16 for the <base> argument.  The
  1758. * corresponding argument should be a pointer to `unsigned int'.
  1759. * .iP "`e', `f', `g'"
  1760. * Match an optionally signed floating-point number, whose format
  1761. * is the same as expected for the subject string of the strtod()
  1762. * function.  The corresponding argument should be a pointer to `float'.
  1763. * .iP `s'
  1764. * Matches a sequence of non-white-space characters.  The 
  1765. * corresponding argument should be a pointer to the initial
  1766. * character of an array large enough to accept the sequence
  1767. * and a terminating null character, which will be added 
  1768. * automatically.
  1769. * .iP `['
  1770. * Matches a non-empty sequence of characters from a set of 
  1771. * expected characters (the `scanset').  The corresponding argument
  1772. * should be a pointer to the initial character of an array large
  1773. * enough to accept the sequence and a terminating null character,
  1774. * which is added automatically.  The conversion specifier
  1775. * includes all subsequent character in the format string, up to
  1776. * and including the matching right bracket (`]').  The characters
  1777. * between the brackets (the `scanlist') comprise the scanset,
  1778. * unless the character after the left bracket is a circumflex (`^')
  1779. * in which case the scanset contains all characters that do not
  1780. * appear in the scanlist between the circumflex and the right
  1781. * bracket.  If the conversion specifier begins with "[]" or "[^]", the
  1782. * right bracket character is in the scanlist and the next 
  1783. * right bracket character is the matching right bracket that ends
  1784. * the specification; otherwise the first right bracket character
  1785. * is the one that ends the specification.
  1786. * .iP `c'
  1787. * Matches a sequence of characters of the number specified by the
  1788. * field width (1 if no field width is present in the directive).
  1789. * The corresponding argument should be a pointer to the initial 
  1790. * character of an array large enough to accept the sequence.
  1791. * No null character is added.
  1792. * .iP `p'
  1793. * Matches an implementation-defined set of sequences, which should be
  1794. * the same as the set of sequences that may be produced by the %p
  1795. * conversion of the fprintf() function.  The corresponding argument
  1796. * should be a pointer to a pointer to `void'.  VxWorks defines its
  1797. * pointer input field to be consistent with pointers written by the
  1798. * fprintf() function ("0x" hexadecimal notation).  If the input item is
  1799. * a value converted earlier during the same program execution, the
  1800. * pointer that results should compare equal to that value; otherwise
  1801. * the behavior of the %p conversion is undefined.
  1802. * .iP `n'
  1803. * No input is consumed.  The corresponding argument should be a pointer to
  1804. * `int' into which the number of characters read from the input stream so
  1805. * far by this call to sscanf() is written.  Execution of a %n directive does
  1806. * not increment the assignment count returned when sscanf() completes
  1807. * execution.
  1808. * .iP `%'
  1809. * Matches a single `%'; no conversion or assignment occurs.  The
  1810. * complete conversion specification is %%.
  1811. * .LP
  1812. *
  1813. * If a conversion specification is invalid, the behavior is undefined.
  1814. *
  1815. * The conversion specifiers `E', `G', and `X' are also valid and behave the
  1816. * same as `e', `g', and `x', respectively.
  1817. *
  1818. * If end-of-file is encountered during input, conversion is terminated.  If 
  1819. * end-of-file occurs before any characters matching the current directive
  1820. * have been read (other than leading white space, where permitted), execution
  1821. * of the current directive terminates with an input failure; otherwise, unless
  1822. * execution of the current directive is terminated with a matching failure,
  1823. * execution of the following directive (if any) is terminated with an input
  1824. * failure.
  1825. *
  1826. * If conversion terminates on a conflicting input character, the offending
  1827. * input character is left unread in the input stream.  Trailing white space
  1828. * (including new-line characters) is left unread unless matched by a
  1829. * directive.  The success of literal matches and suppressed assignments is
  1830. * not directly determinable other than via the %n directive.
  1831. *
  1832. * INCLUDE FILES: fioLib.h 
  1833. *
  1834. * RETURNS:
  1835. * The number of input items assigned, which can be fewer than provided for,
  1836. * or even zero, in the event of an early matching failure; or EOF if an
  1837. * input failure occurs before any conversion.
  1838. *
  1839. * SEE ALSO: fscanf(), scanf(),
  1840. * .I "American National Standard for Information Systems -"
  1841. * .I "Programming Language - C, ANSI X3.159-1989: Input/Output (stdio.h)"
  1842. *
  1843. * VARARGS2
  1844. */
  1846. int sscanf
  1847.     (
  1848.     const char *  str, /* string to scan */
  1849.     const char *  fmt, /* format string */
  1850.     ...       /* optional arguments to format string */
  1851.     )
  1852.     {
  1853.     int nArgs;
  1854.     int unget;
  1855.     va_list vaList; /* vararg list */
  1857.     va_start (vaList, fmt);
  1858.     nArgs = fioScanV (fmt, getbuf, (int) &str, &unget, vaList);
  1859.     va_end (vaList);
  1861.     return (nArgs);
  1862.     }
  1864. /********************************************************************************
  1865. * getbuf - sscanf() support routine: get next character in string
  1866. *
  1867. * RETURNS: Next character or EOF if empty.
  1868. */
  1870. LOCAL int getbuf
  1871.     (
  1872.     char **str
  1873.     )
  1874.     {
  1875.     int c = (int)(**str);
  1877.     if (c == EOS)
  1878.         return (EOF);
  1880.     ++*str;
  1882.     return (c);
  1883.     }
  1885. /******************************************************************************
  1886. *
  1887. * fioScanV - scan processor
  1888. *
  1889. * NOMANUAL
  1890. */
  1892. int fioScanV
  1893.     (
  1894.     const char *fmt,            /* the format string */
  1895.     FUNCPTR     getRtn,         /* routine to get next character */
  1896.     int         getArg,         /* argument to be passed to get */
  1897.     int *       pUnget,         /* where to return unget char (-1 = no unget) */
  1898.     va_list     vaList          /* vararg list */
  1899.     )
  1900.     {
  1901.     BOOL        suppress;                       /* assignment was suppressed */
  1902.     void *      pArg;
  1903.     int         ch;
  1904.     BOOL        countArg;                       /* FALSE for %n, not counted */
  1905.     BOOL        quit            = FALSE;
  1906.     int         argsAssigned    = 0;
  1907.     int         nchars          = 0;
  1908.  
  1909.     pArg = va_arg (vaList, void *);     /* get first pointer arg */
  1910.  
  1911.     ch = (* getRtn) (getArg);           /* get first char */
  1912.  
  1913.  
  1914.     while (!quit && (*fmt != EOS))
  1915.         {
  1916.         countArg = TRUE;                /* default = count arg assignment */
  1917.  
  1918.         switch (*fmt)
  1919.             {
  1920.             case ' ':
  1921.             case 'n':
  1922.             case 't':                  /* skip white space in string */
  1923.                 ++fmt;
  1924.                 while (isspace (ch))
  1925.                     GET_CHAR (ch, nchars);
  1926.                 break;
  1927.  
  1928.             case '%':                   /* conversion specification */
  1929.                 ++fmt;
  1930.  
  1931.                 /* NOTE: if next char is '%' (i.e. "%%") then a normal match
  1932.                  * of '%' is required: FALL THROUGH to default case
  1933.                  */
  1934.                 if (*fmt != '%')
  1935.                     {
  1937.                     /* Skip white space except for 'c', 'n', '[' specifiers.
  1938.                      * Suppress including %n fields in returned count.
  1939.                      */
  1940.  
  1942.                     switch (*fmt)
  1943.                         {
  1944.                         case 'c':
  1945.                         case '[':
  1946.                             break;
  1948.                         case '*':  /* ignore the '*' for purposes of white
  1949.             * space removal                        */
  1950.     switch(*(fmt+1))
  1951.         {
  1952. case 'c':
  1953. case '[':
  1954.     break;
  1956.                          default:
  1957.                                  while (isspace (ch))
  1958.                                  GET_CHAR (ch, nchars);
  1959. }
  1960.     break;
  1962.                         case 'n':
  1963.                             countArg = FALSE;           /* we don't count %n */
  1964.                             break;
  1965.  
  1966.                         case 'h':                       /* %hn, %ln, %Ln, %lln */
  1967. case 'l':
  1968. case 'L':
  1969.     if ((*(fmt + 1) == 'n') || 
  1970.         ((*fmt == 'l') && (*(fmt + 1) == 'l') && (*(fmt + 2) == 'n'))) 
  1971.                                 {
  1972.         countArg = FALSE;
  1973.         break;
  1974.         }
  1976.                         default:
  1977.                             while (isspace (ch))
  1978.                                 GET_CHAR (ch, nchars);
  1979.                         }
  1980.  
  1981.  
  1982.                     /* Quit if at end of input string, unless spec is %[hl]n */
  1983.  
  1984.                     if (ch == EOF)                      /* if at end of input */                        {
  1985.                         switch (*fmt)
  1986.                             {
  1987.                             case 'n':
  1988.                                 break;                  /* %n is still valid */
  1989.  
  1990.                             case 'h':                   /* also %hn, %ln, %lln */
  1991.                             case 'l':
  1992.     case 'L':
  1993. if ((*(fmt + 1) == 'n') || 
  1994.             ((*fmt == 'l') && (*(fmt + 1) == 'l') && (*(fmt + 2) == 'n'))) 
  1995.                                     {
  1996.             break; /* keep going */
  1997.             }
  1998.                                 /* FALL THROUGH */
  1999.  
  2000.                             default:
  2001.                                 quit = TRUE;
  2002.                                 break;
  2003.                             }
  2004.                         }
  2005.  
  2006.                     /* Scan field in input string */
  2007.  
  2008.                     if (scanField (&fmt, pArg, getRtn, getArg, &suppress, &ch,
  2009.                                    &nchars))
  2010.                         {
  2011.                         /* successful scan */
  2013.                         if (!suppress)
  2014.                             {
  2015.                             if (countArg)               /* unless arg was %n */
  2016.                                 ++argsAssigned;         /*  increment count */
  2017.  
  2018.                             pArg = va_arg (vaList, void *);     /* next arg */
  2019.                             }
  2020.                         }
  2021.                     else
  2022.                         quit = TRUE;          /* unsuccessful */
  2023.                     break;
  2024.                     }
  2025.  
  2026.                 /* NOTE: else of above if FALLS THROUGH to default below! */
  2027.  
  2028.             default:                    /* character to match */
  2029.                 if (ch == *fmt)
  2030.                     {
  2031.                     GET_CHAR (ch, nchars);      /* advance past matched char */
  2032.                     ++fmt;                      /* advance past matched char */
  2033.                     }
  2034.                 else
  2035.                     quit = TRUE;                /* match failed */
  2036.                 break;
  2037.             }
  2038.         }
  2039.  
  2040.     *pUnget = ch;
  2041.  
  2042.     if ((argsAssigned == 0) && (ch == EOF))
  2043.         return (EOF);
  2044.  
  2045.     return (argsAssigned);
  2046.     }
  2047. /********************************************************************************
  2048. * scanField - assign value to argument according to format
  2049. *
  2050. * RETURNS:
  2051. * TRUE if conversion successful, otherwise FALSE;
  2052. * <pSuppress> is set TRUE if assignment was suppressed.
  2053. *
  2054. * NOMANUAL
  2055. */
  2056.  
  2057. /*LOCAL*/ BOOL scanField
  2058.     (
  2059.     const char **ppFmt,          /* conversion specification string */
  2060.     FAST void *  pReturn,        /* where to set result */
  2061.     FUNCPTR      getRtn,
  2062.     int          getArg,
  2063.     BOOL *       pSuppress,      /* set to TRUE if argptr was not assigned */
  2064.     int *        pCh,
  2065.     int *        pNchars
  2066.     )
  2067.     {
  2068.     FAST int    fieldwidth = 0;         /* maximum number of chars to convert.
  2069.                                          * default 0 implies no limit */
  2070.     int         returnSpec = 0;         /* 0, 'h', 'l', ll */
  2071.     FAST const char *pFmt = *ppFmt;     /* ptr to current char in fmt string */
  2072.     FAST int    base;
  2073. #ifdef _WRS_ALTIVEC_SUPPORT
  2074.     VECTOR vec; /* vector value accumulator */
  2075.     BOOL doVector = FALSE;/* AltiVec vector */
  2076.     char Separator = ' '; /* separator for vector elements */
  2077.     char C_Separator = EOS; /* separator for char vector elements */
  2078.     FAST int    ch, ix; /* handy variables for GET_CHAR */
  2079.     char  *vp; /* handy char pointer (short term usage) */
  2080.     FAST int i=4; /* handy integer (short term usage) */
  2082.     while(i--) vec.s32[i] = 0;
  2083. #endif /* _WRS_ALTIVEC_SUPPORT */
  2084.     /* check for assignment suppression */
  2086.     *pSuppress = (*pFmt == '*');
  2087.     if (*pSuppress)
  2088.         {
  2089.         ++pFmt;
  2090.         pReturn = NULL;
  2091.         }
  2092.  
  2093.     /* check for specification of maximum fieldwidth */
  2094.  
  2095.     while (isdigit ((int)*pFmt))
  2096.         fieldwidth = 10 * fieldwidth + (*pFmt++ - '0');
  2098. #ifdef _WRS_ALTIVEC_SUPPORT
  2099.     /* check for separator for vector value */
  2101.     switch (*pFmt)
  2102.         {
  2103.         case ',':
  2104.         case ';':
  2105.         case ':':
  2106.         case '_':
  2107.             Separator = C_Separator = *pFmt++;
  2108.             break;
  2109.         }
  2110. #endif /* _WRS_ALTIVEC_SUPPORT */
  2112.     /* check for specification of size of returned value */
  2113.  
  2114.     switch (*pFmt)
  2115.         {
  2116.         case 'h':
  2117. case 'L':
  2118.     returnSpec = *pFmt++;
  2120. #ifdef _WRS_ALTIVEC_SUPPORT            
  2121.             if (*pFmt == 'v') { pFmt++; doVector = TRUE; }
  2122. #endif /* _WRS_ALTIVEC_SUPPORT */
  2124.     break;
  2125. case 'l':
  2126.             if (*(++pFmt) == 'l')
  2127.         {
  2128.         returnSpec = ll;
  2129.         pFmt++;
  2130.         }
  2131.     else
  2132.         returnSpec = 'l';
  2134. #ifdef _WRS_ALTIVEC_SUPPORT            
  2135.             if (*pFmt == 'v') { pFmt++; doVector = TRUE; }
  2136. #endif /* _WRS_ALTIVEC_SUPPORT */ 
  2138.             break;
  2140. #ifdef _WRS_ALTIVEC_SUPPORT            
  2141.         case 'v':
  2142.             pFmt++;
  2143.             doVector = TRUE;
  2144.                 
  2145.     switch (*pFmt)
  2146. {
  2147. case 'h':
  2148. case 'L':
  2149.     returnSpec = *pFmt++;
  2150.     break;
  2151. case 'l':
  2152.             if (*(++pFmt) == 'l')
  2153.         {
  2154.         returnSpec = ll;
  2155.         pFmt++;
  2156.         }
  2157.             else
  2158.                returnSpec = 'l';
  2159.     break;
  2160. }
  2161.             break;
  2162. #endif /* _WRS_ALTIVEC_SUPPORT */
  2163.         }
  2164.  
  2165. #ifdef _WRS_ALTIVEC_SUPPORT            
  2166.     if (C_Separator && !doVector) return (FALSE); /* unsuccessful conversion */
  2167. #endif /* _WRS_ALTIVEC_SUPPORT */
  2169.     /* set default fieldwidth if not specified */
  2170.  
  2171.     if (fieldwidth == 0)
  2172.         fieldwidth = (*pFmt == 'c') ? 1 : INT_MAX;
  2173.  
  2174.  
  2175.     switch (*pFmt)
  2176.         {
  2177.         case 'c':               /* character, or character array */
  2178. #ifdef _WRS_ALTIVEC_SUPPORT
  2179.     if ( doVector )
  2180.       {
  2181. if (fieldwidth != 1) return (FALSE); /* unsuccessful conversion */
  2183. i  = 16;
  2184. ix = 0;
  2185. ch = *pCh;
  2186. vp = (char*) &vec.s8;
  2188. while (i--) {
  2190. if (ch != EOF)
  2191. {
  2192.      *vp++ = (char) ch;
  2193.      GET_CHAR (ch, ix);
  2194. }
  2195. else return (FALSE); /* unsuccessful conversion */
  2197. if (C_Separator && i)
  2198. {
  2199.     if ( (char)ch != C_Separator ) return (FALSE);
  2200.     GET_CHAR (ch, ix);
  2201. }
  2202. }
  2204. *pCh = ch;
  2205. *pNchars += ix;
  2207. if (pReturn != NULL)
  2208. *((__vector unsigned long *) pReturn) = vec.vul;
  2210.         break;
  2211.       }
  2212. #endif /* _WRS_ALTIVEC_SUPPORT */
  2213.       
  2214.             if (!scanChar ((char *) pReturn, fieldwidth, getRtn, getArg,
  2215.                            pCh, pNchars))
  2216.                 return (FALSE);         /* unsuccessful conversion */
  2217.             break;
  2218.  
  2219.         case 'i':               /* integer */
  2220.         case 'o':               /* octal integer */
  2221.         case 'd':               /* decimal integer */
  2222.         case 'u':               /* unsigned decimal integer */
  2223.         case 'x':               /* hex integer */
  2224.         case 'X':               /* hex integer */
  2225.         case 'p':               /* pointer */
  2226.  
  2227.             switch (*pFmt)
  2228.                 {
  2229.                 case 'i':       base = 0;       break;
  2230.                 case 'o':       base = 8;       break;
  2231.                 case 'd':       base = 10;      break;
  2232.                 case 'u':       base = 10;      break;
  2233.                 case 'x':       base = 16;      break;
  2234.                 case 'X':       base = 16;      break;
  2235.                 case 'p':       base = 16;      break;
  2236.                 default :       base = 0;       break;
  2237.                 }
  2238. #ifdef _WRS_ALTIVEC_SUPPORT
  2239.             if ( doVector )
  2240.       {
  2241. i  = ((returnSpec == 'h') ? 8:4);
  2242. ix = 0;
  2243. ch = *pCh;
  2245. while (i--) {
  2247. if (returnSpec != 'h') /* int, long */
  2248. {
  2249.                 if (!scanNum (base,(void*)&vec.u32[3-i], returnSpec,
  2250.                               fieldwidth, getRtn, getArg, pCh, pNchars))
  2251.                     return (FALSE);         /* unsuccessful conversion */
  2252. }
  2253. else /* short int, AltiVec pixel */
  2254. {
  2255.                 if (!scanNum (base,(void*)&vec.u16[7-i], returnSpec,
  2256.                               fieldwidth, getRtn, getArg, pCh, pNchars))
  2257.                     return (FALSE);         /* unsuccessful conversion */
  2258. }
  2260. if (i)
  2261. {
  2262.     if ( *pCh != Separator ) return (FALSE);
  2263.     GET_CHAR (ch, ix);
  2264.     *pCh = ch;
  2265. }
  2266. }
  2268. *pNchars += ix;
  2270. if (pReturn != NULL)
  2271. *((__vector unsigned long *) pReturn) = vec.vul;
  2273.         break;
  2274.       }
  2275. #endif /* _WRS_ALTIVEC_SUPPORT */
  2277.             if (!scanNum (base, pReturn, returnSpec, fieldwidth, getRtn,
  2278.             getArg, pCh, pNchars))
  2279.                 return (FALSE);         /* unsuccessful conversion */
  2280.             break;
  2281.  
  2282.         case 'e':               /* exponential float */
  2283.         case 'f':               /* float */
  2284.         case 'g':               /* float */
  2285.         case 'E':               /* exponential double */
  2286.         case 'F':               /* double */
  2287.         case 'G':               /* double */
  2288. #ifdef _WRS_ALTIVEC_SUPPORT
  2289.             if ( doVector )
  2290.       {
  2291.       
  2292.         if (fioFltScanRtn == NULL) return (FALSE);
  2294. i  = 4;
  2295. ix = 0;
  2296. ch = *pCh;
  2298. while (i--) 
  2299.   {
  2301.                  if (!(* fioFltScanRtn) ((void*)&vec.f32[3-i], 
  2302.     returnSpec, fieldwidth, 
  2303.     getRtn, getArg, pCh, pNchars))
  2304.                     return (FALSE);    /* unsuccessful conversion */
  2306. if (i)
  2307. {
  2308.     if ( *pCh != Separator ) return (FALSE);
  2309.     GET_CHAR (ch, ix);
  2310.     *pCh = ch;
  2311. }
  2312. }
  2314. *pNchars += ix;
  2316. if (pReturn != NULL)
  2317. *((__vector unsigned long *) pReturn) = vec.vul;
  2319.         break;
  2320.       }
  2321. #endif /* _WRS_ALTIVEC_SUPPORT */
  2323.             if ((fioFltScanRtn == NULL) ||
  2324.                 (!(* fioFltScanRtn) (pReturn, returnSpec, fieldwidth, getRtn,
  2325.                                      getArg, pCh, pNchars)))
  2326.                 return (FALSE);         /* unsuccessful conversion */
  2327.             break;
  2328.  
  2329.         case 's':               /* string */
  2330.             if (!scanString ((char *) pReturn, fieldwidth, getRtn, getArg,
  2331.                              pCh, pNchars))
  2332.                 return (FALSE);         /* unsuccessful conversion */
  2333.             break;
  2334.  
  2335.         case '[':               /* non-space-delimited string */
  2336.             if (!scanCharSet ((char *) pReturn, fieldwidth, pFmt, getRtn,
  2337.                               getArg, pCh, pNchars))
  2338.                 return (FALSE);
  2340.             /* get past format specifier string */
  2341.  
  2342.             while (*pFmt != ']')
  2343.                 ++pFmt;
  2344.             break;
  2345.  
  2346.  
  2347.         case 'n':               /* current number of chars scanned */
  2348.             if (pReturn != NULL)
  2349.                 {
  2350.                 switch (returnSpec)
  2351.                     {
  2352.                     case 'h': *((short *) pReturn) = *pNchars; break;
  2353.                     case 'l': *((long *) pReturn)  = *pNchars; break;
  2354.     case (ll) : *((long long *) pReturn) = *pNchars; break;
  2355.                     default:  *((int *) pReturn)   = *pNchars; break;
  2356.                     }
  2357.                 }
  2358.             break;
  2359.  
  2360.         default:
  2361.             return (FALSE);
  2362.         }
  2363.  
  2364.     *ppFmt = pFmt + 1;          /* update callers format string pointer */
  2365.     
  2366.     return (TRUE);              /* successful conversion */
  2367.     }
  2368. /********************************************************************************
  2369. * scanString - perform conversion of space delineated string
  2370. *
  2371. * RETURNS: TRUE if successful, FALSE if unsuccessful.
  2372. */
  2374. LOCAL BOOL scanString
  2375.     (
  2376.     FAST char * pResult,
  2377.     FAST int    fieldwidth,
  2378.     FAST FUNCPTR getRtn,
  2379.     FAST int    getArg,
  2380.     int *       pCh,
  2381.     int *       pNchars
  2382.     )
  2383.     {
  2384.     FAST int ix = 0;
  2385.     FAST int ch = *pCh;
  2387.     while (ch != EOF && ix < fieldwidth)
  2388.         {
  2389.         if (isspace (ch))
  2390.             break;
  2392.         if (pResult != NULL)
  2393.             *pResult++ = (char)ch;
  2395.         GET_CHAR (ch, ix);
  2396.         }
  2398.     if (pResult != NULL)
  2399.         *pResult = EOS;
  2400.  
  2401.     *pCh = ch;
  2402.     *pNchars += ix;
  2403.  
  2404.     return (ix != 0);
  2405.     }
  2407. /********************************************************************************
  2408. * scanChar - perform character conversion
  2409. *
  2410. * RETURNS: TRUE if successful, FALSE if unsuccessful.
  2411. */
  2413. LOCAL BOOL scanChar
  2414.     (
  2415.     FAST char * pResult,
  2416.     FAST int    fieldwidth,
  2417.     FAST FUNCPTR getRtn,
  2418.     FAST int    getArg,
  2419.     FAST int *  pCh,
  2420.     FAST int *  pNchars
  2421.     )
  2422.     {
  2423.     FAST int ch = *pCh;
  2424.     FAST int ix = 0;
  2426.     while (ch != EOF && ix < fieldwidth)
  2427.         {
  2428.         if (pResult != NULL)
  2429.             *(pResult++) = (char) ch;
  2431.         GET_CHAR (ch, ix);
  2432.         }
  2434.     *pCh = ch;
  2435.     *pNchars += ix;
  2437.     return (ix != 0);
  2438.     }
  2440. /********************************************************************************
  2441. * scanCharSet - perform user-specified string conversion
  2442. *
  2443. * RETURNS: TRUE if successful, FALSE if unsuccessful.
  2444. *
  2445. * NOMANUAL
  2446. */
  2447.  
  2448. BOOL scanCharSet
  2449.     (
  2450.     FAST char * pResult,
  2451.     int         fieldwidth,
  2452.     FAST const char *charsAllowed,   /* The chars (not) allowed in the string */
  2453.     FAST FUNCPTR getRtn,
  2454.     FAST int    getArg,
  2455.     int *       pCh,
  2456.     int *       pNchars
  2457.     )
  2458.     {
  2459. #define NUM_ASCII_CHARS 128
  2460.     char lastChar = 0;
  2461.     char charsAllowedTbl [NUM_ASCII_CHARS];
  2462.     FAST BOOL allowed;
  2463.     int nx;
  2464.     FAST int ix;
  2465.     FAST int ch;
  2466.  
  2467.     if (*charsAllowed++ != '[')         /* skip past the [ */
  2468.         return (FALSE);
  2469.  
  2470.     /* chars in table will (not) be allowed */
  2471.  
  2472.     if (*charsAllowed == '^')
  2473.         {
  2474.         allowed = FALSE;
  2475.         ++charsAllowed;                 /* skip past ^ */
  2476.         }
  2477.     else
  2478.         allowed = TRUE;
  2479.  
  2480.     /* initialize table to (not) allow any chars */
  2481.  
  2482.     for (ix = 0; ix < NUM_ASCII_CHARS; ix++)
  2483.         charsAllowedTbl [ix] = !allowed;
  2484.  
  2485.     /* Check for the first char of the set being '-' or ']', in which case
  2486.      * they are not special chars.
  2487.      */
  2488.  
  2489.     if (*charsAllowed == '-' || *charsAllowed == ']')
  2490.         charsAllowedTbl [(int)(*charsAllowed++)] = allowed;
  2491.  
  2492.     /* Examine the rest of the set, and put it into the table. */
  2493.  
  2494.     for (nx = 0; nx < NUM_ASCII_CHARS; nx++)
  2495.         {
  2496.         if (*charsAllowed == ']' || *charsAllowed == EOS)
  2497.             break;      /* all done */
  2498.  
  2499.         /* Check if its of the form x-y.
  2500.          * If x<y, then allow all chars in the range.
  2501.          * If x>=y, its not a legal range.  Just allow '-'.
  2502.          * Also, if the '-' is the last char before the final ']',
  2503.          * just allow '-'.
  2504.          */
  2505.         if (*charsAllowed == '-' &&
  2506.             (lastChar < *(charsAllowed+1) && *(charsAllowed+1) != ']'))
  2507.             {
  2508.             ++charsAllowed;     /* skip - */
  2509.             for (ix = lastChar; ix <= *charsAllowed; ix++)
  2510.                 charsAllowedTbl [ix] = allowed;
  2511.             }
  2512.         else
  2513.             {
  2514.             charsAllowedTbl [(int)(*charsAllowed)] = allowed;
  2515.             lastChar = *charsAllowed;
  2516.             }
  2517.         ++charsAllowed;
  2518.         }
  2519.  
  2520.     /* make sure that ']' appeared */
  2521.  
  2522.     if (*charsAllowed != ']')
  2523.         return (FALSE);
  2524.  
  2525.     /* Copy the appropriate portion of the string */
  2526.  
  2527.     ix = 0;
  2528.     ch = *pCh;
  2529.  
  2530.     while (ch != EOF && ix < fieldwidth)
  2531.         {
  2532.         if (! charsAllowedTbl [(int)ch])
  2533.             break;
  2534.  
  2535.         if (pResult != NULL)
  2536.             *pResult++ = (char) ch;
  2537.  
  2538.         GET_CHAR (ch, ix);
  2539.         }
  2540.  
  2541. /* If no characters were copied from the input, then this assignment
  2542. has failed */
  2544. if(ix == 0)
  2545. return (FALSE);
  2546. else
  2547. {
  2549.      if (pResult != NULL)
  2550.          *pResult = EOS;
  2551.  
  2552.      *pCh = ch;
  2553.      *pNchars += ix;
  2555.      return (TRUE);
  2556. }
  2557.     }
  2558. /********************************************************************************
  2559. * scanNum - perform number conversion
  2560. *
  2561. * RETURNS: TRUE if successful, FALSE if unsuccessful.
  2562. */
  2563.  
  2564. LOCAL BOOL scanNum
  2565.     (
  2566.     int         base,
  2567.     FAST void * pReturn,
  2568.     int         returnSpec,
  2569.     int         fieldwidth,
  2570.     FAST FUNCPTR getRtn,
  2571.     FAST int    getArg,
  2572.     int *       pCh,
  2573.     int *       pNchars
  2574.     )
  2575.     {
  2576.     int         dig;                    /* current digit */
  2577.     BOOL        neg     = FALSE;        /* negative or positive? */
  2578.     long long   num     = 0;            /* scanned number */
  2579.     FAST int    ix      = 0;            /* present used width */
  2580.     FAST int    ch      = *pCh;         /* current character */
  2581.  
  2582.     /* check for sign */
  2583.  
  2584.     if (ix < fieldwidth)
  2585.         {
  2586.         if ((char)ch == '+' || (neg = ((char)ch == '-')))
  2587.             GET_CHAR (ch, ix);
  2588.         }
  2589.  
  2590.  
  2591.     /* check for optional 0 or 0x */
  2592.  
  2593.     if (ix < fieldwidth && ch == '0')
  2594.         {
  2595.         GET_CHAR (ch, ix);
  2596.  
  2597.         if ((ix < fieldwidth) &&
  2598.             (ch == 'x' || ch == 'X') &&
  2599.             (base == 16 || base == 0))
  2600.             {
  2601.             base = 16;
  2602.             GET_CHAR (ch, ix);
  2603.             }
  2604.         else if (base == 0)
  2605.             base = 8;
  2606.         }
  2607.     else
  2608.         {
  2609.         /* default base is 10 */
  2610.         if (base == 0)
  2611.             base = 10;
  2612.         }
  2613.  
  2614.  
  2615.     /* scan digits */
  2616.  
  2617.     while (ch != EOF && ix < fieldwidth)
  2618.         {
  2619.         if (isdigit (ch))
  2620.             dig = ch - '0';
  2621.         else if (islower (ch))
  2622.             dig = ch - 'a' + 10;
  2623.         else if (isupper (ch))
  2624.             dig = ch - 'A' + 10;
  2625.         else
  2626.             break;
  2627.  
  2628.         if (dig >= base)
  2629.             break;
  2630.  
  2631.         num = (num * base) + dig;
  2632.  
  2633.         GET_CHAR (ch, ix);
  2634.         }
  2635.  
  2636.  
  2637.     /* check that we scanned at least one character */
  2638.  
  2639.     if (ix == 0)
  2640.         return (FALSE);
  2641.  
  2642.  
  2643.     /* return value to caller */
  2644.  
  2645.     if (neg)
  2646.         num = -num;
  2647.  
  2648.     if (pReturn != NULL)
  2649.         {
  2650.         switch (returnSpec)
  2651.             {
  2652.             case 'h': *((short *) pReturn) = num; break;
  2653.             case 'l': *((long *) pReturn)  = num; break;
  2654.             case (ll) : *((long long *) pReturn) = num; break;
  2655.             default:  *((int *) pReturn)   = num; break;
  2656.             }
  2657.         }
  2658.  
  2659.     *pCh = ch;
  2660.     *pNchars += ix;
  2661.  
  2662.     return (ix != 0);
  2663.     }