1522 lines
38 KiB
C
1522 lines
38 KiB
C
/*
|
|
*******************************************************************************
|
|
* *
|
|
* COPYRIGHT: *
|
|
* (C) Copyright International Business Machines Corporation, 1998 *
|
|
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
|
|
* US Government Users Restricted Rights - Use, duplication, or disclosure *
|
|
* restricted by GSA ADP Schedule Contract with IBM Corp. *
|
|
* *
|
|
*******************************************************************************
|
|
*
|
|
* File uscanf.c
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
* 12/02/98 stephen Creation.
|
|
* 03/13/99 stephen Modified for new C API.
|
|
*******************************************************************************
|
|
*/
|
|
|
|
#include "uchar.h"
|
|
|
|
#include "uscanf.h"
|
|
#include "uscanf_p.h"
|
|
#include "uscanset.h"
|
|
#include "ustdio.h"
|
|
#include "ufile.h"
|
|
#include "ustring.h"
|
|
#include "locbund.h"
|
|
#include "umutex.h"
|
|
#include "unum.h"
|
|
#include "udat.h"
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <float.h>
|
|
#include <limits.h>
|
|
#include <wchar.h>
|
|
|
|
|
|
u_scanf_handler g_u_scanf_handlers [256];
|
|
u_scanf_info g_u_scanf_infos [256];
|
|
bool_t g_u_scanf_inited = FALSE;
|
|
|
|
int32_t
|
|
u_fscanf( UFILE *f,
|
|
const char *patternSpecification,
|
|
... )
|
|
{
|
|
va_list ap;
|
|
int32_t converted;
|
|
|
|
va_start(ap, patternSpecification);
|
|
converted = u_vfscanf(f, patternSpecification, ap);
|
|
va_end(ap);
|
|
|
|
return converted;
|
|
}
|
|
|
|
int32_t
|
|
u_fscanf_u( UFILE *f,
|
|
const UChar *patternSpecification,
|
|
... )
|
|
{
|
|
va_list ap;
|
|
int32_t converted;
|
|
|
|
va_start(ap, patternSpecification);
|
|
converted = u_vfscanf_u(f, patternSpecification, ap);
|
|
va_end(ap);
|
|
|
|
return converted;
|
|
}
|
|
|
|
int32_t
|
|
u_vfscanf( UFILE *f,
|
|
const char *patternSpecification,
|
|
va_list ap)
|
|
{
|
|
int32_t converted;
|
|
UChar *pattern;
|
|
|
|
/* convert from the default codepage to Unicode */
|
|
pattern = ufmt_defaultCPToUnicode(patternSpecification,
|
|
strlen(patternSpecification));
|
|
if(pattern == 0) {
|
|
return 0;
|
|
}
|
|
|
|
/* do the work */
|
|
converted = u_vfscanf_u(f, pattern, ap);
|
|
|
|
/* clean up */
|
|
free(pattern);
|
|
|
|
return converted;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_register_handler (UChar spec,
|
|
u_scanf_info info,
|
|
u_scanf_handler handler)
|
|
{
|
|
/* lock the cache */
|
|
umtx_lock(0);
|
|
|
|
/* add to our list of function pointers */
|
|
g_u_scanf_infos[ (unsigned char) spec ] = info;
|
|
g_u_scanf_handlers[ (unsigned char) spec ] = handler;
|
|
|
|
/* unlock the cache */
|
|
umtx_unlock(0);
|
|
return 0;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_skip_leading_ws(UFILE *stream,
|
|
UChar pad)
|
|
{
|
|
UChar c;
|
|
int32_t count = 0;
|
|
|
|
/* skip all leading ws in the stream */
|
|
while( ((c = u_fgetc(stream)) != 0xFFFF) && (c == pad || ufmt_isws(c)) )
|
|
++count;
|
|
|
|
/* put the final character back on the stream */
|
|
if(c != 0xFFFF)
|
|
u_fungetc(c, stream);
|
|
|
|
return count;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_simple_percent_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* we don't need any arguments */
|
|
return 0;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_simple_percent_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
/* make sure the next character in the stream is a percent */
|
|
if(u_fgetc(stream) != 0x0025)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_string_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type string */
|
|
argtypes[0] = ufmt_string;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_string_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
UChar c;
|
|
int32_t count;
|
|
const UChar *source;
|
|
UConverter *conv;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
char *arg = (char*)(args[0].ptrValue);
|
|
char *alias = arg;
|
|
char *limit;
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* get the string one character at a time, truncating to the width */
|
|
count = 0;
|
|
|
|
/* open the default converter */
|
|
conv = ucnv_open(ucnv_getDefaultName(), &status);
|
|
|
|
if(FAILURE(status))
|
|
return -1;
|
|
|
|
/* since there is no real limit, just use a reasonable value */
|
|
limit = alias + 2048;
|
|
|
|
while( ((c = u_fgetc(stream)) != 0xFFFF) &&
|
|
(c != info->fPadChar && ! ufmt_isws(c)) &&
|
|
(info->fWidth == -1 || count < info->fWidth) ) {
|
|
|
|
/* put the character from the stream onto the target */
|
|
source = &c;
|
|
|
|
/* convert the character to the default codepage */
|
|
ucnv_fromUnicode(conv, &alias, limit, &source, source + 1,
|
|
NULL, TRUE, &status);
|
|
|
|
if(FAILURE(status))
|
|
return -1;
|
|
|
|
/* increment the count */
|
|
++count;
|
|
}
|
|
|
|
/* put the final character we read back on the stream */
|
|
if(c != 0xFFFF)
|
|
u_fungetc(c, stream);
|
|
|
|
/* add the terminator */
|
|
*alias = 0x00;
|
|
|
|
/* clean up */
|
|
ucnv_close(conv);
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_ustring_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type ustring */
|
|
argtypes[0] = ufmt_ustring;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_ustring_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
UChar c;
|
|
int32_t count;
|
|
UChar *arg = (UChar*)(args[0].ptrValue);
|
|
UChar *alias = arg;
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* get the string one character at a time, truncating to the width */
|
|
count = 0;
|
|
|
|
while( ((c = u_fgetc(stream)) != 0xFFFF) &&
|
|
(c != info->fPadChar && ! ufmt_isws(c)) &&
|
|
(info->fWidth == -1 || count < info->fWidth) ) {
|
|
|
|
/* put the character from the stream onto the target */
|
|
*alias++ = c;
|
|
|
|
/* increment the count */
|
|
++count;
|
|
}
|
|
|
|
/* put the final character we read back on the stream */
|
|
if(c != 0xFFFF)
|
|
u_fungetc(c, stream);
|
|
|
|
/* add the terminator */
|
|
*alias = 0x0000;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
|
|
int32_t
|
|
u_scanf_count_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type count */
|
|
argtypes[0] = ufmt_count;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_count_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int *converted = (int*)(args[0].ptrValue);
|
|
|
|
/* in the special case of count, the u_scanf_spec_info's width */
|
|
/* will contain the # of items converted thus far */
|
|
*converted = info->fWidth;
|
|
|
|
/* we converted 0 args */
|
|
return 0;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_integer_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type int */
|
|
argtypes[0] = ufmt_int;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_integer_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
long *num = (long*) (args[0].ptrValue);
|
|
UNumberFormat *format;
|
|
int32_t parsePos = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getNumberFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* parse the number */
|
|
*num = unum_parse(format, stream->fUCPos, len, &parsePos, &status);
|
|
|
|
/* mask off any necessary bits */
|
|
if(info->fIsShort)
|
|
*num &= SHRT_MAX;
|
|
else if(! info->fIsLong || ! info->fIsLongLong)
|
|
*num &= INT_MAX;
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += parsePos;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_double_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type double */
|
|
argtypes[0] = ufmt_double;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_double_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
double *num = (double*) (args[0].ptrValue);
|
|
UNumberFormat *format;
|
|
int32_t parsePos = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getNumberFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* parse the number */
|
|
*num = unum_parseDouble(format, stream->fUCPos, len, &parsePos, &status);
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLong_double)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += parsePos;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_scientific_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type double */
|
|
argtypes[0] = ufmt_double;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_scientific_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
double *num = (double*) (args[0].ptrValue);
|
|
UNumberFormat *format;
|
|
int32_t parsePos = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getScientificFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* parse the number */
|
|
*num = unum_parseDouble(format, stream->fUCPos, len, &parsePos, &status);
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLong_double)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += parsePos;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_scidbl_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type double */
|
|
argtypes[0] = ufmt_double;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_scidbl_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
double *num = (double*) (args[0].ptrValue);
|
|
UNumberFormat *scientificFormat, *genericFormat;
|
|
int32_t scientificResult, genericResult;
|
|
int32_t scientificParsePos = 0, genericParsePos = 0;
|
|
UErrorCode scientificStatus = U_ZERO_ERROR;
|
|
UErrorCode genericStatus = U_ZERO_ERROR;
|
|
bool_t useScientific;
|
|
|
|
|
|
/* since we can't determine by scanning the characters whether */
|
|
/* a number was formatted in the 'f' or 'g' styles, parse the */
|
|
/* string with both formatters, and assume whichever one */
|
|
/* parsed the most is the correct formatter to use */
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* get the formatters */
|
|
scientificFormat = u_locbund_getScientificFormat(stream->fBundle);
|
|
genericFormat = u_locbund_getNumberFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(scientificFormat == 0 || genericFormat == 0)
|
|
return 0;
|
|
|
|
/* parse the number using each format*/
|
|
|
|
scientificResult = unum_parseDouble(scientificFormat, stream->fUCPos, len,
|
|
&scientificParsePos, &scientificStatus);
|
|
|
|
genericResult = unum_parseDouble(genericFormat, stream->fUCPos, len,
|
|
&genericParsePos, &genericStatus);
|
|
|
|
/* determine which parse made it farther */
|
|
useScientific = scientificParsePos > genericParsePos;
|
|
|
|
/* stash the result in num */
|
|
*num = useScientific ? scientificResult : genericResult;
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLong_double)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += useScientific ? scientificParsePos : genericParsePos;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_currency_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type double */
|
|
argtypes[0] = ufmt_double;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_currency_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
double *num = (double*) (args[0].ptrValue);
|
|
UNumberFormat *format;
|
|
int32_t parsePos = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getCurrencyFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* parse the number */
|
|
*num = unum_parseDouble(format, stream->fUCPos, len, &parsePos, &status);
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLong_double)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += parsePos;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_percent_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type double */
|
|
argtypes[0] = ufmt_double;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_percent_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
double *num = (double*) (args[0].ptrValue);
|
|
UNumberFormat *format;
|
|
int32_t parsePos = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getPercentFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* parse the number */
|
|
*num = unum_parseDouble(format, stream->fUCPos, len, &parsePos, &status);
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLong_double)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += parsePos;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_date_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type Date */
|
|
argtypes[0] = ufmt_date;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_date_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
UDate *date = (UDate*) (args[0].ptrValue);
|
|
UDateFormat *format;
|
|
int32_t parsePos = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getDateFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* parse the number */
|
|
*date = udat_parse(format, stream->fUCPos, len, &parsePos, &status);
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += parsePos;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_time_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type Date */
|
|
argtypes[0] = ufmt_date;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_time_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
UDate *time = (UDate*) (args[0].ptrValue);
|
|
UDateFormat *format;
|
|
int32_t parsePos = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getTimeFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* parse the number */
|
|
*time = udat_parse(format, stream->fUCPos, len, &parsePos, &status);
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += parsePos;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_char_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type char */
|
|
argtypes[0] = ufmt_char;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_char_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
UChar uc;
|
|
char *result;
|
|
char *c = (char*)(args[0].ptrValue);
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* get the character from the stream, truncating to the width */
|
|
if(info->fWidth == -1 || info->fWidth > 1)
|
|
uc = u_fgetc(stream);
|
|
|
|
/* handle EOF */
|
|
if(uc == 0xFFFF)
|
|
return -1;
|
|
|
|
/* convert the character to the default codepage */
|
|
result = ufmt_unicodeToDefaultCP(&uc, 1);
|
|
*c = result[0];
|
|
|
|
/* clean up */
|
|
free(result);
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_uchar_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type uchar */
|
|
argtypes[0] = ufmt_uchar;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_uchar_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
UChar *c = (UChar*)(args[0].ptrValue);
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* get the character from the stream, truncating to the width */
|
|
if(info->fWidth == -1 || info->fWidth > 1)
|
|
*c = u_fgetc(stream);
|
|
|
|
/* handle EOF */
|
|
if(*c == 0xFFFF)
|
|
return -1;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_spellout_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type double */
|
|
argtypes[0] = ufmt_double;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_spellout_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
double *num = (double*) (args[0].ptrValue);
|
|
UNumberFormat *format;
|
|
int32_t parsePos = 0;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* get the formatter */
|
|
format = u_locbund_getSpelloutFormat(stream->fBundle);
|
|
|
|
/* handle error */
|
|
if(format == 0)
|
|
return 0;
|
|
|
|
/* parse the number */
|
|
*num = unum_parseDouble(format, stream->fUCPos, len, &parsePos, &status);
|
|
|
|
/* mask off any necessary bits */
|
|
/* if(! info->fIsLong_double)
|
|
num &= DBL_MAX;*/
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += parsePos;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_hex_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type int */
|
|
argtypes[0] = ufmt_int;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_hex_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
long *num = (long*) (args[0].ptrValue);
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* check for alternate form */
|
|
if( *(stream->fUCPos) == 0x0030 &&
|
|
(*(stream->fUCPos + 1) == 0x0078 || *(stream->fUCPos + 1) == 0x0058) ) {
|
|
|
|
/* skip the '0' and 'x' or 'X' if present */
|
|
stream->fUCPos += 2;
|
|
len -= 2;
|
|
}
|
|
|
|
/* parse the number */
|
|
*num = ufmt_utol(stream->fUCPos, &len, 16);
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += len;
|
|
|
|
/* mask off any necessary bits */
|
|
if(info->fIsShort)
|
|
*num &= SHRT_MAX;
|
|
else if(! info->fIsLong || ! info->fIsLongLong)
|
|
*num &= INT_MAX;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_octal_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type int */
|
|
argtypes[0] = ufmt_int;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_octal_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
long *num = (long*) (args[0].ptrValue);
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* parse the number */
|
|
*num = ufmt_utol(stream->fUCPos, &len, 8);
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += len;
|
|
|
|
/* mask off any necessary bits */
|
|
if(info->fIsShort)
|
|
*num &= SHRT_MAX;
|
|
else if(! info->fIsLong || ! info->fIsLongLong)
|
|
*num &= INT_MAX;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_pointer_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type void* */
|
|
argtypes[0] = ufmt_pointer;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_pointer_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
int32_t len;
|
|
void *p = (void*)(args[0].ptrValue);
|
|
|
|
|
|
/* skip all ws in the stream */
|
|
u_scanf_skip_leading_ws(stream, info->fPadChar);
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* parse the pointer - cast to void** to assign to *p */
|
|
*(void**)p = (void*) ufmt_utol(stream->fUCPos, &len, 16);
|
|
|
|
/* update the stream's position to reflect consumed data */
|
|
stream->fUCPos += len;
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_scanset_info(const u_scanf_spec_info *info,
|
|
int32_t *argtypes,
|
|
int32_t n)
|
|
{
|
|
/* handle error */
|
|
if(n < 1)
|
|
return 0;
|
|
|
|
/* we need 1 argument of type char* */
|
|
argtypes[0] = ufmt_string;
|
|
return 1;
|
|
}
|
|
|
|
int32_t
|
|
u_scanf_scanset_handler(UFILE *stream,
|
|
const u_scanf_spec_info *info,
|
|
ufmt_args *args,
|
|
const UChar *fmt,
|
|
int32_t *consumed)
|
|
{
|
|
u_scanf_scanset scanset;
|
|
int32_t len;
|
|
bool_t success;
|
|
UChar c;
|
|
const UChar *source;
|
|
UConverter *conv;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
char *s = (char*) (args[0].ptrValue);
|
|
char *alias, *limit;
|
|
|
|
|
|
/* fill the stream's internal buffer */
|
|
ufile_fill_uchar_buffer(stream);
|
|
|
|
/* determine the size of the stream's buffer */
|
|
len = stream->fUCLimit - stream->fUCPos;
|
|
|
|
/* truncate to the width, if specified */
|
|
if(info->fWidth != -1)
|
|
len = ufmt_min(len, info->fWidth);
|
|
|
|
/* alias the target */
|
|
alias = s;
|
|
limit = alias + len;
|
|
|
|
/* parse the scanset from the fmt string */
|
|
*consumed = u_strlen(fmt);
|
|
success = u_scanf_scanset_init(&scanset, fmt, consumed);
|
|
|
|
/* increment consumed by one to eat the final ']' */
|
|
++(*consumed);
|
|
|
|
/* open the default converter */
|
|
conv = ucnv_open(ucnv_getDefaultName(), &status);
|
|
|
|
/* verify that the parse was successful and the converter opened */
|
|
if(! success || FAILURE(status))
|
|
return -1;
|
|
|
|
/* grab characters one at a time and make sure they are in the scanset */
|
|
while( (c = u_fgetc(stream)) != 0xFFFF && alias < limit) {
|
|
if(u_scanf_scanset_in(&scanset, c)) {
|
|
source = &c;
|
|
/* convert the character to the default codepage */
|
|
ucnv_fromUnicode(conv, &alias, limit, &source, source + 1,
|
|
NULL, TRUE, &status);
|
|
|
|
if(FAILURE(status))
|
|
return -1;
|
|
}
|
|
/* if the character's not in the scanset, break out */
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* put the final character we read back on the stream */
|
|
if(c != 0xFFFF)
|
|
u_fungetc(c, stream);
|
|
|
|
/* if we didn't match at least 1 character, fail */
|
|
if(alias == s)
|
|
return -1;
|
|
/* otherwise, add the terminator */
|
|
else
|
|
*alias = 0x00;
|
|
|
|
/* clean up */
|
|
ucnv_close(conv);
|
|
|
|
/* we converted 1 arg */
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
u_scanf_init()
|
|
{
|
|
int32_t i;
|
|
/*Mutex *lock;*/
|
|
|
|
/* if we're already inited, do nothing */
|
|
if(g_u_scanf_inited)
|
|
return;
|
|
|
|
/* lock the cache */
|
|
umtx_lock(0);
|
|
|
|
/* if we're already inited, do nothing */
|
|
if(g_u_scanf_inited) {
|
|
umtx_unlock(0);
|
|
return;
|
|
}
|
|
|
|
/* initialize all handlers and infos to 0 */
|
|
for(i = 0; i < 256; ++i) {
|
|
g_u_scanf_infos[i] = 0;
|
|
g_u_scanf_handlers[i] = 0;
|
|
}
|
|
|
|
/* register the handlers for standard specifiers */
|
|
/* don't use u_scanf_register_handler to avoid mutex creation */
|
|
|
|
/* handle '%' */
|
|
g_u_scanf_infos[ 0x0025 ] = u_scanf_simple_percent_info;
|
|
g_u_scanf_handlers[ 0x0025 ] = u_scanf_simple_percent_handler;
|
|
|
|
/* handle 's' */
|
|
g_u_scanf_infos[ 0x0073 ] = u_scanf_string_info;
|
|
g_u_scanf_handlers[ 0x0073 ] = u_scanf_string_handler;
|
|
|
|
/* handle 'U' */
|
|
g_u_scanf_infos[ 0x0055 ] = u_scanf_ustring_info;
|
|
g_u_scanf_handlers[ 0x0055 ] = u_scanf_ustring_handler;
|
|
|
|
/* handle 'n' */
|
|
g_u_scanf_infos[ 0x006E ] = u_scanf_count_info;
|
|
g_u_scanf_handlers[ 0x006E ] = u_scanf_count_handler;
|
|
|
|
/* handle 'd' */
|
|
g_u_scanf_infos[ 0x0064 ] = u_scanf_integer_info;
|
|
g_u_scanf_handlers[ 0x0064 ] = u_scanf_integer_handler;
|
|
|
|
/* handle 'i' */
|
|
g_u_scanf_infos[ 0x0069 ] = u_scanf_integer_info;
|
|
g_u_scanf_handlers[ 0x0069 ] = u_scanf_integer_handler;
|
|
|
|
/* handle 'u' */
|
|
g_u_scanf_infos[ 0x0075 ] = u_scanf_integer_info;
|
|
g_u_scanf_handlers[ 0x0075 ] = u_scanf_integer_handler;
|
|
|
|
/* handle 'f' */
|
|
g_u_scanf_infos[ 0x0066 ] = u_scanf_double_info;
|
|
g_u_scanf_handlers[ 0x0066 ] = u_scanf_double_handler;
|
|
|
|
/* handle 'e' */
|
|
g_u_scanf_infos[ 0x0065 ] = u_scanf_scientific_info;
|
|
g_u_scanf_handlers[ 0x0065 ] = u_scanf_scientific_handler;
|
|
|
|
/* handle 'E' */
|
|
g_u_scanf_infos[ 0x0045 ] = u_scanf_scientific_info;
|
|
g_u_scanf_handlers[ 0x0045 ] = u_scanf_scientific_handler;
|
|
|
|
/* handle 'g' */
|
|
g_u_scanf_infos[ 0x0067 ] = u_scanf_scidbl_info;
|
|
g_u_scanf_handlers[ 0x0067 ] = u_scanf_scidbl_handler;
|
|
|
|
/* handle 'G' */
|
|
g_u_scanf_infos[ 0x0047 ] = u_scanf_scidbl_info;
|
|
g_u_scanf_handlers[ 0x0047 ] = u_scanf_scidbl_handler;
|
|
|
|
/* handle 'M' */
|
|
g_u_scanf_infos[ 0x004D ] = u_scanf_currency_info;
|
|
g_u_scanf_handlers[ 0x004D ] = u_scanf_currency_handler;
|
|
|
|
/* handle 'P' */
|
|
g_u_scanf_infos[ 0x0050 ] = u_scanf_percent_info;
|
|
g_u_scanf_handlers[ 0x0050 ] = u_scanf_percent_handler;
|
|
|
|
/* handle 'D' */
|
|
g_u_scanf_infos[ 0x0044 ] = u_scanf_date_info;
|
|
g_u_scanf_handlers[ 0x0044 ] = u_scanf_date_handler;
|
|
|
|
/* handle 'T' */
|
|
g_u_scanf_infos[ 0x0054 ] = u_scanf_time_info;
|
|
g_u_scanf_handlers[ 0x0054 ] = u_scanf_time_handler;
|
|
|
|
/* handle 'c' */
|
|
g_u_scanf_infos[ 0x0063 ] = u_scanf_char_info;
|
|
g_u_scanf_handlers[ 0x0063 ] = u_scanf_char_handler;
|
|
|
|
/* handle 'K' */
|
|
g_u_scanf_infos[ 0x004B ] = u_scanf_uchar_info;
|
|
g_u_scanf_handlers[ 0x004B ] = u_scanf_uchar_handler;
|
|
|
|
/* handle 'V' */
|
|
g_u_scanf_infos[ 0x0056 ] = u_scanf_spellout_info;
|
|
g_u_scanf_handlers[ 0x0056 ] = u_scanf_spellout_handler;
|
|
|
|
/* handle 'x' */
|
|
g_u_scanf_infos[ 0x0078 ] = u_scanf_hex_info;
|
|
g_u_scanf_handlers[ 0x0078 ] = u_scanf_hex_handler;
|
|
|
|
/* handle 'X' */
|
|
g_u_scanf_infos[ 0x0058 ] = u_scanf_hex_info;
|
|
g_u_scanf_handlers[ 0x0058 ] = u_scanf_hex_handler;
|
|
|
|
/* handle 'o' */
|
|
g_u_scanf_infos[ 0x006F ] = u_scanf_octal_info;
|
|
g_u_scanf_handlers[ 0x006F ] = u_scanf_octal_handler;
|
|
|
|
/* handle 'p' */
|
|
g_u_scanf_infos[ 0x0070 ] = u_scanf_pointer_info;
|
|
g_u_scanf_handlers[ 0x0070 ] = u_scanf_pointer_handler;
|
|
|
|
/* handle '[' */
|
|
g_u_scanf_infos[ 0x005B ] = u_scanf_scanset_info;
|
|
g_u_scanf_handlers[ 0x005B ] = u_scanf_scanset_handler;
|
|
|
|
/* we're finished */
|
|
g_u_scanf_inited = TRUE;
|
|
|
|
/* unlock the cache */
|
|
umtx_unlock(0);
|
|
}
|
|
|
|
|
|
#define U_SCANF_MAX_ARGS 32
|
|
#define UP_PERCENT 0x0025
|
|
|
|
int32_t
|
|
u_vfscanf_u( UFILE *f,
|
|
const UChar *patternSpecification,
|
|
va_list ap)
|
|
{
|
|
u_scanf_spec spec;
|
|
const UChar *alias;
|
|
int32_t count, converted, temp;
|
|
|
|
int32_t num_args_wanted;
|
|
int32_t ufmt_types [U_SCANF_MAX_ARGS];
|
|
ufmt_args args [U_SCANF_MAX_ARGS];
|
|
|
|
u_scanf_info info;
|
|
u_scanf_handler handler;
|
|
|
|
int32_t cur_arg;
|
|
|
|
|
|
/* init our function tables */
|
|
if(! g_u_scanf_inited)
|
|
u_scanf_init();
|
|
|
|
/* alias the pattern */
|
|
alias = patternSpecification;
|
|
|
|
/* haven't converted anything yet */
|
|
converted = 0;
|
|
|
|
/* iterate through the pattern */
|
|
for(;;) {
|
|
|
|
/* match any characters up to the next '%' */
|
|
while(*alias != UP_PERCENT && *alias != 0x0000 && u_fgetc(f) == *alias) {
|
|
*alias++;
|
|
}
|
|
|
|
/* if we aren't at a '%', or if we're at end of string, break*/
|
|
if(*alias != UP_PERCENT || *alias == 0x0000)
|
|
break;
|
|
|
|
/* parse the specifier */
|
|
count = u_scanf_parse_spec(alias, &spec);
|
|
|
|
/* update the pointer in pattern */
|
|
alias += count;
|
|
|
|
/* skip the argument, if necessary */
|
|
if(spec.fSkipArg)
|
|
va_arg(ap, int);
|
|
|
|
/* query the info function for argument information */
|
|
info = g_u_scanf_infos[ (unsigned char) spec.fInfo.fSpec ];
|
|
if(info != 0) {
|
|
num_args_wanted = (*info)(&spec.fInfo,
|
|
ufmt_types,
|
|
U_SCANF_MAX_ARGS);
|
|
}
|
|
else
|
|
num_args_wanted = 0;
|
|
|
|
/* fill in the requested arguments */
|
|
for(cur_arg = 0;
|
|
cur_arg < num_args_wanted && cur_arg < U_SCANF_MAX_ARGS;
|
|
++cur_arg) {
|
|
|
|
switch(ufmt_types[cur_arg]) {
|
|
|
|
case ufmt_count:
|
|
args[cur_arg].intValue = va_arg(ap, int);
|
|
/* set the spec's width to the # of items converted */
|
|
spec.fInfo.fWidth = converted;
|
|
break;
|
|
|
|
case ufmt_int:
|
|
args[cur_arg].ptrValue = va_arg(ap, int*);
|
|
break;
|
|
|
|
case ufmt_char:
|
|
args[cur_arg].ptrValue = va_arg(ap, int*);
|
|
break;
|
|
|
|
case ufmt_wchar:
|
|
args[cur_arg].ptrValue = va_arg(ap, wchar_t*);
|
|
break;
|
|
|
|
case ufmt_string:
|
|
args[cur_arg].ptrValue = va_arg(ap, char*);
|
|
break;
|
|
|
|
case ufmt_wstring:
|
|
args[cur_arg].ptrValue = va_arg(ap, wchar_t*);
|
|
break;
|
|
|
|
case ufmt_pointer:
|
|
args[cur_arg].ptrValue = va_arg(ap, void*);
|
|
break;
|
|
|
|
case ufmt_float:
|
|
args[cur_arg].ptrValue = va_arg(ap, float*);
|
|
break;
|
|
|
|
case ufmt_double:
|
|
args[cur_arg].ptrValue = va_arg(ap, double*);
|
|
break;
|
|
|
|
case ufmt_date:
|
|
args[cur_arg].ptrValue = va_arg(ap, UDate*);
|
|
break;
|
|
|
|
case ufmt_ustring:
|
|
args[cur_arg].ptrValue = va_arg(ap, UChar*);
|
|
break;
|
|
|
|
case ufmt_uchar:
|
|
args[cur_arg].ptrValue = va_arg(ap, int*);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* call the handler function */
|
|
handler = g_u_scanf_handlers[ (unsigned char) spec.fInfo.fSpec ];
|
|
if(handler != 0) {
|
|
|
|
/* reset count */
|
|
count = 0;
|
|
|
|
temp = (*handler)(f, &spec.fInfo, args, alias, &count);
|
|
|
|
/* if the handler encountered an error condition, break */
|
|
if(temp == -1)
|
|
break;
|
|
|
|
/* add to the # of items converted */
|
|
converted += temp;
|
|
|
|
/* update the pointer in pattern */
|
|
alias += count;
|
|
}
|
|
|
|
/* just ignore unknown tags */
|
|
|
|
}
|
|
|
|
/* return # of items converted */
|
|
return converted;
|
|
}
|
|
|